Group_Visit_Manager::getCreatedVisits() - Code Metrics - salimkanoun/GaelO - Measure and Improve Code Quality continuously with Scrutinizer

Group_Visit_Manager::getCreatedVisits() A
last analyzed 2021-07-04 22:07 UTC

↳ Parent: Group_Visit_Manager

Complexity

Conditions	2
Paths	2

Size

Total Lines	23
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	9
nc	2
nop	1
dl	0
loc	23
c	0
b	0
f	0
cc	2
rs	9.9666

<?php

/**
 Copyright (C) 2018-2020 KANOUN Salim
 This program is free software; you can redistribute it and/or modify
 it under the terms of the Affero GNU General Public v.3 License as published by
 the Free Software Foundation;
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 Affero GNU General Public Public for more details.
 You should have received a copy of the Affero GNU General Public Public along
 with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * Manage visit for a group level of a study
 */

class Group_Visit_Manager
{

	private Study $studyObject;
	private Visit_Group $visitGroupObject;
	private PDO $linkpdo;


	public function __construct(Study $studyObject, Visit_Group $visitGroupObject, PDO $linkpdo)
	{
		$this->linkpdo=$linkpdo;
		$this->studyObject=$studyObject;
		$this->visitGroupObject=$visitGroupObject;
	}

	public function getVisitGroupObject(): Visit_Group
	{
		return $this->visitGroupObject;
	}

	/**
	 * Return uploaded and non deleted visit Objects (visit Done and Upload status done)
	 */
	public function getUploadedVisits(): array
	{

		$uploadedVisitQuery=$this->linkpdo->prepare('SELECT id_visit FROM visits 
                                                                    INNER JOIN visit_type ON 
                                                                        (visit_type.id=visits.visit_type_id 
                                                                        AND visit_type.group_id = :visitGroupId)
                                                                WHERE deleted=0
                                                                    AND upload_status="Done" ');

		$uploadedVisitQuery->execute(array(
			'visitGroupId' => $this->visitGroupObject->groupId
		));

		$uploadedVisitIds=$uploadedVisitQuery->fetchall(PDO::FETCH_COLUMN);

		$visitObjectArray=[];
		foreach ($uploadedVisitIds as $id_visit) {
			$visitObjectArray[]=new Visit($id_visit, $this->linkpdo);
		}

		return $visitObjectArray;
	}

	/**
	 * Get visits with a awaiting upload status (Visit Done but upload status not done)
	 */
	public function getAwaitingUploadVisit(): array
	{

		$uploadedVisitQuery=$this->linkpdo->prepare("SELECT id_visit FROM visits 
                                                                    INNER JOIN visit_type ON 
                                                                         (visit_type.id=visits.visit_type_id 
                                                                            AND visit_type.group_id = :visitGroupId)
                                                                WHERE deleted=0
														        AND upload_status = 'Not Done'
														        AND status_done = 'Done' ");

		$uploadedVisitQuery->execute(
			array(
				'visitGroupId' => $this->visitGroupObject->groupId
			)
		);
		$uploadedVisitIds=$uploadedVisitQuery->fetchAll(PDO::FETCH_COLUMN);

		$visitObjectArray=[];
		foreach ($uploadedVisitIds as $id_visit) {
			$visitObjectArray[]=new Visit($id_visit, $this->linkpdo);
		}

		return $visitObjectArray;
	}

	/**
	 * Get Visits awaiting review
	 * Optionally visit awaiting review can be specific to an username
	 * @param string $username
	 * @return Visit[]
	 */
	public function getAwaitingReviewVisit(string $username=null): array
	{

		//Query visit to analyze visit awaiting a review
		$idVisitsQuery=$this->linkpdo->prepare('SELECT id_visit FROM visits 
                                                                    INNER JOIN visit_type ON 
                                                                        (visit_type.id=visits.visit_type_id 
                                                                        AND visit_type.group_id = :visitGroupId)
                                                                WHERE deleted=0
                                                                AND review_available=1 
                                                                ORDER BY visit_type.visit_order ');

		$idVisitsQuery->execute(array(
			'visitGroupId' => $this->visitGroupObject->groupId
		));

		$visitList=$idVisitsQuery->fetchAll(PDO::FETCH_COLUMN);

		$visitObjectArray=[];

		foreach ($visitList as $visitId) {
			$visitObject=new Visit($visitId, $this->linkpdo);

			if (!empty($username)) {
				if ($visitObject->isAwaitingReviewForReviewerUser($username)) {
					$visitObjectArray[]=$visitObject;
				}
			}else {
				$visitObjectArray[]=$visitObject;
			}
		}

		return $visitObjectArray;
	}

	/**
	 * For controller tree
	 * List all visits that awaiting QC Action (QC not done or waiting definitive conclusion)
	 */
	public function getVisitForControllerAction(): array
	{

		$visitsQuery=$this->linkpdo->prepare('SELECT id_visit FROM visits 
                                                    INNER JOIN visit_type ON 
                                                        (visit_type.id=visits.visit_type_id 
                                                        AND visit_type.group_id = :visitGroupId)
                                                    WHERE deleted=0
                                                    AND status_done = "Done"
                                                    AND upload_status= "Done"
                                                    AND state_investigator_form = "Done"
                                                    AND (state_quality_control = "Not Done"
                                                        OR state_quality_control = "Wait Definitive Conclusion")
                                                    ORDER BY visit_type.visit_order');
		$visitsQuery->execute(array(
			'visitGroupId' => $this->visitGroupObject->groupId
		));

		$visits=$visitsQuery->fetchAll(PDO::FETCH_COLUMN);

		$visitObjectArray=[];
		foreach ($visits as $visit) {
			$visitObjectArray[]=new Visit($visit, $this->linkpdo);
		}

		return $visitObjectArray;
	}

	/**
	 * Return visits with a specific QC Status
	 */
	public function getVisitWithQCStatus($qcStatus): array
	{

		$visitQuery=$this->linkpdo->prepare("SELECT id_visit FROM visits 
                                                        INNER JOIN visit_type ON 
                                                            (visit_type.id=visits.visit_type_id 
                                                            AND visit_type.group_id = :visitGroupId)
                                                        WHERE deleted=0
                                                        AND state_quality_control=:qcStatus");

		$visitQuery->execute(array(
			'study' => $this->study,

			'qcStatus' => $qcStatus,
			'visitGroupId' => $this->visitGroupObject->groupId
		));
		$visitIds=$visitQuery->fetchall(PDO::FETCH_COLUMN);

		$visitObjectArray=[];
		foreach ($visitIds as $id_visit) {
			$visitObjectArray[]=new Visit($id_visit, $this->linkpdo);
		}

		return $visitObjectArray;
	}

	/**
	 * Get Visits with image uploaded status but investigator form missing
	 */
	public function getVisitsMissingInvestigatorForm(): array
	{

		$visitQuery=$this->linkpdo->prepare("SELECT id_visit FROM visits 
                                                            INNER JOIN visit_type ON 
                                                                (visit_type.id=visits.visit_type_id 
                                                                AND visit_type.group_id = :visitGroupId)
                                                            WHERE deleted=0 
                                                            AND state_investigator_form !='Done' 
                                                            AND upload_status='Done'");

		$visitQuery->execute(array(
			'visitGroupId' => $this->visitGroupObject->groupId
		));

		$visitIds=$visitQuery->fetchAll(PDO::FETCH_COLUMN);

		$visitObjectArray=[];
		foreach ($visitIds as $id_visit) {
			$visitObjectArray[]=new Visit($id_visit, $this->linkpdo);
		}

		return $visitObjectArray;
	}

	/**
	 * Return studie's created visits
	 */
	public function getCreatedVisits(bool $deleted=false): array
	{

		$uploadedVisitQuery=$this->linkpdo->prepare('SELECT id_visit FROM visits 
                                                    INNER JOIN visit_type ON 
                                                        (visit_type.id=visits.visit_type_id 
                                                        AND visit_type.group_id = :visitGroupId)
                                                    AND deleted = :deleted 
                                                    ORDER BY patient_code, visit_type.visit_order');

		$uploadedVisitQuery->execute(array(
			'deleted' => intval($deleted),
			'visitGroupId' => $this->visitGroupObject->groupId
		));

		$uploadedVisitIds=$uploadedVisitQuery->fetchAll(PDO::FETCH_COLUMN);

		$visitObjectArray=[];
		foreach ($uploadedVisitIds as $id_visit) {
			$visitObjectArray[]=new Visit($id_visit, $this->linkpdo);
		}

		return $visitObjectArray;
	}

	/**
	 * Determine all patient status for a specific visitType
	 */
	public function getPatientVisitStatusForVisitType(Visit_Type $visitType)
	{

		//Get patients list in this study
		$allPatients=$this->studyObject->getAllPatientsInStudy();

		$results=[];

		foreach ($allPatients as $patient) {

			$patientCenter=$patient->getPatientCenter();
			$visitManager=$patient->getPatientVisitManager($this->visitGroupObject);

			$patientData=[];
			$patientData['center']=$patientCenter->name;
			$patientData['country']=$patientCenter->countryName;
			$patientData['firstname']=$patient->patientFirstName;
			$patientData['lastname']=$patient->patientLastName;
			$patientData['birthdate']=$patient->patientBirthDate;
			$patientData['registration_date']=$patient->patientRegistrationDate;

			$visitStatus=$visitManager->determineVisitStatus($visitType->name);

			$results[$patient->patientCode]=array_merge($patientData, $visitStatus);
		}

		return $results;
	}

	/**
	 * Determine all visits status for all visit type for all patients
	 */
	public function getPatientsAllVisitsStatus()
	{

		//Get ordered list of possible visits in this study
		$allVisitsType=$this->visitGroupObject->getAllVisitTypesOfGroup();

		$results=[];

		foreach ($allVisitsType as $visitType) {

			$allPatientStatus=$this->getPatientVisitStatusForVisitType($visitType);

			$results[$visitType->name]=$allPatientStatus;
			//array_push($results, ...$allPatientStatus);
		}

		return $results;
	}
}


1			<?php
2
3			/**
4			Copyright (C) 2018-2020 KANOUN Salim
5			This program is free software; you can redistribute it and/or modify
6			it under the terms of the Affero GNU General Public v.3 License as published by
7			the Free Software Foundation;
8			This program is distributed in the hope that it will be useful,
9			but WITHOUT ANY WARRANTY; without even the implied warranty of
10			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11			Affero GNU General Public Public for more details.
12			You should have received a copy of the Affero GNU General Public Public along
13			with this program; if not, write to the Free Software Foundation, Inc.,
14			51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15			*/
16
17			/**
18			* Manage visit for a group level of a study
19			*/
20
21			class Group_Visit_Manager
22			{
23
24			private Study $studyObject;
25			private Visit_Group $visitGroupObject;
26			private PDO $linkpdo;
27
28
29			public function __construct(Study $studyObject, Visit_Group $visitGroupObject, PDO $linkpdo)
30			{
31			$this->linkpdo=$linkpdo;
32			$this->studyObject=$studyObject;
33			$this->visitGroupObject=$visitGroupObject;
34			}
35
36			public function getVisitGroupObject(): Visit_Group
37			{
38			return $this->visitGroupObject;
39			}
40
41			/**
42			* Return uploaded and non deleted visit Objects (visit Done and Upload status done)
43			*/
44			public function getUploadedVisits(): array
45			{
46
47			$uploadedVisitQuery=$this->linkpdo->prepare('SELECT id_visit FROM visits
48			INNER JOIN visit_type ON
49			(visit_type.id=visits.visit_type_id
50			AND visit_type.group_id = :visitGroupId)
51			WHERE deleted=0
52			AND upload_status="Done" ');
53
54			$uploadedVisitQuery->execute(array(
55			'visitGroupId' => $this->visitGroupObject->groupId
56			));
57
58			$uploadedVisitIds=$uploadedVisitQuery->fetchall(PDO::FETCH_COLUMN);
59
60			$visitObjectArray=[];
61			foreach ($uploadedVisitIds as $id_visit) {
62			$visitObjectArray[]=new Visit($id_visit, $this->linkpdo);
63			}
64
65			return $visitObjectArray;
66			}
67
68			/**
69			* Get visits with a awaiting upload status (Visit Done but upload status not done)
70			*/
71			public function getAwaitingUploadVisit(): array
72			{
73
74			$uploadedVisitQuery=$this->linkpdo->prepare("SELECT id_visit FROM visits
75			INNER JOIN visit_type ON
76			(visit_type.id=visits.visit_type_id
77			AND visit_type.group_id = :visitGroupId)
78			WHERE deleted=0
79			AND upload_status = 'Not Done'
80			AND status_done = 'Done' ");
81
82			$uploadedVisitQuery->execute(
83			array(
84			'visitGroupId' => $this->visitGroupObject->groupId
85			)
86			);
87			$uploadedVisitIds=$uploadedVisitQuery->fetchAll(PDO::FETCH_COLUMN);
88
89			$visitObjectArray=[];
90			foreach ($uploadedVisitIds as $id_visit) {
91			$visitObjectArray[]=new Visit($id_visit, $this->linkpdo);
92			}
93
94			return $visitObjectArray;
95			}
96
97			/**
98			* Get Visits awaiting review
99			* Optionally visit awaiting review can be specific to an username
100			* @param string $username
101			* @return Visit[]
102			*/
103			public function getAwaitingReviewVisit(string $username=null): array
104			{
105
106			//Query visit to analyze visit awaiting a review
107			$idVisitsQuery=$this->linkpdo->prepare('SELECT id_visit FROM visits
108			INNER JOIN visit_type ON
109			(visit_type.id=visits.visit_type_id
110			AND visit_type.group_id = :visitGroupId)
111			WHERE deleted=0
112			AND review_available=1
113			ORDER BY visit_type.visit_order ');
114
115			$idVisitsQuery->execute(array(
116			'visitGroupId' => $this->visitGroupObject->groupId
117			));
118
119			$visitList=$idVisitsQuery->fetchAll(PDO::FETCH_COLUMN);
120
121			$visitObjectArray=[];
122
123			foreach ($visitList as $visitId) {
124			$visitObject=new Visit($visitId, $this->linkpdo);
125
126			if (!empty($username)) {
127			if ($visitObject->isAwaitingReviewForReviewerUser($username)) {
128			$visitObjectArray[]=$visitObject;
129			}
130			}else {
131			$visitObjectArray[]=$visitObject;
132			}
133			}
134
135			return $visitObjectArray;
136			}
137
138			/**
139			* For controller tree
140			* List all visits that awaiting QC Action (QC not done or waiting definitive conclusion)
141			*/
142			public function getVisitForControllerAction(): array
143			{
144
145			$visitsQuery=$this->linkpdo->prepare('SELECT id_visit FROM visits
146			INNER JOIN visit_type ON
147			(visit_type.id=visits.visit_type_id
148			AND visit_type.group_id = :visitGroupId)
149			WHERE deleted=0
150			AND status_done = "Done"
151			AND upload_status= "Done"
152			AND state_investigator_form = "Done"
153			AND (state_quality_control = "Not Done"
154			OR state_quality_control = "Wait Definitive Conclusion")
155			ORDER BY visit_type.visit_order');
156			$visitsQuery->execute(array(
157			'visitGroupId' => $this->visitGroupObject->groupId
158			));
159
160			$visits=$visitsQuery->fetchAll(PDO::FETCH_COLUMN);
161
162			$visitObjectArray=[];
163			foreach ($visits as $visit) {
164			$visitObjectArray[]=new Visit($visit, $this->linkpdo);
165			}
166
167			return $visitObjectArray;
168			}
169
170			/**
171			* Return visits with a specific QC Status
172			*/
173			public function getVisitWithQCStatus($qcStatus): array
174			{
175
176			$visitQuery=$this->linkpdo->prepare("SELECT id_visit FROM visits
177			INNER JOIN visit_type ON
178			(visit_type.id=visits.visit_type_id
179			AND visit_type.group_id = :visitGroupId)
180			WHERE deleted=0
181			AND state_quality_control=:qcStatus");
182
183			$visitQuery->execute(array(
184			'study' => $this->study,
			0 ignored issues – show Bug introduced 2020-03-31 22:08 UTC by Report Bug Copy Issue Report The property `study` does not exist on `Group_Visit_Manager`. Did you mean `studyObject`? Loading history...
185			'qcStatus' => $qcStatus,
186			'visitGroupId' => $this->visitGroupObject->groupId
187			));
188			$visitIds=$visitQuery->fetchall(PDO::FETCH_COLUMN);
189
190			$visitObjectArray=[];
191			foreach ($visitIds as $id_visit) {
192			$visitObjectArray[]=new Visit($id_visit, $this->linkpdo);
193			}
194
195			return $visitObjectArray;
196			}
197
198			/**
199			* Get Visits with image uploaded status but investigator form missing
200			*/
201			public function getVisitsMissingInvestigatorForm(): array
202			{
203
204			$visitQuery=$this->linkpdo->prepare("SELECT id_visit FROM visits
205			INNER JOIN visit_type ON
206			(visit_type.id=visits.visit_type_id
207			AND visit_type.group_id = :visitGroupId)
208			WHERE deleted=0
209			AND state_investigator_form !='Done'
210			AND upload_status='Done'");
211
212			$visitQuery->execute(array(
213			'visitGroupId' => $this->visitGroupObject->groupId
214			));
215
216			$visitIds=$visitQuery->fetchAll(PDO::FETCH_COLUMN);
217
218			$visitObjectArray=[];
219			foreach ($visitIds as $id_visit) {
220			$visitObjectArray[]=new Visit($id_visit, $this->linkpdo);
221			}
222
223			return $visitObjectArray;
224			}
225
226			/**
227			* Return studie's created visits
228			*/
229			public function getCreatedVisits(bool $deleted=false): array
230			{
231
232			$uploadedVisitQuery=$this->linkpdo->prepare('SELECT id_visit FROM visits
233			INNER JOIN visit_type ON
234			(visit_type.id=visits.visit_type_id
235			AND visit_type.group_id = :visitGroupId)
236			AND deleted = :deleted
237			ORDER BY patient_code, visit_type.visit_order');
238
239			$uploadedVisitQuery->execute(array(
240			'deleted' => intval($deleted),
241			'visitGroupId' => $this->visitGroupObject->groupId
242			));
243
244			$uploadedVisitIds=$uploadedVisitQuery->fetchAll(PDO::FETCH_COLUMN);
245
246			$visitObjectArray=[];
247			foreach ($uploadedVisitIds as $id_visit) {
248			$visitObjectArray[]=new Visit($id_visit, $this->linkpdo);
249			}
250
251			return $visitObjectArray;
252			}
253
254			/**
255			* Determine all patient status for a specific visitType
256			*/
257			public function getPatientVisitStatusForVisitType(Visit_Type $visitType)
258			{
259
260			//Get patients list in this study
261			$allPatients=$this->studyObject->getAllPatientsInStudy();
262
263			$results=[];
264
265			foreach ($allPatients as $patient) {
266
267			$patientCenter=$patient->getPatientCenter();
268			$visitManager=$patient->getPatientVisitManager($this->visitGroupObject);
269
270			$patientData=[];
271			$patientData['center']=$patientCenter->name;
272			$patientData['country']=$patientCenter->countryName;
273			$patientData['firstname']=$patient->patientFirstName;
274			$patientData['lastname']=$patient->patientLastName;
275			$patientData['birthdate']=$patient->patientBirthDate;
276			$patientData['registration_date']=$patient->patientRegistrationDate;
277
278			$visitStatus=$visitManager->determineVisitStatus($visitType->name);
279
280			$results[$patient->patientCode]=array_merge($patientData, $visitStatus);
281			}
282
283			return $results;
284			}
285
286			/**
287			* Determine all visits status for all visit type for all patients
288			*/
289			public function getPatientsAllVisitsStatus()
290			{
291
292			//Get ordered list of possible visits in this study
293			$allVisitsType=$this->visitGroupObject->getAllVisitTypesOfGroup();
294
295			$results=[];
296
297			foreach ($allVisitsType as $visitType) {
298
299			$allPatientStatus=$this->getPatientVisitStatusForVisitType($visitType);
300
301			$results[$visitType->name]=$allPatientStatus;
302			//array_push($results, ...$allPatientStatus);
303			}
304
305			return $results;
306			}
307			}
308

salimkanoun / GaelO

Group_Visit_Manager::getCreatedVisits() A last analyzed 2021-07-04 22:07 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Group_Visit_Manager::getCreatedVisits() A
last analyzed 2021-07-04 22:07 UTC