src/Entity/Cases.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\CaseRepository;
  6. use Doctrine\Common\Collections\{ArrayCollection, Collection};
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Gedmo\Mapping\Annotation as Gedmo;
  9. use Symfony\Component\Validator\Constraints as Assert;
  11. #[ORM\Entity(repositoryClass: CaseRepository::class), ORM\Table(name: 'cases')]
  12. class Cases implements \Stringable
  13. {
  14.     #[ORM\Id, ORM\GeneratedValue, ORM\Column(type: 'integer')]
  15.     private $id;
  17.     #[ORM\Column(type: 'string', length: 40)]
  18.     private string $mrdId = 'MRD-0001';
  20.     #[ORM\ManyToOne(targetEntity: Hospital::class), ORM\JoinColumn(nullable: false)]
  21.     private $hospital;
  23.     #[ORM\ManyToOne(targetEntity: Patient::class), ORM\JoinColumn(nullable: false)]
  24.     private $patient;
  26.     #[ORM\ManyToOne(targetEntity: User::class), ORM\JoinColumn(name: 'doctor_id')]
  27.     private $doctor;
  29.     #[ORM\ManyToOne(targetEntity: Cases::class)]
  30.     private $prevCase;
  32.     #[ORM\Column(type: 'string', length: 255), Assert\NotBlank]
  33.     private $patientCategory;
  35.     #[ORM\Column(type: 'text', nullable: true)]
  36.     private $familyHistory;
  38.     #[ORM\Column(type: 'text', nullable: true)]
  39.     private $medicalHistory;
  41.     #[ORM\Column(type: 'text', nullable: true)]
  42.     private $medicineHistory;
  44.     #[ORM\Column(type: 'text', nullable: true)]
  45.     private $abha_number;
  47.     #[ORM\ManyToOne(targetEntity: DiseaseCategory::class)]
  48.     private $diseaseCategory;
  50.     #[ORM\ManyToOne(targetEntity: Icd10CauseGroup::class)]
  51.     private $icd10CauseGroup;
  53.     #[ORM\ManyToOne(targetEntity: Icd10CauseSubGroup::class)]
  54.     private $icd10CauseSubGroup;
  56.     #[ORM\ManyToOne(targetEntity: Icd10Disease::class)]
  57.     private $icd10Disease;
  59.     #[ORM\Column(type: 'text', nullable: true)]
  60.     private $currentDiseaseHistory;
  62.     #[ORM\Column(type: 'boolean')]
  63.     private bool $isLab = true;
  65.     #[ORM\Column(type: 'text', nullable: true)]
  66.     private $confirmedDiagnosis;
  68.     #[ORM\Column(type: 'string', length: 7, nullable: true)]
  69.     private $temparature;
  71.     #[ORM\Column(type: 'string', length: 7, nullable: true)]
  72.     private $cns;
  74.     #[ORM\Column(type: 'string', length: 7, nullable: true)]
  75.     private $endrocine;
  77.     #[ORM\Column(type: 'string', length: 7, nullable: true)]
  78.     private $excretory;
  80.     #[ORM\Column(type: 'string', length: 7, nullable: true)]
  81.     private $pulse;
  83.     #[ORM\Column(type: 'string', length: 7, nullable: true)]
  84.     #[Assert\Length(
  85.         min: 2,
  86.         max: 3,
  87.         minMessage: 'BP Sys  must be at least {{ limit }} characters long',
  88.         maxMessage: 'BP Sys cannot be longer than {{ limit }} characters'
  89.     )]
  90.     #[Assert\Regex(pattern: '/^[0-9]*$/', message: 'BP Sys cannot contain a Characters')]
  91.     private $bpUpper;
  93.     #[ORM\Column(type: 'string', length: 7, nullable: true)]
  94.     #[Assert\Length(
  95.         min: 2,
  96.         max: 3,
  97.         minMessage: 'BP Dia  must be at least {{ limit }} characters long',
  98.         maxMessage: 'BP Dia cannot be longer than {{ limit }} characters'
  99.     )]
  100.     #[Assert\Regex(pattern: '/^[0-9]*$/', message: 'BP Dia cannot contain a Characters')]
  101.     private $bpLower;
  103.     #[ORM\Column(type: 'string', length: 7, nullable: true)]
  104.     #[Assert\Length(
  105.         min: 2,
  106.         max: 3,
  107.         minMessage: 'Respiration  must be at least {{ limit }} characters long',
  108.         maxMessage: 'Respiration cannot be longer than {{ limit }} characters'
  109.     )]
  110.     #[Assert\Regex(pattern: '/^[0-9]*$/', message: 'Respiration cannot contain a Characters')]
  111.     private $respiration;
  113.     #[ORM\Column(type: 'string', length: 7, nullable: true)]
  114.     private $auscultation;
  116.     #[ORM\Column(type: 'text', nullable: true)]
  117.     private $localExamination;
  119.     #[ORM\OneToMany(targetEntity: CaseClinicalPattern::class, mappedBy: 'case', orphanRemoval: true)]
  120.     private $clinicalPatterns;
  122.     #[ORM\OneToMany(targetEntity: CaseProvisionalExamination::class, mappedBy: 'case', orphanRemoval: true)]
  123.     private $provisionalExaminations;
  125.     #[ORM\OneToMany(targetEntity: CaseProvisionalDiagnosis::class, mappedBy: 'case', orphanRemoval: true)]
  126.     private $provisionalDiagnosis;
  128.     #[ORM\OneToMany(targetEntity: CaseSymptom::class, mappedBy: 'case', orphanRemoval: true)]
  129.     #[ORM\JoinColumn(nullable: true)]
  130.     private $symptoms;
  132.     #[ORM\OneToMany(targetEntity: CaseNcd::class, mappedBy: 'case', orphanRemoval: true)]
  133.     #[ORM\JoinColumn(nullable: true)]
  134.     private $ncds;
  136.     #[ORM\OneToMany(targetEntity: CaseReferral::class, mappedBy: 'case', orphanRemoval: true)]
  137.     private $referrals;
  139.     #[ORM\OneToMany(targetEntity: CaseLaboratory::class, mappedBy: 'case', orphanRemoval: true)]
  140.     private $labTests;
  142.     #[ORM\Column(type: 'boolean')]
  143.     private bool $isMedicine = false;
  145.     #[ORM\Column(type: 'boolean')]
  146.     private bool $isWard = false;
  148.     #[ORM\Column(type: 'date', nullable: true)]
  149.     private $followUpDate;
  151.     #[ORM\Column(type: 'boolean')]
  152.     private bool $isPmDone = false;
  154.     #[ORM\Column(type: 'boolean')]
  155.     private bool $isDeathCertGen = false;
  157.     #[ORM\Column(type: 'boolean')]
  158.     private bool $isBirthCertGen = false;
  160.     #[ORM\Column(type: 'boolean')]
  161.     private bool $isClosed = false;
  163.     #[ORM\Column(type: 'boolean')]
  164.     private bool $isReopened = false;
  166.     #[ORM\Column(type: 'boolean')]
  167.     private bool $isOpinion = false;
  169.     #[ORM\Column(type: 'boolean')]
  170.     private bool $isReferral = false;
  172.     #[ORM\Column(type: 'text', nullable: true)]
  173.     private $emergencyStaffNotes;
  175.     #[ORM\Column(type: 'text', nullable: true)]
  176.     private $pharmacyStaffNotes;
  178.     #[ORM\Column(type: 'text', nullable: true)]
  179.     private $wardStaffNotes;
  181.     #[ORM\OneToOne(targetEntity: WardBed::class, mappedBy: 'case', cascade: ['persist', 'remove'])]
  182.     private $wardBed;
  184.     #[ORM\Column(type: 'text', nullable: true)]
  185.     private $pharmacyPatientNotes;
  187.     #[ORM\Column(type: 'string', length: 100, nullable: true)]
  188.     private $closureReason;
  190.     #[Gedmo\Timestampable(on: 'create'), ORM\Column(type: 'datetime')]
  191.     private $createdAt;
  193.     #[Gedmo\Timestampable(on: 'update'), ORM\Column(type: 'datetime')]
  194.     private $updatedAt;
  196.     #[ORM\Column(name: 'lab_test_status', type: 'string', nullable: true, columnDefinition: "enum('Pending', 'Sample taken', 'Completed')")]
  197.     private $labTestStatus;
  199.     #[ORM\Column(name: 'case_medicine_status', type: 'string', nullable: true, columnDefinition: "enum('Pending', 'Completed')")]
  200.     private $caseMedicineStatus;
  202.     #[ORM\Column(name: 'ward_medicine_status', type: 'string', nullable: true, columnDefinition: "enum('Pending', 'Completed')")]
  203.     private $wardMedicineStatus;
  205.     #[Gedmo\Blameable(on: 'create'), ORM\ManyToOne(targetEntity: User::class), ORM\JoinColumn(name: 'created_by')]
  206.     private $createdBy;
  208.     #[Gedmo\Blameable(on: 'update'), ORM\ManyToOne(targetEntity: User::class), ORM\JoinColumn(name: 'updated_by')]
  209.     private $updatedBy;
  211.     #[ORM\OneToOne(targetEntity: DeliveryDetail::class, mappedBy: 'case', cascade: ['persist', 'remove'])]
  212.     private $deliveryDetail;
  214.     #[ORM\OneToOne(mappedBy: 'case', targetEntity: InjuredInfo::class, cascade: ['persist', 'remove'])]
  215.     private $injuredInfo;
  217.     #[ORM\OneToOne(mappedBy: 'case', targetEntity: PostMortemReport::class, cascade: ['persist', 'remove'])]
  218.     private $postMortemReport;
  220.     #[ORM\OneToOne(mappedBy: 'case', targetEntity: DeathCertificate::class, cascade: ['persist', 'remove'])]
  221.     private $deathCertificate;
  223.     #[ORM\OneToOne(mappedBy: 'case', targetEntity: BirthCertificate::class, cascade: ['persist', 'remove'])]
  224.     private $birthCertificate;
  226.     public function __construct()
  227.     {
  228.         $this->clinicalPatterns = new ArrayCollection();
  229.         $this->provisionalExaminations = new ArrayCollection();
  230.         $this->provisionalDiagnosis = new ArrayCollection();
  231.         $this->symptoms = new ArrayCollection();
  232.         $this->ncds = new ArrayCollection();
  233.         $this->referrals = new ArrayCollection();
  234.         $this->labTests = new ArrayCollection();
  235.     }
  237.     public function getId(): ?int
  238.     {
  239.         return $this->id;
  240.     }
  242.     public function getMrdId(): ?string
  243.     {
  244.         return $this->mrdId;
  245.     }
  247.     public function setMrdId(string $mrdId): self
  248.     {
  249.         $this->mrdId = $mrdId;
  251.         return $this;
  252.     }
  254.     public function getHospital(): ?Hospital
  255.     {
  256.         return $this->hospital;
  257.     }
  259.     public function setHospital(Hospital $hospital): self
  260.     {
  261.         $this->hospital = $hospital;
  263.         return $this;
  264.     }
  266.     public function getPatient(): ?Patient
  267.     {
  268.         return $this->patient;
  269.     }
  271.     public function setPatient(Patient $patient): self
  272.     {
  273.         $this->patient = $patient;
  275.         return $this;
  276.     }
  278.     public function getDoctor(): ?User
  279.     {
  280.         return $this->doctor;
  281.     }
  282.     public function setDoctor(User $doctor): self
  283.     {
  284.         $this->doctor = $doctor;
  286.         return $this;
  287.     }
  289.     public function getPrevCase(): ?Cases
  290.     {
  291.         return $this->prevCase;
  292.     }
  294.     public function setPrevCase(Cases $prevCase): self
  295.     {
  296.         $this->prevCase = $prevCase;
  298.         return $this;
  299.     }
  301.     public function getTemparature(): ?string
  302.     {
  303.         return $this->temparature;
  304.     }
  306.     public function setTemparature(?string $temparature): self
  307.     {
  308.         $this->temparature = $temparature;
  310.         return $this;
  311.     }
  313.     public function getCns(): ?string
  314.     {
  315.         return $this->cns;
  316.     }
  318.     public function setCns(?string $cns): self
  319.     {
  320.         $this->cns = strip_tags($cns);
  322.         return $this;
  323.     }
  325.     public function getEndrocine(): ?string
  326.     {
  327.         return $this->endrocine;
  328.     }
  330.     public function setEndrocine(?string $endrocine): self
  331.     {
  332.         $this->endrocine = strip_tags($endrocine);
  334.         return $this;
  335.     }
  337.     public function getExcretory(): ?string
  338.     {
  339.         return $this->excretory;
  340.     }
  342.     public function setExcretory(?string $excretory): self
  343.     {
  344.         $this->excretory = strip_tags($excretory);
  346.         return $this;
  347.     }
  349.     public function getCreatedAt(): ?\DateTimeInterface
  350.     {
  351.         return $this->createdAt;
  352.     }
  354.     public function getUpdatedAt(): ?\DateTimeInterface
  355.     {
  356.         return $this->updatedAt;
  357.     }
  359.     public function getDiseaseCategory(): ?DiseaseCategory
  360.     {
  361.         return $this->diseaseCategory;
  362.     }
  364.     public function setDiseaseCategory(?DiseaseCategory $diseaseCategory): self
  365.     {
  366.         $this->diseaseCategory = $diseaseCategory;
  368.         return $this;
  369.     }
  371.     public function getIcd10CauseGroup(): ?Icd10CauseGroup
  372.     {
  373.         return $this->icd10CauseGroup;
  374.     }
  376.     public function setIcd10CauseGroup(?Icd10CauseGroup $icd10CauseGroup): self
  377.     {
  378.         $this->icd10CauseGroup = $icd10CauseGroup;
  380.         return $this;
  381.     }
  383.     public function getIcd10CauseSubGroup(): ?Icd10CauseSubGroup
  384.     {
  385.         return $this->icd10CauseSubGroup;
  386.     }
  388.     public function setIcd10CauseSubGroup(?Icd10CauseSubGroup $icd10CauseSubGroup): self
  389.     {
  390.         $this->icd10CauseSubGroup = $icd10CauseSubGroup;
  392.         return $this;
  393.     }
  395.     public function getIcd10Disease(): ?Icd10Disease
  396.     {
  397.         return $this->icd10Disease;
  398.     }
  400.     public function setIcd10Disease(?Icd10Disease $icd10Disease): self
  401.     {
  402.         $this->icd10Disease = $icd10Disease;
  404.         return $this;
  405.     }
  407.     public function getPatientCategory(): ?string
  408.     {
  409.         return $this->patientCategory;
  410.     }
  412.     public function setPatientCategory(?string $patientCategory): self
  413.     {
  414.         $this->patientCategory = $patientCategory;
  416.         return $this;
  417.     }
  419.     public function getFamilyHistory(): ?string
  420.     {
  421.         return $this->familyHistory;
  422.     }
  424.     public function setFamilyHistory(?string $familyHistory): self
  425.     {
  426.         $this->familyHistory = strip_tags($familyHistory);
  428.         return $this;
  429.     }
  431.     public function getMedicalHistory(): ?string
  432.     {
  433.         return $this->medicalHistory;
  434.     }
  436.     public function setMedicalHistory(?string $medicalHistory): self
  437.     {
  438.         $this->medicalHistory = strip_tags($medicalHistory);
  440.         return $this;
  441.     }
  443.     public function getMedicineHistory(): ?string
  444.     {
  445.         return $this->medicineHistory;
  446.     }
  448.     public function setMedicineHistory(?string $medicineHistory): self
  449.     {
  450.         $this->medicineHistory = strip_tags($medicineHistory);
  452.         return $this;
  453.     }
  455.     public function getCurrentDiseaseHistory(): ?string
  456.     {
  457.         return $this->currentDiseaseHistory;
  458.     }
  460.     public function setCurrentDiseaseHistory(?string $currentDiseaseHistory): self
  461.     {
  462.         $this->currentDiseaseHistory = strip_tags($currentDiseaseHistory);
  464.         return $this;
  465.     }
  467.     public function getIsLab(): ?bool
  468.     {
  469.         return $this->isLab;
  470.     }
  472.     public function setIsLab(bool $isLab): self
  473.     {
  474.         $this->isLab = $isLab;
  476.         return $this;
  477.     }
  478.     public function getAbhanumber(): ?string
  479.     {
  480.         return $this->abha_number;
  481.     }
  483.     public function setAbhanumber(string $AbhaNumber): self
  484.     {
  485.         $this->abha_number = $AbhaNumber;
  487.         return $this;
  488.     }
  490.     public function getConfirmedDiagnosis(): ?string
  491.     {
  492.         return $this->confirmedDiagnosis;
  493.     }
  495.     public function setConfirmedDiagnosis(?string $confirmedDiagnosis): self
  496.     {
  497.         $this->confirmedDiagnosis = strip_tags($confirmedDiagnosis);
  499.         return $this;
  500.     }
  502.     public function getPulse(): ?string
  503.     {
  504.         return $this->pulse;
  505.     }
  507.     public function setPulse(?string $pulse): self
  508.     {
  509.         $this->pulse = $pulse;
  511.         return $this;
  512.     }
  514.     public function getBpUpper(): ?string
  515.     {
  516.         return $this->bpUpper;
  517.     }
  519.     public function setBpUpper(?string $bpUpper): self
  520.     {
  521.         $this->bpUpper = $bpUpper;
  523.         return $this;
  524.     }
  526.     public function getBpLower(): ?string
  527.     {
  528.         return $this->bpLower;
  529.     }
  531.     public function setBpLower(?string $bpLower): self
  532.     {
  533.         $this->bpLower = $bpLower;
  535.         return $this;
  536.     }
  538.     public function getRespiration(): ?string
  539.     {
  540.         return $this->respiration;
  541.     }
  543.     public function setRespiration(?string $respiration): self
  544.     {
  545.         $this->respiration = $respiration;
  547.         return $this;
  548.     }
  550.     public function getAuscultation(): ?string
  551.     {
  552.         return $this->auscultation;
  553.     }
  555.     public function setAuscultation(?string $auscultation): self
  556.     {
  557.         $this->auscultation = $auscultation;
  559.         return $this;
  560.     }
  562.     public function getLocalExamination(): ?string
  563.     {
  564.         return $this->localExamination;
  565.     }
  567.     public function setLocalExamination(string $localExamination): self
  568.     {
  569.         $this->localExamination = strip_tags($localExamination);
  571.         return $this;
  572.     }
  574.     public function getIsMedicine(): ?bool
  575.     {
  576.         return $this->isMedicine;
  577.     }
  579.     public function setIsMedicine(bool $isMedicine): self
  580.     {
  581.         $this->isMedicine = $isMedicine;
  583.         return $this;
  584.     }
  586.     public function getIsWard(): ?bool
  587.     {
  588.         return $this->isWard;
  589.     }
  591.     public function setIsWard(bool $isWard): self
  592.     {
  593.         $this->isWard = $isWard;
  595.         return $this;
  596.     }
  598.     public function getFollowUpDate(): ?\DateTimeInterface
  599.     {
  600.         return $this->followUpDate;
  601.     }
  603.     public function setFollowUpDate(?\DateTimeInterface $followUpDate): self
  604.     {
  605.         $this->followUpDate = $followUpDate;
  607.         return $this;
  608.     }
  610.     public function getIsDeathCertGen(): ?bool
  611.     {
  612.         return $this->isDeathCertGen;
  613.     }
  615.     public function setIsDeathCertGen(bool $isDeathCertGen): self
  616.     {
  617.         $this->isDeathCertGen = $isDeathCertGen;
  619.         return $this;
  620.     }
  622.     public function getIsBirthCertGen(): ?bool
  623.     {
  624.         return $this->isBirthCertGen;
  625.     }
  627.     public function setIsBirthCertGen(bool $isBirthCertGen): self
  628.     {
  629.         $this->isBirthCertGen = $isBirthCertGen;
  631.         return $this;
  632.     }
  634.     public function getIsPmDone(): ?bool
  635.     {
  636.         return $this->isPmDone;
  637.     }
  639.     public function setIsPmDone(bool $isPmDone): self
  640.     {
  641.         $this->isPmDone = $isPmDone;
  643.         return $this;
  644.     }
  646.     public function getIsClosed(): ?bool
  647.     {
  648.         return $this->isClosed;
  649.     }
  651.     public function setIsClosed(bool $isClosed): self
  652.     {
  653.         $this->isClosed = $isClosed;
  655.         return $this;
  656.     }
  658.     public function getIsReopened(): ?bool
  659.     {
  660.         return $this->isReopened;
  661.     }
  663.     public function setIsReopened(bool $isReopened): self
  664.     {
  665.         $this->isReopened = $isReopened;
  667.         return $this;
  668.     }
  670.     public function getIsOpinion(): ?bool
  671.     {
  672.         return $this->isOpinion;
  673.     }
  675.     public function setIsOpinion(bool $isOpinion): self
  676.     {
  677.         $this->isOpinion = $isOpinion;
  679.         return $this;
  680.     }
  682.     public function getIsReferral(): ?bool
  683.     {
  684.         return $this->isReferral;
  685.     }
  687.     public function setIsReferral(bool $isReferral): self
  688.     {
  689.         $this->isReferral = $isReferral;
  691.         return $this;
  692.     }
  694.     public function getEmergencyStaffNotes(): ?string
  695.     {
  696.         return $this->emergencyStaffNotes;
  697.     }
  699.     public function setEmergencyStaffNotes(?string $emergencyStaffNotes): self
  700.     {
  701.         $this->emergencyStaffNotes = $emergencyStaffNotes;
  703.         return $this;
  704.     }
  706.     public function getPharmacyStaffNotes(): ?string
  707.     {
  708.         return $this->pharmacyStaffNotes;
  709.     }
  711.     public function setPharmacyStaffNotes(?string $pharmacyStaffNotes): self
  712.     {
  713.         $this->pharmacyStaffNotes = $pharmacyStaffNotes;
  715.         return $this;
  716.     }
  718.     public function getWardStaffNotes(): ?string
  719.     {
  720.         return $this->wardStaffNotes;
  721.     }
  723.     public function setWardStaffNotes(?string $wardStaffNotes): self
  724.     {
  725.         $this->wardStaffNotes = $wardStaffNotes;
  727.         return $this;
  728.     }
  730.     public function getWardBed(): ?WardBed
  731.     {
  732.         return $this->wardBed;
  733.     }
  735.     public function setWardBed(WardBed $wardBed): self
  736.     {
  737.         $this->wardBed = $wardBed;
  739.         return $this;
  740.     }
  742.     public function getPharmacyPatientNotes(): ?string
  743.     {
  744.         return $this->pharmacyPatientNotes;
  745.     }
  747.     public function setPharmacyPatientNotes(?string $pharmacyPatientNotes): self
  748.     {
  749.         $this->pharmacyPatientNotes = $pharmacyPatientNotes;
  751.         return $this;
  752.     }
  754.     public function getClosureReason(): ?string
  755.     {
  756.         return $this->closureReason;
  757.     }
  759.     public function setClosureReason(?string $closureReason): self
  760.     {
  761.         $this->closureReason = $closureReason;
  763.         return $this;
  764.     }
  766.     public function getCreatedBy(): ?User
  767.     {
  768.         return $this->createdBy;
  769.     }
  771.     public function getUpdatedBy(): ?User
  772.     {
  773.         return $this->updatedBy;
  774.     }
  776.     public function getLabTestStatus(): ?string
  777.     {
  778.         return $this->labTestStatus;
  779.     }
  781.     public function setLabTestStatus(?string $labTestStatus): self
  782.     {
  783.         $this->labTestStatus = $labTestStatus;
  785.         return $this;
  786.     }
  788.     public function getCaseMedicineStatus(): ?string
  789.     {
  790.         return $this->caseMedicineStatus;
  791.     }
  793.     public function setCaseMedicineStatus(?string $caseMedicineStatus): self
  794.     {
  795.         $this->caseMedicineStatus = $caseMedicineStatus;
  797.         return $this;
  798.     }
  800.     public function getWardMedicineStatus(): ?string
  801.     {
  802.         return $this->wardMedicineStatus;
  803.     }
  805.     public function setWardMedicineStatus(?string $wardMedicineStatus): self
  806.     {
  807.         $this->wardMedicineStatus = $wardMedicineStatus;
  809.         return $this;
  810.     }
  812.     /**
  813.      * @return Collection|CaseClinicalPattern[]
  814.      */
  815.     public function getClinicalPatterns(): Collection
  816.     {
  817.         return $this->clinicalPatterns;
  818.     }
  820.     public function addClinicalPattern(CaseClinicalPattern $clinicalPattern): self
  821.     {
  822.         if (!$this->clinicalPatterns->contains($clinicalPattern)) {
  823.             $this->clinicalPatterns[] = $clinicalPattern;
  824.             $clinicalPattern->setCase($this);
  825.         }
  827.         return $this;
  828.     }
  830.     /**
  831.      * @return Collection|CaseProvisionalExamination[]
  832.      */
  833.     public function getProvisionalExaminations(): Collection
  834.     {
  835.         return $this->provisionalExaminations;
  836.     }
  838.     public function addProvisionalExamination(CaseProvisionalExamination $provisionalExamination): self
  839.     {
  840.         if (!$this->provisionalExaminations->contains($provisionalExamination)) {
  841.             $this->provisionalExaminations[] = $provisionalExamination;
  842.             $provisionalExamination->setCase($this);
  843.         }
  845.         return $this;
  846.     }
  848.     /**
  849.      * @return Collection|CaseProvisionalDiagnosis[]
  850.      */
  851.     public function getProvisionalDiagnosis(): Collection
  852.     {
  853.         return $this->provisionalDiagnosis;
  854.     }
  856.     public function addProvisionalDiagnosis(CaseProvisionalDiagnosis $provisionalDiagnosis): self
  857.     {
  858.         if (!$this->provisionalDiagnosis->contains($provisionalDiagnosis)) {
  859.             $this->provisionalDiagnosis[] = $provisionalDiagnosis;
  860.             $provisionalDiagnosis->setCase($this);
  861.         }
  863.         return $this;
  864.     }
  866.     /**
  867.      * @return Collection|CaseSymptom[]
  868.      */
  869.     public function getSymptoms(): Collection
  870.     {
  871.         return $this->symptoms;
  872.     }
  874.     public function addSymptom(CaseSymptom $symptom): self
  875.     {
  876.         if (!$this->symptoms->contains($symptom)) {
  877.             $this->symptoms[] = $symptom;
  878.             $symptom->setCase($this);
  879.         }
  881.         return $this;
  882.     }
  884.     /**
  885.      * @return Collection|CaseNcd[]
  886.      */
  887.     public function getNcds(): Collection
  888.     {
  889.         return $this->ncds;
  890.     }
  892.     public function addNcd(CaseNcd $ncd): self
  893.     {
  894.         if (!$this->ncds->contains($ncd)) {
  895.             $this->ncds[] = $ncd;
  896.             $ncd->setCase($this);
  897.         }
  899.         return $this;
  900.     }
  902.     /**
  903.      * @return Collection|CaseReferral[]
  904.      */
  905.     public function getReferrals(): Collection
  906.     {
  907.         return $this->referrals;
  908.     }
  910.     public function addReferral(CaseReferral $referral): self
  911.     {
  912.         if (!$this->referrals->contains($referral)) {
  913.             $this->referrals[] = $referral;
  914.             $referral->setCase($this);
  915.         }
  917.         return $this;
  918.     }
  920.     /**
  921.      * @return Collection|CaseLaboratory[]
  922.      */
  923.     public function getLabTests(): Collection
  924.     {
  925.         return $this->labTests;
  926.     }
  928.     public function addLabTest(CaseLaboratory $labTest): self
  929.     {
  930.         if (!$this->labTests->contains($labTest)) {
  931.             $this->labTests[] = $labTest;
  932.             $labTest->setCase($this);
  933.         }
  935.         return $this;
  936.     }
  938.     public function hasOpinion(): bool
  939.     {
  940.         foreach ($this->referrals as $referral) {
  941.             if ($referral->getIsOpinion()) {
  942.                 return true;
  943.             }
  944.         }
  946.         return false;
  947.     }
  949.     public function getDeliveryDetail(): ?DeliveryDetail
  950.     {
  951.         return $this->deliveryDetail;
  952.     }
  954.     public function setDeliveryDetail(DeliveryDetail $deliveryDetail): self
  955.     {
  956.         if ($deliveryDetail->getCase() !== $this) {
  957.             $deliveryDetail->setCase($this);
  958.         }
  960.         $this->deliveryDetail = $deliveryDetail;
  962.         return $this;
  963.     }
  965.     public function __toString(): string
  966.     {
  967.         return $this->getMrdId();
  968.     }
  970.     public function removeClinicalPattern(CaseClinicalPattern $clinicalPattern): self
  971.     {
  972.         if ($this->clinicalPatterns->removeElement($clinicalPattern)) {
  973.             if ($clinicalPattern->getCase() === $this) {
  974.                 $clinicalPattern->setCase(null);
  975.             }
  976.         }
  978.         return $this;
  979.     }
  981.     public function removeProvisionalExamination(CaseProvisionalExamination $provisionalExamination): self
  982.     {
  983.         if ($this->provisionalExaminations->removeElement($provisionalExamination)) {
  984.             if ($provisionalExamination->getCase() === $this) {
  985.                 $provisionalExamination->setCase(null);
  986.             }
  987.         }
  989.         return $this;
  990.     }
  992.     public function addProvisionalDiagnosi(CaseProvisionalDiagnosis $provisionalDiagnosi): self
  993.     {
  994.         if (!$this->provisionalDiagnosis->contains($provisionalDiagnosi)) {
  995.             $this->provisionalDiagnosis[] = $provisionalDiagnosi;
  996.             $provisionalDiagnosi->setCase($this);
  997.         }
  999.         return $this;
  1000.     }
  1002.     public function removeProvisionalDiagnosi(CaseProvisionalDiagnosis $provisionalDiagnosi): self
  1003.     {
  1004.         if ($this->provisionalDiagnosis->removeElement($provisionalDiagnosi)) {
  1005.             if ($provisionalDiagnosi->getCase() === $this) {
  1006.                 $provisionalDiagnosi->setCase(null);
  1007.             }
  1008.         }
  1010.         return $this;
  1011.     }
  1013.     public function removeSymptom(CaseSymptom $symptom): self
  1014.     {
  1015.         if ($this->symptoms->removeElement($symptom)) {
  1016.             if ($symptom->getCase() === $this) {
  1017.                 $symptom->setCase(null);
  1018.             }
  1019.         }
  1021.         return $this;
  1022.     }
  1024.     public function removeNcd(CaseNcd $ncd): self
  1025.     {
  1026.         if ($this->ncds->removeElement($ncd)) {
  1027.             if ($ncd->getCase() === $this) {
  1028.                 $ncd->setCase(null);
  1029.             }
  1030.         }
  1032.         return $this;
  1033.     }
  1035.     public function removeReferral(CaseReferral $referral): self
  1036.     {
  1037.         if ($this->referrals->removeElement($referral)) {
  1038.             if ($referral->getCase() === $this) {
  1039.                 $referral->setCase(null);
  1040.             }
  1041.         }
  1043.         return $this;
  1044.     }
  1046.     public function removeLabTest(CaseLaboratory $labTest): self
  1047.     {
  1048.         if ($this->labTests->removeElement($labTest)) {
  1049.             if ($labTest->getCase() === $this) {
  1050.                 $labTest->setCase(null);
  1051.             }
  1052.         }
  1054.         return $this;
  1055.     }
  1057.     public function getInjuredInfo(): ?InjuredInfo
  1058.     {
  1059.         return $this->injuredInfo;
  1060.     }
  1062.     public function setInjuredInfo(InjuredInfo $injuredInfo): self
  1063.     {
  1064.         if ($injuredInfo->getCase() !== $this) {
  1065.             $injuredInfo->setCase($this);
  1066.         }
  1068.         $this->injuredInfo = $injuredInfo;
  1070.         return $this;
  1071.     }
  1073.     public function getPostMortemReport(): ?PostMortemReport
  1074.     {
  1075.         return $this->postMortemReport;
  1076.     }
  1078.     public function setPostMortemReport(?PostMortemReport $postMortemReport): self
  1079.     {
  1080.         if ($postMortemReport === null && $this->postMortemReport !== null) {
  1081.             $this->postMortemReport->setCase(null);
  1082.         }
  1084.         if ($postMortemReport !== null && $postMortemReport->getCase() !== $this) {
  1085.             $postMortemReport->setCase($this);
  1086.         }
  1088.         $this->postMortemReport = $postMortemReport;
  1090.         return $this;
  1091.     }
  1093.     public function getDeathCertificate(): ?DeathCertificate
  1094.     {
  1095.         return $this->deathCertificate;
  1096.     }
  1098.     public function setDeathCertificate(DeathCertificate $deathCertificate): self
  1099.     {
  1100.         if ($deathCertificate->getCase() !== $this) {
  1101.             $deathCertificate->setCase($this);
  1102.         }
  1104.         $this->deathCertificate = $deathCertificate;
  1106.         return $this;
  1107.     }
  1109.     public function getBirthCertificate(): ?BirthCertificate
  1110.     {
  1111.         return $this->birthCertificate;
  1112.     }
  1114.     public function setBirthCertificate(BirthCertificate $birthCertificate): self
  1115.     {
  1116.         if ($birthCertificate->getCase() !== $this) {
  1117.             $birthCertificate->setCase($this);
  1118.         }
  1120.         $this->birthCertificate = $birthCertificate;
  1122.         return $this;
  1123.     }
  1124. }