psychological.go

package api

import (
	"encoding/json"
)

// PsychologicalCompetence represents the payload for the psychological competence section.
type PsychologicalCompetence struct {
	PayloadIsIncompetent Payload `json:"IsIncompetent" sql:"-"`
	PayloadList          Payload `json:"List" sql:"-"`

	IsIncompetent *Branch     `json:"-"`
	List          *Collection `json:"-"`
}

// Unmarshal bytes in to the entity properties.
func (entity *PsychologicalCompetence) Unmarshal(raw []byte) error {
	err := json.Unmarshal(raw, entity)
	if err != nil {
		return err
	}

	isIncompetent, err := entity.PayloadIsIncompetent.Entity()
	if err != nil {
		return err
	}
	entity.IsIncompetent = isIncompetent.(*Branch)

	list, err := entity.PayloadList.Entity()
	if err != nil {
		return err
	}
	entity.List = list.(*Collection)

	return err
}

// Marshal to payload structure
func (entity *PsychologicalCompetence) Marshal() Payload {
	if entity.IsIncompetent != nil {
		entity.PayloadIsIncompetent = entity.IsIncompetent.Marshal()
	}
	if entity.List != nil {
		entity.PayloadList = entity.List.Marshal()
	}
	return MarshalPayloadEntity("psychological.competence", entity)
}

// ClearNoBranches clears the "no" answers on application rejection
func (entity *PsychologicalCompetence) ClearNoBranches() error {
	entity.IsIncompetent.ClearNo()

	nestedErr := entity.List.ClearNestedHasNo("Appeals")
	if nestedErr != nil {
		return nestedErr
	}

	entity.List.ClearBranchNo()
	return nil
}

// PsychologicalConsultations represents the payload for the psychological consultations section.
type PsychologicalConsultations struct {
	PayloadConsulted Payload `json:"Consulted" sql:"-"`
	PayloadList      Payload `json:"List" sql:"-"`

	Consulted *Branch     `json:"-"`
	List      *Collection `json:"-"`
}

// Unmarshal bytes in to the entity properties.
func (entity *PsychologicalConsultations) Unmarshal(raw []byte) error {
	err := json.Unmarshal(raw, entity)
	if err != nil {
		return err
	}

	consulted, err := entity.PayloadConsulted.Entity()
	if err != nil {
		return err
	}
	entity.Consulted = consulted.(*Branch)

	list, err := entity.PayloadList.Entity()
	if err != nil {
		return err
	}
	entity.List = list.(*Collection)

	return err
}

// Marshal to payload structure
func (entity *PsychologicalConsultations) Marshal() Payload {
	if entity.Consulted != nil {
		entity.PayloadConsulted = entity.Consulted.Marshal()
	}
	if entity.List != nil {
		entity.PayloadList = entity.List.Marshal()
	}
	return MarshalPayloadEntity("psychological.consultations", entity)
}

// ClearNoBranches clears the "no" answers on application rejection
func (entity *PsychologicalConsultations) ClearNoBranches() error {
	entity.Consulted.ClearNo()

	nestedErr := entity.List.ClearNestedHasNo("Appeals")
	if nestedErr != nil {
		return nestedErr
	}

	entity.List.ClearBranchNo()
	return nil
}

// PsychologicalDiagnoses represents the payload for the psychological diagnosis section.
type PsychologicalDiagnoses struct {
	PayloadDiagnosed     Payload `json:"Diagnosed" sql:"-"`
	PayloadDidNotConsult Payload `json:"DidNotConsult" sql:"-"`
	PayloadDiagnosisList Payload `json:"DiagnosisList" sql:"-"`
	PayloadInTreatment   Payload `json:"InTreatment" sql:"-"`
	PayloadTreatmentList Payload `json:"TreatmentList" sql:"-"`

	Diagnosed     *Branch     `json:"-"`
	DidNotConsult *Branch     `json:"-"`
	DiagnosisList *Collection `json:"-"`
	InTreatment   *Branch     `json:"-"`
	TreatmentList *Collection `json:"-"`
}

// Unmarshal bytes in to the entity properties.
func (entity *PsychologicalDiagnoses) Unmarshal(raw []byte) error {
	err := json.Unmarshal(raw, entity)
	if err != nil {
		return err
	}

	diagnosed, err := entity.PayloadDiagnosed.Entity()
	if err != nil {
		return err
	}
	entity.Diagnosed = diagnosed.(*Branch)

	didNotConsult, err := entity.PayloadDidNotConsult.Entity()
	if err != nil {
		return err
	}
	entity.DidNotConsult = didNotConsult.(*Branch)

	diagnosisList, err := entity.PayloadDiagnosisList.Entity()
	if err != nil {
		return err
	}
	entity.DiagnosisList = diagnosisList.(*Collection)

	inTreatment, err := entity.PayloadInTreatment.Entity()
	if err != nil {
		return err
	}
	entity.InTreatment = inTreatment.(*Branch)

	treatmentList, err := entity.PayloadTreatmentList.Entity()
	if err != nil {
		return err
	}
	entity.TreatmentList = treatmentList.(*Collection)

	return err
}

// Marshal to payload structure
func (entity *PsychologicalDiagnoses) Marshal() Payload {
	if entity.Diagnosed != nil {
		entity.PayloadDiagnosed = entity.Diagnosed.Marshal()
	}
	if entity.DidNotConsult != nil {
		entity.PayloadDidNotConsult = entity.DidNotConsult.Marshal()
	}
	if entity.DiagnosisList != nil {
		entity.PayloadDiagnosisList = entity.DiagnosisList.Marshal()
	}
	if entity.InTreatment != nil {
		entity.PayloadInTreatment = entity.InTreatment.Marshal()
	}
	if entity.TreatmentList != nil {
		entity.PayloadTreatmentList = entity.TreatmentList.Marshal()
	}
	return MarshalPayloadEntity("psychological.diagnoses", entity)
}

// ClearNoBranches clears the "no" answers on application rejection
func (entity *PsychologicalDiagnoses) ClearNoBranches() error {
	entity.Diagnosed.ClearNo()
	entity.DiagnosisList.ClearBranchNo()
	entity.DidNotConsult.ClearNo()
	entity.InTreatment.ClearNo()
	entity.TreatmentList.ClearBranchNo()
	return nil
}

// PsychologicalHospitalizations represents the payload for the psychological hospitalizations section.
type PsychologicalHospitalizations struct {
	PayloadHospitalized Payload `json:"Hospitalized" sql:"-"`
	PayloadList         Payload `json:"List" sql:"-"`

	Hospitalized *Branch     `json:"-"`
	List         *Collection `json:"-"`
}

// Unmarshal bytes in to the entity properties.
func (entity *PsychologicalHospitalizations) Unmarshal(raw []byte) error {
	err := json.Unmarshal(raw, entity)
	if err != nil {
		return err
	}

	hospitalized, err := entity.PayloadHospitalized.Entity()
	if err != nil {
		return err
	}
	entity.Hospitalized = hospitalized.(*Branch)

	list, err := entity.PayloadList.Entity()
	if err != nil {
		return err
	}
	entity.List = list.(*Collection)

	return err
}

// Marshal to payload structure
func (entity *PsychologicalHospitalizations) Marshal() Payload {
	if entity.Hospitalized != nil {
		entity.PayloadHospitalized = entity.Hospitalized.Marshal()
	}
	if entity.List != nil {
		entity.PayloadList = entity.List.Marshal()
	}
	return MarshalPayloadEntity("psychological.hospitalizations", entity)
}

// ClearNoBranches clears the "no" answers on application rejection
func (entity *PsychologicalHospitalizations) ClearNoBranches() error {
	entity.Hospitalized.ClearNo()
	entity.List.ClearBranchNo()
	return nil
}

// PsychologicalExisting represents the payload for the psychological existing conditions section.
type PsychologicalExisting struct {
	PayloadHasCondition            Payload `json:"HasCondition" sql:"-"`
	PayloadReceivedTreatment       Payload `json:"ReceivedTreatment" sql:"-"`
	PayloadExplanation             Payload `json:"Explanation" sql:"-"`
	PayloadTreatmentList           Payload `json:"TreatmentList" sql:"-"`
	PayloadDidNotFollow            Payload `json:"DidNotFollow" sql:"-"`
	PayloadDidNotFollowExplanation Payload `json:"DidNotFollowExplanation" sql:"-"`

	HasCondition            *Branch     `json:"-"`
	ReceivedTreatment       *Radio      `json:"-"`
	Explanation             *Textarea   `json:"-"`
	TreatmentList           *Collection `json:"-"`
	DidNotFollow            *Branch     `json:"-"`
	DidNotFollowExplanation *Textarea   `json:"-"`
}

// Unmarshal bytes in to the entity properties.
func (entity *PsychologicalExisting) Unmarshal(raw []byte) error {
	err := json.Unmarshal(raw, entity)
	if err != nil {
		return err
	}

	hasCondition, err := entity.PayloadHasCondition.Entity()
	if err != nil {
		return err
	}
	entity.HasCondition = hasCondition.(*Branch)

	receivedTreatment, err := entity.PayloadReceivedTreatment.Entity()
	if err != nil {
		return err
	}
	entity.ReceivedTreatment = receivedTreatment.(*Radio)

	explanation, err := entity.PayloadExplanation.Entity()
	if err != nil {
		return err
	}
	entity.Explanation = explanation.(*Textarea)

	treatmentList, err := entity.PayloadTreatmentList.Entity()
	if err != nil {
		return err
	}
	entity.TreatmentList = treatmentList.(*Collection)

	didNotFollow, err := entity.PayloadDidNotFollow.Entity()
	if err != nil {
		return err
	}
	entity.DidNotFollow = didNotFollow.(*Branch)

	didNotFollowExplanation, err := entity.PayloadDidNotFollowExplanation.Entity()
	if err != nil {
		return err
	}
	entity.DidNotFollowExplanation = didNotFollowExplanation.(*Textarea)

	return err
}

// Marshal to payload structure
func (entity *PsychologicalExisting) Marshal() Payload {
	if entity.HasCondition != nil {
		entity.PayloadHasCondition = entity.HasCondition.Marshal()
	}
	if entity.ReceivedTreatment != nil {
		entity.PayloadReceivedTreatment = entity.ReceivedTreatment.Marshal()
	}
	if entity.Explanation != nil {
		entity.PayloadExplanation = entity.Explanation.Marshal()
	}
	if entity.TreatmentList != nil {
		entity.PayloadTreatmentList = entity.TreatmentList.Marshal()
	}
	if entity.DidNotFollow != nil {
		entity.PayloadDidNotFollow = entity.DidNotFollow.Marshal()
	}
	if entity.DidNotFollowExplanation != nil {
		entity.PayloadDidNotFollowExplanation = entity.DidNotFollowExplanation.Marshal()
	}
	return MarshalPayloadEntity("psychological.conditions", entity)
}