src/Entity/Disc.php line 30

1. <?php
3. namespace MedBrief\MSR\Entity;
5. use DH\Auditor\Provider\Doctrine\Auditing\Annotation as Audit;
6. use Doctrine\Common\Collections\ArrayCollection;
7. use Doctrine\Common\Collections\Collection as DoctrineCollection;
8. use Doctrine\ORM\Mapping as ORM;
9. use Gedmo\Mapping\Annotation as Gedmo;
10. use MedBrief\MSR\Repository\DiscRepository;
11. use MedBrief\MSR\Service\ProjectClosure\RemoveRecords\RemovableRecordInterface;
12. use MedBrief\MSR\Service\VirusScan\Async\VirusScannableInterface;
13. use MedBrief\MSR\Service\VirusScan\Async\Visitor\VirusScannerPathVisitorInterface;
14. use MedBrief\MSR\Service\VirusScan\Async\Visitor\VirusScannerVisitorInterface;
15. use Symfony\Component\HttpFoundation\File\File;
17. /**
18. * Disc
19. *
20. * @ORM\Table(name="Disc", indexes={@ORM\Index(name="status_index", columns={"status"})})
21. *
22. * @ORM\Entity(repositoryClass=DiscRepository::class)
23. *
24. * @Gedmo\SoftDeleteable(fieldName="deletedAt", timeAware=false)
25. *
26. * @Audit\Auditable
27. *
28. * @Audit\Security(view={"ROLE_ALLOWED_TO_AUDIT"})
29. */
30. class Disc implements RemovableRecordInterface, VirusScannableInterface
31. {
32. public const STATUS_PENDING_UPLOAD = 1;
33. public const STATUS_PENDING_PROCESSING = 2;
34. public const STATUS_ACTIVE = 3;
35. public const STATUS_PENDING_ARCHIVE = 12;
36. public const STATUS_ARCHIVED = 14;
37. public const STATUS_ARCHIVED_FAILED = 15;
38. public const STATUS_FAILED_VIRUS = 17;
40. // all the processing statuses
41. public const STATUS_PROCESSING_FAILED = 4;
42. public const STATUS_PROCESSING_SYNC_COLLECTION_TO_ORTHANC_FAILED = 16;
43. public const STATUS_PROCESSING_CURRENT_EXTRACT_IMPORT = 5;
44. public const STATUS_PROCESSING_CURRENT_EXTRACT_IMPORT_COMPLETE = 6;
45. public const STATUS_PROCESSING_CURRENT_IMPORT_DICOM = 10;
46. public const STATUS_PROCESSING_CURRENT_IMPORT_DICOM_COMPLETE = 11;
47. public const STATUS_PROCESSING_CURRENT_SYNC_COLLECTION_TO_ORTHANC = 7;
48. public const STATUS_PROCESSING_CURRENT_SYNC_COLLECTION_TO_ORTHANC_COMPLETE = 8;
49. public const STATUS_PROCESSING_CURRENT_SYNC_PATIENT_STRUCTURE = 9;
50. public const STATUS_PROCESSING_CURRENT_ARCHIVING = 13;
52. public const STATUS_MODERN_PROCESSING_EXTRACT_ARCHIVE = 100;
53. public const STATUS_MODERN_PROCESSING_EXTRACT_COMPLETE = 101;
54. public const STATUS_MODERN_PROCESSING_IMPORT_DICOM = 110;
55. public const STATUS_MODERN_PROCESSING_IMPORT_COMPLETE = 111;
56. public const STATUS_MODERN_PROCESSING_SYNC_STRUCTURE = 120;
57. public const STATUS_MODERN_PROCESSING_SYNC_COMPLETE = 121;
58. public const STATUS_MODERN_PROCESSING_CLEANUP = 130;
59. public const STATUS_MODERN_PROCESSING_CLEANUP_COMPLETE = 131;
61. public const STATUS_REASON_CODE_ARCHIVE_ERROR_UNKNOWN = 1;
62. public const STATUS_REASON_CODE_ARCHIVE_ERROR_UNKNOWN__LABEL = 'An Unknown Error Occurred';
63. public const STATUS_REASON_CODE_ARCHIVE_ERROR_PASSWORD_INVALID = 2;
64. public const STATUS_REASON_CODE_ARCHIVE_ERROR_PASSWORD_INVALID__LABEL = 'Incorrect Password Provided';
65. public const STATUS_REASON_CODE_ARCHIVE_CONTAINS_NO_DICOM_FILES = 3;
66. public const STATUS_REASON_CODE_ARCHIVE_CONTAINS_NO_DICOM_FILES__LABEL = 'Archive Contains No DICOMs';
67. public const STATUS_REASON_CODE_ORTHANC_UNAVAILABLE = 4;
68. public const STATUS_REASON_CODE_ORTHANC_UNAVAILABLE__LABEL = 'Orthanc Unavailable During Processing';
69. public const STATUS_REASON_CODE_EXCEPTION_THROWN = 5;
70. public const STATUS_REASON_CODE_EXCEPTION_THROWN__LABEL = 'An Exception Occurred During Processing';
71. public const STATUS_REASON_CODE_ARCHIVE_NONEXISTENT = 6;
72. public const STATUS_REASON_CODE_ARCHIVE_NONEXISTENT__LABEL = 'Could Not Find an Archive to Process';
74. // Set this to 100 so we can add the previous failure's code to it and sneakily store both
75. public const STATUS_REASON_CODE_MAX_ATTEMPTS_EXCEEDED = 100;
76. public const STATUS_REASON_CODE_MAX_ATTEMPTS_EXCEEDED__LABEL = 'Exceeded The Maximum Number of Attempts';
78. //All delete statuses
79. public const DELETE_STATUS_PENDING = 'pending';
80. public const DELETE_STATUS_IN_PROGRESS = 'in_progress';
81. public const DELETE_STATUS_FAILED = 'failed';
82. public const DELETE_STATUS__LABEL = 'Deletion in progress';
84. // Valid values for processingPriority
85. public const PROCESSING_PRIORITY_HIGH = 1;
86. public const PROCESSING_PRIORITY_LOW = 0;
88. /**
89. * @var int
90. *
91. * @ORM\Column(name="id", type="integer")
92. *
93. * @ORM\Id
94. *
95. * @ORM\GeneratedValue(strategy="IDENTITY")
96. */
97. protected $id;
99. /**
100. * @var \DateTime|null
101. *
102. * @ORM\Column(name="deletedAt", type="datetime", nullable=true)
103. */
104. protected $deletedAt;
106. /**
107. * @var string
108. *
109. * @ORM\Column(name="name", type="string", nullable=false)
110. */
111. protected $name;
113. /**
114. * @var \DateTime|null
115. *
116. * @ORM\Column(name="date_received", type="datetime", nullable=true)
117. */
118. protected $date_received;
120. /**
121. * @var \DateTime
122. *
123. * @ORM\Column(name="created", type="datetime")
124. *
125. * @Gedmo\Timestampable(on="create")
126. */
127. protected $created;
129. /**
130. * @var \DateTime
131. *
132. * @ORM\Column(name="updated", type="datetime")
133. *
134. * @Gedmo\Timestampable(on="update")
135. */
136. protected $updated;
138. /**
139. * @var Project
140. *
141. * @ORM\ManyToOne(targetEntity="MedBrief\MSR\Entity\Project", inversedBy="discs")
142. *
143. * @ORM\JoinColumns({
144. *
145. * @ORM\JoinColumn(name="project_id", referencedColumnName="id", nullable=false)
146. * })
147. */
148. protected $project;
150. /**
151. * @var string
152. *
153. * @ORM\Column(name="archiveFilesize", type="string", nullable=true)
154. */
155. protected $archiveFilesize;
157. /**
158. * Indicates the processing priority of the Disc. Currently, this is limited to 0 or 1, with
159. * 1 indicating a priority Disc. But, in future we may implement fine grain control using this field.
160. *
161. * @var int
162. *
163. * @ORM\Column(name="processingPriority", type="integer", options={"default"="0"})
164. */
165. protected $processingPriority;
167. /**
168. * @var BatchRequest
169. *
170. * @ORM\ManyToOne(targetEntity="MedBrief\MSR\Entity\BatchRequest", inversedBy="discs")
171. *
172. * @ORM\JoinColumns({
173. *
174. * @ORM\JoinColumn(name="batchRequest_id", referencedColumnName="id", nullable=true)
175. * })
176. */
177. protected $batchRequest;
179. /**
180. * @var int
181. *
182. * @ORM\Column(name="status", type="integer", nullable=false)
183. */
184. protected $status;
186. /**
187. * @var int|null
188. *
189. * @ORM\Column(name="status_reason_code", type="integer", nullable=true)
190. */
191. protected $status_reason_code;
193. /**
194. * @ORM\Column(type="integer", nullable=true)
195. */
196. protected ?int $preMigrationStatus;
198. /**
199. * @var string|null
200. *
201. * @ORM\Column(name="archiveName", type="string", length=255, nullable=true)
202. */
203. protected $archiveName;
205. /**
206. * @var string
207. */
208. protected $archiveFile;
210. /**
211. * @var string|null
212. *
213. * @ORM\Column(name="archiveOriginalName", type="string", length=255, nullable=true)
214. */
215. protected $archiveOriginalName;
217. /**
218. * @var Collection
219. *
220. * @ORM\OneToOne(targetEntity="MedBrief\MSR\Entity\Collection", inversedBy="disc", cascade={"all"})
221. *
222. * @ORM\JoinColumns({
223. *
224. * @ORM\JoinColumn(name="collection_id", referencedColumnName="id", unique=true)
225. * })
226. */
227. protected $collection;
229. /**
230. * @var string|null
231. *
232. * @ORM\Column(name="source", type="string", nullable=true)
233. */
234. protected $source;
236. /**
237. * @var string|null
238. *
239. * @ORM\Column(name="password", type="string", length=255, nullable=true)
240. */
241. protected $password;
243. /**
244. * @var bool|null
245. *
246. * @ORM\Column(name="copy_created", type="boolean", nullable=true)
247. */
248. protected $copy_created;
250. /**
251. * @var bool|null
252. *
253. * @ORM\Column(name="is_password_protected", type="boolean", nullable=true)
254. */
255. protected $is_password_protected;
257. /**
258. * @var User
259. *
260. * @ORM\ManyToOne(targetEntity="MedBrief\MSR\Entity\User", inversedBy="discs")
261. *
262. * @ORM\JoinColumns({
263. *
264. * @ORM\JoinColumn(name="creator_id", referencedColumnName="id", nullable=false)
265. * })
266. */
267. protected $creator;
269. /**
270. * @var DoctrineCollection
271. *
272. * @todo We've taken out the remove cascade here as causes havoc with removing this entity. We'll create
273. * a separate clean-up script for this (See https://medbrief.atlassian.net/browse/MSR-2980)
274. *
275. * @ORM\OneToMany(targetEntity="MedBrief\MSR\Entity\DiscImportSession", mappedBy="disc", cascade={"persist"})
276. */
277. protected $discImportSessions;
279. /**
280. * @var DoctrineCollection
281. *
282. * @ORM\ManyToMany(targetEntity="MedBrief\MSR\Entity\Study", mappedBy="discs")
283. */
284. protected $studies;
286. /**
287. * @var string
288. *
289. * @ORM\Column(type="string", length=255, nullable=true)
290. */
291. protected $deleteStatus;
293. /**
294. * @ORM\OneToOne(targetEntity=DiscMetadata::class, mappedBy="disc", cascade={"persist", "remove"})
295. *
296. * @ORM\JoinColumn(nullable=true)
297. */
298. private ?DiscMetadata $discMetadata;
300. /**
301. * @ORM\ManyToMany(targetEntity=Instance::class, mappedBy="discs")
302. */
303. private $instances;
305. /**
306. * Used to indicate if this disc is a duplicate of another disc
307. *
308. * @ORM\Column(type="integer", nullable=true)
309. */
310. private $originalDiscId;
312. /**
313. * @ORM\OneToOne(targetEntity=VirusScanItem::class, mappedBy="disc")
314. */
315. private ?VirusScanItem $virusScanItem = null;
317. public function __construct()
318. {
319. // default status of discs is 'pending upload'
320. $this->setStatus(self::STATUS_PENDING_UPLOAD);
321. // Assign the default value to processingPriority
322. $this->setProcessingPriorityToDefault();
323. $this->discImportSessions = new ArrayCollection();
324. $this->studies = new ArrayCollection();
325. $this->instances = new ArrayCollection();
326. }
328. public function __clone()
329. {
330. if ($this->id) {
331. $this->id = null;
332. $this->project = null;
333. $this->discMetadata = null;
334. $this->deleteStatus = null;
335. $this->collection = null;
336. $this->deletedAt = null;
337. $this->discImportSessions = new ArrayCollection();
338. $this->studies = new ArrayCollection();
339. $this->instances = new ArrayCollection();
340. }
341. }
343. public function __toString()
344. {
345. return $this->getName();
346. }
348. /**
349. * Get id
350. *
351. * @return int
352. */
353. public function getId(): ?int
354. {
355. return $this->id;
356. }
358. /**
359. * Set name
360. *
361. * @param string $name
362. *
363. * @return Disc
364. */
365. public function setName($name)
366. {
367. $this->name = $name;
369. return $this;
370. }
372. /**
373. * Get name
374. *
375. * @return string
376. */
377. public function getName()
378. {
379. return $this->name;
380. }
382. /**
383. * Set date_received
384. *
385. * @param \DateTime $dateReceived
386. *
387. * @return Disc
388. */
389. public function setDateReceived($dateReceived)
390. {
391. $this->date_received = $dateReceived;
393. return $this;
394. }
396. /**
397. * Get date_received
398. *
399. * @return \DateTime
400. */
401. public function getDateReceived()
402. {
403. return $this->date_received;
404. }
406. /**
407. * Set created
408. *
409. * @param \DateTime $created
410. *
411. * @return Disc
412. */
413. public function setCreated($created)
414. {
415. $this->created = $created;
417. return $this;
418. }
420. /**
421. * Get created
422. *
423. * @return \DateTime
424. */
425. public function getCreated()
426. {
427. return $this->created;
428. }
430. /**
431. * Set updated
432. *
433. * @param \DateTime $updated
434. *
435. * @return Disc
436. */
437. public function setUpdated($updated)
438. {
439. $this->updated = $updated;
441. return $this;
442. }
444. /**
445. * Get updated
446. *
447. * @return \DateTime
448. */
449. public function getUpdated()
450. {
451. return $this->updated;
452. }
454. /**
455. * Set project
456. *
457. * @param Project $project
458. *
459. * @return Disc
460. */
461. public function setProject(Project $project)
462. {
463. $this->project = $project;
465. return $this;
466. }
468. /**
469. * Get project
470. *
471. * @return Project
472. */
473. public function getProject()
474. {
475. return $this->project;
476. }
478. /**
479. * Set status
480. *
481. * @param int $status
482. *
483. * @return Disc
484. */
485. public function setStatus($status)
486. {
487. $this->status = $status;
489. return $this;
490. }
492. /**
493. * Get status
494. *
495. * @return int
496. */
497. public function getStatus()
498. {
499. return $this->status;
500. }
502. /**
503. * Returns a human readable version of the status
504. *
505. * @return string
506. */
507. public function getStatusName()
508. {
509. $statusOptions = self::getStatusOptions();
511. return
512. $statusOptions[$this->getStatus()] ?? $this->getStatus();
513. }
515. /**
516. * Returns a detailed human readable version of the status
517. *
518. * @return string
519. */
520. public function getStatusDetailedName()
521. {
522. $statusOptions = self::getStatusOptions();
524. $detailedStatusOptions = [
525. // Legacy Statuses
526. self::STATUS_PROCESSING_CURRENT_EXTRACT_IMPORT => 'Extract and Import',
527. self::STATUS_PROCESSING_CURRENT_EXTRACT_IMPORT_COMPLETE => 'Extract and Import Complete',
528. self::STATUS_PROCESSING_CURRENT_SYNC_COLLECTION_TO_ORTHANC => 'Sync Collection To Orthanc',
529. self::STATUS_PROCESSING_CURRENT_SYNC_COLLECTION_TO_ORTHANC_COMPLETE => 'Sync Collection To Orthanc Complete',
530. self::STATUS_PROCESSING_CURRENT_SYNC_PATIENT_STRUCTURE => 'Sync Patient Structure',
531. self::STATUS_PROCESSING_CURRENT_IMPORT_DICOM => 'Import Dicom',
532. self::STATUS_PROCESSING_CURRENT_IMPORT_DICOM_COMPLETE => 'Import Dicom Complete',
534. // Modern Statuses
535. self::STATUS_MODERN_PROCESSING_EXTRACT_ARCHIVE => 'Extracting Disc',
536. self::STATUS_MODERN_PROCESSING_EXTRACT_COMPLETE => 'Extracted Disc',
537. self::STATUS_MODERN_PROCESSING_IMPORT_DICOM => 'Importing DICOMs',
538. self::STATUS_MODERN_PROCESSING_IMPORT_COMPLETE => 'Imported DICOMs',
539. self::STATUS_MODERN_PROCESSING_SYNC_STRUCTURE => 'Replicating Patient Structure',
540. self::STATUS_MODERN_PROCESSING_SYNC_COMPLETE => 'Patient Structure Replicated',
541. self::STATUS_MODERN_PROCESSING_CLEANUP => 'Cleaning Temporary Files',
542. self::STATUS_MODERN_PROCESSING_CLEANUP_COMPLETE => 'Temporary Files Removed',
543. ];
545. $statusOptions = array_replace_recursive($statusOptions, $detailedStatusOptions);
547. return
548. $statusOptions[$this->getStatus()] ?? $this->getStatus();
549. }
551. /**
552. * Returns an array of permitted values for the status field and their
553. * associated labels,
554. *
555. * @return array
556. */
557. public static function getStatusOptions()
558. {
559. return [
560. self::STATUS_ACTIVE => 'Active',
561. self::STATUS_PENDING_PROCESSING => 'Pending Processing',
562. self::STATUS_PENDING_UPLOAD => 'Pending Upload',
563. self::STATUS_PROCESSING_FAILED => 'Processing Failed',
564. self::STATUS_PROCESSING_SYNC_COLLECTION_TO_ORTHANC_FAILED => 'Processing Failed',
565. self::STATUS_PENDING_ARCHIVE => 'Pending Archiving',
566. self::STATUS_ARCHIVED => 'Archived',
567. self::STATUS_ARCHIVED_FAILED => 'Archiving Failed',
568. self::STATUS_FAILED_VIRUS => 'Processing Failed - File Failed Virus Scan',
570. //all of the below statusses can just be shown as 'processing' for the user
571. self::STATUS_PROCESSING_CURRENT_EXTRACT_IMPORT => 'Currently Processing',
572. self::STATUS_PROCESSING_CURRENT_EXTRACT_IMPORT_COMPLETE => 'Currently Processing',
573. self::STATUS_PROCESSING_CURRENT_SYNC_COLLECTION_TO_ORTHANC => 'Currently Processing',
574. self::STATUS_PROCESSING_CURRENT_SYNC_COLLECTION_TO_ORTHANC_COMPLETE => 'Currently Processing',
575. self::STATUS_PROCESSING_CURRENT_SYNC_PATIENT_STRUCTURE => 'Currently Processing',
576. self::STATUS_PROCESSING_CURRENT_IMPORT_DICOM => 'Currently Processing',
577. self::STATUS_PROCESSING_CURRENT_IMPORT_DICOM_COMPLETE => 'Currently Processing',
579. // Modern Statuses
580. self::STATUS_MODERN_PROCESSING_EXTRACT_ARCHIVE => 'Currently Processing',
581. self::STATUS_MODERN_PROCESSING_EXTRACT_COMPLETE => 'Currently Processing',
582. self::STATUS_MODERN_PROCESSING_IMPORT_DICOM => 'Currently Processing',
583. self::STATUS_MODERN_PROCESSING_IMPORT_COMPLETE => 'Currently Processing',
584. self::STATUS_MODERN_PROCESSING_SYNC_STRUCTURE => 'Currently Processing',
585. self::STATUS_MODERN_PROCESSING_SYNC_COMPLETE => 'Currently Processing',
586. self::STATUS_MODERN_PROCESSING_CLEANUP => 'Currently Processing',
587. self::STATUS_MODERN_PROCESSING_CLEANUP_COMPLETE => 'Currently Processing',
589. self::STATUS_PROCESSING_CURRENT_ARCHIVING => 'Archiving',
590. ];
591. }
593. /**
594. * Returns true if the disc is in status.
595. *
596. * @return array
597. */
598. public static function processingStuckStatusArray()
599. {
600. $statuses = [
601. // Modern Statuses
602. self::STATUS_MODERN_PROCESSING_EXTRACT_ARCHIVE,
603. self::STATUS_MODERN_PROCESSING_EXTRACT_COMPLETE,
604. self::STATUS_MODERN_PROCESSING_IMPORT_DICOM,
605. self::STATUS_MODERN_PROCESSING_IMPORT_COMPLETE,
606. self::STATUS_MODERN_PROCESSING_SYNC_STRUCTURE,
607. self::STATUS_MODERN_PROCESSING_SYNC_COMPLETE,
608. self::STATUS_MODERN_PROCESSING_CLEANUP,
609. self::STATUS_MODERN_PROCESSING_CLEANUP_COMPLETE,
610. ];
612. return $statuses;
613. }
615. /**
616. * Returns true if the disc is in an active status.
617. *
618. * @return bool
619. */
620. public function isActive()
621. {
622. return $this->getStatus() === self::STATUS_ACTIVE;
623. }
625. /**
626. * Returns true if the disc is in an pending status.
627. *
628. * @return bool
629. */
630. public function isPending()
631. {
632. $statuses = [
633. self::STATUS_PENDING_PROCESSING,
634. self::STATUS_PENDING_UPLOAD,
635. ];
637. return in_array($this->getStatus(), $statuses);
638. }
640. /**
641. * Returns true if the disc is in an processing status.
642. *
643. * @return bool
644. */
645. public function isProcessing()
646. {
647. $statuses = [
648. // Legacy statuses
649. self::STATUS_PROCESSING_CURRENT_EXTRACT_IMPORT,
650. self::STATUS_PROCESSING_CURRENT_EXTRACT_IMPORT_COMPLETE,
651. self::STATUS_PROCESSING_CURRENT_IMPORT_DICOM,
652. self::STATUS_PROCESSING_CURRENT_IMPORT_DICOM_COMPLETE,
653. self::STATUS_PROCESSING_CURRENT_SYNC_COLLECTION_TO_ORTHANC,
654. self::STATUS_PROCESSING_CURRENT_SYNC_COLLECTION_TO_ORTHANC_COMPLETE,
655. self::STATUS_PROCESSING_CURRENT_SYNC_PATIENT_STRUCTURE,
656. // Modern Statuses
657. self::STATUS_MODERN_PROCESSING_EXTRACT_ARCHIVE,
658. self::STATUS_MODERN_PROCESSING_EXTRACT_COMPLETE,
659. self::STATUS_MODERN_PROCESSING_IMPORT_DICOM,
660. self::STATUS_MODERN_PROCESSING_IMPORT_COMPLETE,
661. self::STATUS_MODERN_PROCESSING_SYNC_STRUCTURE,
662. self::STATUS_MODERN_PROCESSING_SYNC_COMPLETE,
663. self::STATUS_MODERN_PROCESSING_CLEANUP,
664. self::STATUS_MODERN_PROCESSING_CLEANUP_COMPLETE,
665. ];
667. return in_array($this->getStatus(), $statuses);
668. }
670. /**
671. * Returns true if the disc is in an failed status.
672. *
673. * @param array $excludes - optional array of failed status names
674. *
675. * @return bool
676. */
677. public function isFailed(array $excludes = [])
678. {
679. $statuses = [
680. self::STATUS_PROCESSING_FAILED,
681. self::STATUS_PROCESSING_SYNC_COLLECTION_TO_ORTHANC_FAILED,
682. self::STATUS_FAILED_VIRUS,
683. ];
685. if (empty($excludes)) {
686. return in_array($this->getStatus(), $statuses);
687. }
689. return in_array($this->getStatus(), array_diff($statuses, $excludes));
690. }
692. /**
693. * Set archiveName
694. *
695. * @param string $archiveName
696. *
697. * @return Disc
698. */
699. public function setArchiveName($archiveName)
700. {
701. $this->archiveName = $archiveName;
703. return $this;
704. }
706. /**
707. * Get archiveName
708. *
709. * @return string
710. */
711. public function getArchiveName()
712. {
713. return $this->archiveName;
714. }
716. /**
717. * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
718. * of 'UploadedFile' is injected into this setter to trigger the update. If this
719. * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
720. * must be able to accept an instance of 'File' as the bundle will inject one here
721. * during Doctrine hydration.
722. *
723. * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile $archiveFile
724. * @param string
725. *
726. * @return Disc
727. */
728. public function setArchiveFile($archiveFile)
729. {
730. $this->archiveFile = $archiveFile;
732. if ($archiveFile) {
733. // It is required that at least one field changes if you are using doctrine
734. // otherwise the event listeners won't be called and the file is lost
735. // NOTE: We can't actually do this because the this set method gets called when the entity
736. // is populated from the database, therefore the update value will always be wrong
737. //$this->updated = new \DateTime('now');
738. }
740. return $this;
741. }
743. /**
744. * Get archiveFile
745. *
746. * @return string
747. */
748. public function getArchiveFile()
749. {
750. return $this->archiveFile;
751. }
753. /**
754. * Set archiveOriginalName
755. *
756. * @param string $archiveOriginalName
757. *
758. * @return Disc
759. */
760. public function setArchiveOriginalName($archiveOriginalName)
761. {
762. $this->archiveOriginalName = $archiveOriginalName;
764. return $this;
765. }
767. /**
768. * Get archiveOriginalName
769. *
770. * @return string
771. */
772. public function getArchiveOriginalName()
773. {
774. return $this->archiveOriginalName;
775. }
777. /**
778. * Set collection
779. *
780. * @param Collection|null $collection
781. *
782. * @return Disc
783. */
784. public function setCollection(?Collection $collection = null)
785. {
786. $this->collection = $collection;
788. return $this;
789. }
791. /**
792. * Get collection
793. *
794. * @return Collection
795. */
796. public function getCollection()
797. {
798. return $this->collection;
799. }
801. /**
802. * Set source
803. *
804. * @param string $source
805. *
806. * @return Disc
807. */
808. public function setSource($source)
809. {
810. $this->source = $source;
812. return $this;
813. }
815. /**
816. * Get source
817. *
818. * @return string
819. */
820. public function getSource()
821. {
822. return $this->source;
823. }
825. /**
826. * Set password
827. *
828. * @param string $password
829. *
830. * @return Disc
831. */
832. public function setPassword($password)
833. {
834. $this->password = $password;
836. return $this;
837. }
839. /**
840. * Get password
841. *
842. * @return string
843. */
844. public function getPassword()
845. {
846. return $this->password;
847. }
849. /**
850. * Set copy_created
851. *
852. * @param bool $copyCreated
853. *
854. * @return Disc
855. */
856. public function setCopyCreated($copyCreated)
857. {
858. $this->copy_created = $copyCreated;
860. return $this;
861. }
863. /**
864. * Get copy_created
865. *
866. * @return bool
867. */
868. public function getCopyCreated()
869. {
870. return $this->copy_created;
871. }
873. /**
874. * Set is_password_protected
875. *
876. * @param bool $isPasswordProtected
877. *
878. * @return Disc
879. */
880. public function setIsPasswordProtected($isPasswordProtected)
881. {
882. $this->is_password_protected = $isPasswordProtected;
884. return $this;
885. }
887. /**
888. * Get is_password_protected
889. *
890. * @return bool
891. */
892. public function getIsPasswordProtected()
893. {
894. return $this->is_password_protected;
895. }
897. /**
898. * Set status_reason_code
899. *
900. * @param int|null $statusReasonCode
901. *
902. * @return Disc
903. */
904. public function setStatusReasonCode(?int $statusReasonCode)
905. {
906. $this->status_reason_code = $statusReasonCode;
908. return $this;
909. }
911. /**
912. * Get status_reason_code
913. *
914. * @return int
915. */
916. public function getStatusReasonCode()
917. {
918. return $this->status_reason_code;
919. }
921. /**
922. * Set deletedAt
923. *
924. * @param \DateTime $deletedAt
925. *
926. * @return Disc
927. */
928. public function setDeletedAt($deletedAt)
929. {
930. $this->deletedAt = $deletedAt;
932. return $this;
933. }
935. /**
936. * Get deletedAt
937. *
938. * @return \DateTime
939. */
940. public function getDeletedAt()
941. {
942. return $this->deletedAt;
943. }
945. /**
946. * Set creator
947. *
948. * @param User $creator
949. *
950. * @return Disc
951. */
952. public function setCreator(User $creator)
953. {
954. $this->creator = $creator;
956. return $this;
957. }
959. /**
960. * Get creator
961. *
962. * @return User
963. */
964. public function getCreator()
965. {
966. return $this->creator;
967. }
969. /**
970. * Add discImportSession
971. *
972. * @param DiscImportSession $discImportSession
973. *
974. * @return Disc
975. */
976. public function addDiscImportSession(DiscImportSession $discImportSession)
977. {
978. $this->discImportSessions[] = $discImportSession;
980. return $this;
981. }
983. /**
984. * Remove discImportSession
985. *
986. * @param DiscImportSession $discImportSession
987. */
988. public function removeDiscImportSession(DiscImportSession $discImportSession)
989. {
990. $this->discImportSessions->removeElement($discImportSession);
991. }
993. /**
994. * Get discImportSessions
995. *
996. * @return DoctrineCollection
997. */
998. public function getDiscImportSessions()
999. {
1000. return $this->discImportSessions;
1001. }
1003. /**
1004. * Add study
1005. *
1006. * @param Study $study
1007. *
1008. * @return Disc
1009. */
1010. public function addStudy(Study $study)
1011. {
1012. $this->studies[] = $study;
1014. return $this;
1015. }
1017. /**
1018. * Remove study
1019. *
1020. * @param Study $study
1021. */
1022. public function removeStudy(Study $study)
1023. {
1024. $this->studies->removeElement($study);
1025. }
1027. /**
1028. * Get studies
1029. *
1030. * @return Study[]|DoctrineCollection
1031. */
1032. public function getStudies()
1033. {
1034. return $this->studies;
1035. }
1037. /**
1038. * Set archiveFilesize
1039. *
1040. * @param string $archiveFilesize
1041. *
1042. * @return Disc
1043. */
1044. public function setArchiveFilesize($archiveFilesize)
1045. {
1046. $this->archiveFilesize = $archiveFilesize;
1048. return $this;
1049. }
1051. /**
1052. * Get archiveFilesize
1053. *
1054. * @return string
1055. */
1056. public function getArchiveFilesize()
1057. {
1058. return $this->archiveFilesize;
1059. }
1061. /**
1062. * Set processingPriority
1063. *
1064. * @param int $processingPriority
1065. *
1066. * @return Disc
1067. */
1068. public function setProcessingPriority($processingPriority)
1069. {
1070. $this->processingPriority = $processingPriority;
1072. return $this;
1073. }
1075. /**
1076. * Get processingPriority
1077. *
1078. * @return int
1079. */
1080. public function getProcessingPriority()
1081. {
1082. return $this->processingPriority;
1083. }
1085. /**
1086. * Returns true if the Disc has been prioritised,
1087. *
1088. * @return bool
1089. */
1090. public function isPrioritised()
1091. {
1092. return $this->getProcessingPriority() === self::PROCESSING_PRIORITY_HIGH;
1093. }
1095. /**
1096. * Sets the processing priority of the Disc to the default value.
1097. *
1098. * @return void
1099. */
1100. public function setProcessingPriorityToDefault()
1101. {
1102. $this->setProcessingPriority(self::PROCESSING_PRIORITY_LOW);
1103. }
1105. /**
1106. * Set batchRequest
1107. *
1108. * @param BatchRequest $batchRequest
1109. *
1110. * @return Disc
1111. */
1112. public function setBatchRequest(?BatchRequest $batchRequest = null)
1113. {
1114. $this->batchRequest = $batchRequest;
1116. return $this;
1117. }
1119. /**
1120. * Get batchRequest
1121. *
1122. * @return BatchRequest
1123. */
1124. public function getBatchRequest()
1125. {
1126. return $this->batchRequest;
1127. }
1129. /**
1130. * Check whether Disc is available for download
1131. *
1132. * @return bool
1133. */
1134. public function isDownloadable()
1135. {
1136. $nonDownloadableStatuses = [
1137. self::STATUS_PENDING_UPLOAD,
1138. self::STATUS_FAILED_VIRUS,
1139. ];
1141. return !in_array($this->getStatus(), $nonDownloadableStatuses);
1142. }
1144. /**
1145. * Extracts the Trust name from a Disc's name
1146. *
1147. * @return string
1148. */
1149. public function getTrustFromName()
1150. {
1151. // A trust is only available if the Disc has a name
1152. if ($this->getName()) {
1153. // We can only assume the name is conventional and properly structured. If it isn't,
1154. // that's not our fault
1155. return preg_match("/^(.+) - Disc \d+/i", $this->getName(), $discName) ? $discName[1] : $this->getName();
1156. }
1157. // A Disc has no name - Arya Stark 2020
1158. return 'Unknown';
1159. }
1161. /**
1162. * Extracts the Disc number from a Disc's name
1163. *
1164. * @return string
1165. */
1166. public function getDiscNumberFromName()
1167. {
1168. // Disc number is only available if the Disc has a name
1169. if ($this->getName()) {
1170. // We can only assume the name is conventional and properly structured. If it isn't,
1171. // that's not our fault
1172. return preg_match("/^.+ - Disc (\d+)/i", $this->getName(), $discNumber) ? $discNumber[1] : 'Unknown';
1173. }
1174. // A Disc has no name - Jaqen H'ghar 2020
1175. return 'Unknown';
1176. }
1178. /**
1179. * @return null|string
1180. */
1181. public function getDeleteStatus(): ?string
1182. {
1183. return $this->deleteStatus;
1184. }
1186. /**
1187. * @param string|null $deleteStatus
1188. *
1189. * @return self
1190. */
1191. public function setDeleteStatus(?string $deleteStatus): self
1192. {
1193. $this->deleteStatus = $deleteStatus;
1195. return $this;
1196. }
1198. /**
1199. * @return DiscMetadata|null
1200. */
1201. public function getDiscMetadata(): ?DiscMetadata
1202. {
1203. return $this->discMetadata;
1204. }
1206. /**
1207. * @param DiscMetadata $discMetadata
1208. *
1209. * @return $this
1210. */
1211. public function setDiscMetadata(DiscMetadata $discMetadata): self
1212. {
1213. // set the owning side of the relation if necessary
1214. if ($discMetadata->getDisc() !== $this) {
1215. $discMetadata->setDisc($this);
1216. }
1218. $this->discMetadata = $discMetadata;
1220. return $this;
1221. }
1223. /**
1224. * Determines whether the Disc has associated DiscMetadata (legacy discs will not have any and
1225. * will need to use legacy Orthanc calls to determine some meta)
1226. *
1227. * @return bool
1228. */
1229. public function hasDiscMetadata(): bool
1230. {
1231. return ($this->discMetadata !== null);
1232. }
1234. /**
1235. * Returns a human-readable string representation of the failure error code. Because of
1236. * custom logic here, we don't use the FilterableClassConstants trait.
1237. *
1238. * @return string
1239. */
1240. public function getFailureReasonHumanReadable(): string
1241. {
1242. if (($code = $this->getStatusReasonCode()) === null) {
1243. return 'Disc has no failure code';
1244. }
1246. $mapping = [
1247. self::STATUS_REASON_CODE_ARCHIVE_ERROR_UNKNOWN => self::STATUS_REASON_CODE_ARCHIVE_ERROR_UNKNOWN__LABEL,
1248. self::STATUS_REASON_CODE_ARCHIVE_ERROR_PASSWORD_INVALID => self::STATUS_REASON_CODE_ARCHIVE_ERROR_PASSWORD_INVALID__LABEL,
1249. self::STATUS_REASON_CODE_ARCHIVE_CONTAINS_NO_DICOM_FILES => self::STATUS_REASON_CODE_ARCHIVE_CONTAINS_NO_DICOM_FILES__LABEL,
1250. self::STATUS_REASON_CODE_ORTHANC_UNAVAILABLE => self::STATUS_REASON_CODE_ORTHANC_UNAVAILABLE__LABEL,
1251. self::STATUS_REASON_CODE_EXCEPTION_THROWN => self::STATUS_REASON_CODE_EXCEPTION_THROWN__LABEL,
1252. self::STATUS_REASON_CODE_ARCHIVE_NONEXISTENT => self::STATUS_REASON_CODE_ARCHIVE_NONEXISTENT__LABEL,
1253. ];
1255. if ($code > self::STATUS_REASON_CODE_MAX_ATTEMPTS_EXCEEDED) {
1256. $previousReasonCode = $code - self::STATUS_REASON_CODE_MAX_ATTEMPTS_EXCEEDED;
1258. return sprintf('%s: %s', self::STATUS_REASON_CODE_MAX_ATTEMPTS_EXCEEDED__LABEL, $mapping[$previousReasonCode]);
1259. }
1261. return $mapping[$code];
1262. }
1264. /**
1265. * @return DoctrineCollection<int, Instance>
1266. */
1267. public function getInstances(): DoctrineCollection
1268. {
1269. return $this->instances;
1270. }
1272. /**
1273. * @param Instance $instance
1274. *
1275. * @return $this
1276. */
1277. public function addInstance(Instance $instance): self
1278. {
1279. if (!$this->instances->contains($instance)) {
1280. $this->instances[] = $instance;
1281. $instance->addDisc($this);
1282. }
1284. return $this;
1285. }
1287. /**
1288. * @param Instance $instance
1289. *
1290. * @return $this
1291. */
1292. public function removeInstance(Instance $instance): self
1293. {
1294. if ($this->instances->removeElement($instance)) {
1295. $instance->removeDisc($this);
1296. }
1298. return $this;
1299. }
1301. /**
1302. * @return int|null
1303. */
1304. public function getPreMigrationStatus(): ?int
1305. {
1306. return $this->preMigrationStatus;
1307. }
1309. /**
1310. * @param int|null $preMigrationStatus
1311. *
1312. * @return self
1313. */
1314. public function setPreMigrationStatus(?int $preMigrationStatus): self
1315. {
1316. $this->preMigrationStatus = $preMigrationStatus;
1318. return $this;
1319. }
1321. /**
1322. * Returns true if the disc has a pre-migration status and that status does not match its current status.
1323. * Active are assumed successfully migrated - as if the disc failed prior to migration, and succeeded with migration,
1324. * we consider it a success.
1325. *
1326. * @return bool
1327. */
1328. public function hasDiscFailedMigration(): bool
1329. {
1330. return !$this->isActive() && $this->getPreMigrationStatus() !== null && $this->getStatus() !== $this->getPreMigrationStatus();
1331. }
1333. /**
1334. * @return int|null
1335. */
1336. public function getOriginalDiscId(): ?int
1337. {
1338. return $this->originalDiscId;
1339. }
1341. /**
1342. * @param int|null $originalDiscId
1343. *
1344. * @return self
1345. */
1346. public function setOriginalDiscId(?int $originalDiscId): self
1347. {
1348. $this->originalDiscId = $originalDiscId;
1350. return $this;
1351. }
1353. /**
1354. * Check whether Disc is archived
1355. *
1356. * @return bool
1357. */
1358. public function isArchived()
1359. {
1360. $archivedStatuses = [
1361. self::STATUS_PENDING_ARCHIVE,
1362. self::STATUS_ARCHIVED,
1363. self::STATUS_PROCESSING_CURRENT_ARCHIVING,
1364. self::STATUS_ARCHIVED_FAILED,
1365. ];
1367. return in_array($this->getStatus(), $archivedStatuses);
1368. }
1370. /**
1371. * Returns a human readable version of the deleted statuses
1372. *
1373. * @return null|string
1374. */
1375. public function getDeletedStatusLabel(): ?string
1376. {
1377. return self::DELETE_STATUS__LABEL;
1378. }
1380. /**
1381. * @return VirusScanItem|null
1382. */
1383. public function getVirusScanItem(): ?VirusScanItem
1384. {
1385. return $this->virusScanItem;
1386. }
1388. /**
1389. * @param VirusScanItem|null $virusScanItem
1390. *
1391. * @return self
1392. */
1393. public function setVirusScanItem(?VirusScanItem $virusScanItem): self
1394. {
1395. // unset the owning side of the relation if necessary
1396. if ($virusScanItem === null && $this->virusScanItem !== null) {
1397. $this->virusScanItem->setDisc(null);
1398. }
1400. // set the owning side of the relation if necessary
1401. if ($virusScanItem !== null && $virusScanItem->getDisc() !== $this) {
1402. $virusScanItem->setDisc($this);
1403. }
1405. $this->virusScanItem = $virusScanItem;
1407. return $this;
1408. }
1410. /**
1411. * @param VirusScannerPathVisitorInterface $virusScannerPathVisitor
1412. *
1413. * @return VirusScannerVisitorInterface
1414. */
1415. public function acceptVirusScannerPathVisitor(VirusScannerPathVisitorInterface $virusScannerPathVisitor): string
1416. {
1417. return $virusScannerPathVisitor->visitDisc($this);
1418. }
1419. }