src/Entity/TheCase.php line 12

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\TheCaseRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: TheCaseRepository::class)]
  12. class TheCase
  13. {
  14.     #[ORM\Id]
  15.     #[ORM\GeneratedValue]
  16.     #[ORM\Column]
  17.     private ?int $id = null;
  19.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  20.     private ?\DateTimeInterface $CreatedAt = null;
  22.     #[ORM\ManyToOne(inversedBy: 'theCases')]
  23.     private ?User $CreatedBy = null;
  25.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  26.     private ?\DateTimeInterface $UpdateAt = null;
  28.     #[ORM\Column(length: 20, nullable: true)]
  29.     private ?string $RefLawOffice = null;
  30.     
  31.     #[ORM\Column(length: 20, nullable: true)]
  32.     private ?string $FullFileTpiNum = null;
  33.     
  35.     #[ORM\Column(length: 20, nullable: true)]
  36.     private ?string $FullFileCANum = null;
  38.     #[ORM\ManyToOne]
  39.     private ?CaseType $CaseType = null;
  41.     #[ORM\ManyToOne(inversedBy: 'theCases')]
  42.     private ?Client $Client = null;
  44.     #[ORM\Column(length: 255, nullable: true)]
  45.     private ?string $OpponentName = null;
  47.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  48.     private ?\DateTimeInterface $OpenedAt = null;
  50.     #[ORM\OneToMany(mappedBy: 'theCase', targetEntity: TheCaseActions::class)]
  51.     private Collection $Actions;
  53.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  54.     private ?\DateTimeInterface $NotificationAt = null;
  56.     #[ORM\Column(length: 100, nullable: true)]
  57.     private ?string $NotificationRef = null;
  59.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  60.     private ?string $NotificationMemo = null;
  62.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  63.     private ?\DateTimeInterface $ExecutionAt = null;
  65.     #[ORM\Column(length: 100, nullable: true)]
  66.     private ?string $ExecutionRef = null;
  68.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  69.     private ?string $ExecutionMemo = null;
  71.     #[ORM\Column(nullable: true)]
  72.     private ?int $FileStatus = null;
  74.     #[ORM\OneToMany(mappedBy: 'TheCase', targetEntity: CaseLogActions::class)]
  75.     private Collection $caseLogActions;
  77.     #[ORM\ManyToOne]
  78.     private ?LawOffice $LawOffice = null;
  80.     #[ORM\Column(nullable: true)]
  81.     private ?int $CaseSeq = null;
  83.     #[ORM\Column(nullable: true)]
  84.     private ?bool $IsDeleted = false;
  86.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  87.     private ?\DateTimeInterface $DeleteAt = null;
  89.     #[ORM\ManyToOne]
  90.     private ?User $DeletedBy = null;
  92.     #[ORM\ManyToOne]
  93.     private ?User $LockedBy = null;
  95.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  96.     private ?\DateTimeInterface $LockedAt = null;
  98.     #[ORM\Column(nullable: true)]
  99.     private ?bool $IsNotification = null;
  101.     #[ORM\Column(nullable: true)]
  102.     private ?bool $IsExecution = null;
  104.     #[ORM\Column(length: 40, nullable: true)]
  105.     private ?string $RefJudge = null;
  107.     #[ORM\Column(nullable: true)]
  108.     private ?bool $IsJudged = null;
  110.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  111.     private ?\DateTimeInterface $JudgedAt = null;
  113.     #[ORM\ManyToOne]
  114.     private ?Juridiction $Juridiction = null;
  116.     #[ORM\Column(length: 255, nullable: true)]
  117.     private ?string $LawyerAdv = null;
  119.     #[ORM\OneToMany(mappedBy: 'TheCase', targetEntity: IncomeExpense::class)]
  120.     private Collection $incomeExpenses;
  122.     #[ORM\OneToMany(mappedBy: 'TheCase', targetEntity: Deposit::class)]
  123.     private Collection $deposits;
  125.     #[ORM\Column(length: 60, nullable: true)]
  126.     private ?string $JudgeFullName = null;
  128.     #[ORM\Column(length: 100, nullable: true)]
  129.     private ?string $Subject = null;
  131.     #[ORM\Column(nullable: true)]
  132.     private ?int $Parent = null;
  134.     public function __construct()
  135.     {
  136.         $this->Actions = new ArrayCollection();
  137.         $this->caseLogActions = new ArrayCollection();
  138.         $this->incomeExpenses = new ArrayCollection();
  139.         $this->deposits = new ArrayCollection();
  140.     }
  142.     public function getId(): ?int
  143.     {
  144.         return $this->id;
  145.     }
  147.     public function getCreatedAt(): ?\DateTimeInterface
  148.     {
  149.         return $this->CreatedAt;
  150.     }
  152.     public function setCreatedAt(?\DateTimeInterface $CreatedAt): self
  153.     {
  154.         $this->CreatedAt = $CreatedAt;
  156.         return $this;
  157.     }
  159.     public function getCreatedBy(): ?User
  160.     {
  161.         return $this->CreatedBy;
  162.     }
  164.     public function setCreatedBy(?User $CreatedBy): self
  165.     {
  166.         $this->CreatedBy = $CreatedBy;
  168.         return $this;
  169.     }
  171.     public function getUpdateAt(): ?\DateTimeInterface
  172.     {
  173.         return $this->UpdateAt;
  174.     }
  176.     public function setUpdateAt(?\DateTimeInterface $UpdateAt): self
  177.     {
  178.         $this->UpdateAt = $UpdateAt;
  180.         return $this;
  181.     }
  183.     public function getFullFileTpiNum(): ?string
  184.     {
  185.         return $this->FullFileTpiNum;
  186.     }
  188.     public function setFullFileTpiNum(?string $FullFileTpiNum): self
  189.     {
  190.         $this->FullFileTpiNum = $FullFileTpiNum;
  192.         return $this;
  193.     }
  195.     public function getRefLawOffice(): ?string
  196.     {
  197.         return $this->RefLawOffice;
  198.     }
  200.     public function setRefLawOffice(?string $RefLawOffice): self
  201.     {
  202.         $this->RefLawOffice = $RefLawOffice;
  204.         return $this;
  205.     }
  207.     public function getFullFileCANum(): ?string
  208.     {
  209.         return $this->FullFileCANum;
  210.     }
  212.     public function setFullFileCANum(?string $FullFileCANum): self
  213.     {
  214.         $this->FullFileCANum = $FullFileCANum;
  216.         return $this;
  217.     }
  219.     public function getCaseType(): ?CaseType
  220.     {
  221.         return $this->CaseType;
  222.     }
  224.     public function setCaseType(?CaseType $CaseType): self
  225.     {
  226.         $this->CaseType = $CaseType;
  228.         return $this;
  229.     }
  231.     public function getClient(): ?Client
  232.     {
  233.         return $this->Client;
  234.     }
  236.     public function setClient(?Client $Client): self
  237.     {
  238.         $this->Client = $Client;
  240.         return $this;
  241.     }
  243.     public function getOpponentName(): ?string
  244.     {
  245.         return $this->OpponentName;
  246.     }
  248.     public function setOpponentName(?string $OpponentName): self
  249.     {
  250.         $this->OpponentName = $OpponentName;
  252.         return $this;
  253.     }
  255.     public function getOpenedAt(): ?\DateTimeInterface
  256.     {
  257.         return $this->OpenedAt;
  258.     }
  260.     public function setOpenedAt(?\DateTimeInterface $OpenedAt): self
  261.     {
  262.         $this->OpenedAt = $OpenedAt;
  264.         return $this;
  265.     }
  267.     /**
  268.      * @return Collection<int, TheCaseActions>
  269.      */
  270.     public function getActions(): Collection
  271.     {
  272.         return $this->Actions;
  273.     }
  275.     public function addAction(TheCaseActions $action): self
  276.     {
  277.         if (!$this->Actions->contains($action)) {
  278.             $this->Actions->add($action);
  279.             $action->setTheCase($this);
  280.         }
  282.         return $this;
  283.     }
  285.     public function removeAction(TheCaseActions $action): self
  286.     {
  287.         if ($this->Actions->removeElement($action)) {
  288.             // set the owning side to null (unless already changed)
  289.             if ($action->getTheCase() === $this) {
  290.                 $action->setTheCase(null);
  291.             }
  292.         }
  294.         return $this;
  295.     }
  297.     public function getNotificationAt(): ?\DateTimeInterface
  298.     {
  299.         return $this->NotificationAt;
  300.     }
  302.     public function setNotificationAt(?\DateTimeInterface $NotificationAt): self
  303.     {
  304.         $this->NotificationAt = $NotificationAt;
  306.         return $this;
  307.     }
  309.     public function getNotificationRef(): ?string
  310.     {
  311.         return $this->NotificationRef;
  312.     }
  314.     public function setNotificationRef(?string $NotificationRef): self
  315.     {
  316.         $this->NotificationRef = $NotificationRef;
  318.         return $this;
  319.     }
  321.     public function getNotificationMemo(): ?string
  322.     {
  323.         return $this->NotificationMemo;
  324.     }
  326.     public function setNotificationMemo(?string $NotificationMemo): self
  327.     {
  328.         $this->NotificationMemo = $NotificationMemo;
  330.         return $this;
  331.     }
  333.     public function getExecutionAt(): ?\DateTimeInterface
  334.     {
  335.         return $this->ExecutionAt;
  336.     }
  338.     public function setExecutionAt(?\DateTimeInterface $ExecutionAt): self
  339.     {
  340.         $this->ExecutionAt = $ExecutionAt;
  342.         return $this;
  343.     }
  345.     public function getExecutionRef(): ?string
  346.     {
  347.         return $this->ExecutionRef;
  348.     }
  350.     public function setExecutionRef(?string $ExecutionRef): self
  351.     {
  352.         $this->ExecutionRef = $ExecutionRef;
  354.         return $this;
  355.     }
  357.     public function getExecutionMemo(): ?string
  358.     {
  359.         return $this->ExecutionMemo;
  360.     }
  362.     public function setExecutionMemo(?string $ExecutionMemo): self
  363.     {
  364.         $this->ExecutionMemo = $ExecutionMemo;
  366.         return $this;
  367.     }
  369.     public function getFileStatus(): ?int
  370.     {
  371.         return $this->FileStatus;
  372.     }
  374.     public function setFileStatus(?int $FileStatus): self
  375.     {
  376.         $this->FileStatus = $FileStatus;
  378.         return $this;
  379.     }
  381.     /**
  382.      * @return Collection<int, CaseLogActions>
  383.      */
  384.     public function getCaseLogActions(): Collection
  385.     {
  386.         return $this->caseLogActions;
  387.     }
  389.     public function addCaseLogAction(CaseLogActions $caseLogAction): self
  390.     {
  391.         if (!$this->caseLogActions->contains($caseLogAction)) {
  392.             $this->caseLogActions->add($caseLogAction);
  393.             $caseLogAction->setTheCase($this);
  394.         }
  396.         return $this;
  397.     }
  399.     public function removeCaseLogAction(CaseLogActions $caseLogAction): self
  400.     {
  401.         if ($this->caseLogActions->removeElement($caseLogAction)) {
  402.             // set the owning side to null (unless already changed)
  403.             if ($caseLogAction->getTheCase() === $this) {
  404.                 $caseLogAction->setTheCase(null);
  405.             }
  406.         }
  408.         return $this;
  409.     }
  411.     public function getLawOffice(): ?LawOffice
  412.     {
  413.         return $this->LawOffice;
  414.     }
  416.     public function setLawOffice(?LawOffice $LawOffice): self
  417.     {
  418.         $this->LawOffice = $LawOffice;
  420.         return $this;
  421.     }
  423.     public function getCaseSeq(): ?int
  424.     {
  425.         return $this->CaseSeq;
  426.     }
  428.     public function setCaseSeq(?int $CaseSeq): self
  429.     {
  430.         $this->CaseSeq = $CaseSeq;
  432.         return $this;
  433.     }
  435.     public function isIsDeleted(): ?bool
  436.     {
  437.         return $this->IsDeleted;
  438.     }
  440.     public function setIsDeleted(?bool $IsDeleted): self
  441.     {
  442.         $this->IsDeleted = $IsDeleted;
  444.         return $this;
  445.     }
  447.     public function getDeleteAt(): ?\DateTimeInterface
  448.     {
  449.         return $this->DeleteAt;
  450.     }
  452.     public function setDeleteAt(?\DateTimeInterface $DeleteAt): self
  453.     {
  454.         $this->DeleteAt = $DeleteAt;
  456.         return $this;
  457.     }
  459.     public function getDeletedBy(): ?User
  460.     {
  461.         return $this->DeletedBy;
  462.     }
  464.     public function setDeletedBy(?User $DeletedBy): self
  465.     {
  466.         $this->DeletedBy = $DeletedBy;
  468.         return $this;
  469.     }
  471.     public function getLockedBy(): ?User
  472.     {
  473.         return $this->LockedBy;
  474.     }
  476.     public function setLockedBy(?User $LockedBy): self
  477.     {
  478.         $this->LockedBy = $LockedBy;
  480.         return $this;
  481.     }
  483.     public function getLockedAt(): ?\DateTimeInterface
  484.     {
  485.         return $this->LockedAt;
  486.     }
  488.     public function setLockedAt(?\DateTimeInterface $LockedAt): self
  489.     {
  490.         $this->LockedAt = $LockedAt;
  492.         return $this;
  493.     }
  495.     public function isIsNotification(): ?bool
  496.     {
  497.         return $this->IsNotification;
  498.     }
  500.     public function setIsNotification(?bool $IsNotification): self
  501.     {
  502.         $this->IsNotification = $IsNotification;
  504.         return $this;
  505.     }
  507.     public function isIsExecution(): ?bool
  508.     {
  509.         return $this->IsExecution;
  510.     }
  512.     public function setIsExecution(?bool $IsExecution): self
  513.     {
  514.         $this->IsExecution = $IsExecution;
  516.         return $this;
  517.     }
  519.     public function getRefJudge(): ?string
  520.     {
  521.         return $this->RefJudge;
  522.     }
  524.     public function setRefJudge(?string $RefJudge): self
  525.     {
  526.         $this->RefJudge = $RefJudge;
  528.         return $this;
  529.     }
  531.     public function isIsJudged(): ?bool
  532.     {
  533.         return $this->IsJudged;
  534.     }
  536.     public function setIsJudged(?bool $IsJudged): self
  537.     {
  538.         $this->IsJudged = $IsJudged;
  540.         return $this;
  541.     }
  543.     public function getJudgedAt(): ?\DateTimeInterface
  544.     {
  545.         return $this->JudgedAt;
  546.     }
  548.     public function setJudgedAt(?\DateTimeInterface $JudgedAt): self
  549.     {
  550.         $this->JudgedAt = $JudgedAt;
  552.         return $this;
  553.     }
  555.     public function getJuridiction(): ?Juridiction
  556.     {
  557.         return $this->Juridiction;
  558.     }
  560.     public function setJuridiction(?Juridiction $Juridiction): self
  561.     {
  562.         $this->Juridiction = $Juridiction;
  564.         return $this;
  565.     }
  567.     public function getLawyerAdv(): ?string
  568.     {
  569.         return $this->LawyerAdv;
  570.     }
  572.     public function setLawyerAdv(?string $LawyerAdv): self
  573.     {
  574.         $this->LawyerAdv = $LawyerAdv;
  576.         return $this;
  577.     }
  579.     /**
  580.      * @return Collection<int, IncomeExpense>
  581.      */
  582.     public function getIncomeExpenses(): Collection
  583.     {
  584.         return $this->incomeExpenses;
  585.     }
  587.     public function addIncomeExpense(IncomeExpense $incomeExpense): self
  588.     {
  589.         if (!$this->incomeExpenses->contains($incomeExpense)) {
  590.             $this->incomeExpenses->add($incomeExpense);
  591.             $incomeExpense->setTheCase($this);
  592.         }
  594.         return $this;
  595.     }
  597.     public function removeIncomeExpense(IncomeExpense $incomeExpense): self
  598.     {
  599.         if ($this->incomeExpenses->removeElement($incomeExpense)) {
  600.             // set the owning side to null (unless already changed)
  601.             if ($incomeExpense->getTheCase() === $this) {
  602.                 $incomeExpense->setTheCase(null);
  603.             }
  604.         }
  606.         return $this;
  607.     }
  609.     /**
  610.      * @return Collection<int, Deposit>
  611.      */
  612.     public function getDeposits(): Collection
  613.     {
  614.         return $this->deposits;
  615.     }
  617.     public function addDeposit(Deposit $deposit): self
  618.     {
  619.         if (!$this->deposits->contains($deposit)) {
  620.             $this->deposits->add($deposit);
  621.             $deposit->setTheCase($this);
  622.         }
  624.         return $this;
  625.     }
  627.     public function removeDeposit(Deposit $deposit): self
  628.     {
  629.         if ($this->deposits->removeElement($deposit)) {
  630.             // set the owning side to null (unless already changed)
  631.             if ($deposit->getTheCase() === $this) {
  632.                 $deposit->setTheCase(null);
  633.             }
  634.         }
  636.         return $this;
  637.     }
  639.     public function getJudgeFullName(): ?string
  640.     {
  641.         return $this->JudgeFullName;
  642.     }
  644.     public function setJudgeFullName(?string $JudgeFullName): self
  645.     {
  646.         $this->JudgeFullName = $JudgeFullName;
  648.         return $this;
  649.     }
  651.     public function getSubject(): ?string
  652.     {
  653.         return $this->Subject;
  654.     }
  656.     public function setSubject(?string $Subject): self
  657.     {
  658.         $this->Subject = $Subject;
  660.         return $this;
  661.     }
  663.     public function getParent(): ?int
  664.     {
  665.         return $this->Parent;
  666.     }
  668.     public function setParent(?int $Parent): static
  669.     {
  670.         $this->Parent = $Parent;
  672.         return $this;
  673.     }
  674. }