Code Coverage for /opt/homebrew/var/www/html/Linways/ams-professional-core/src/com/linways/core/ams/professional/service/academic/GroupService.php

	Code Coverage
	Classes and Traits			Functions and Methods				Lines
Total	0.00% covered (danger)	0.00%	0 / 1	0.00% covered (danger)	0.00%	0 / 22	CRAP	0.00% covered (danger)	0.00%	0 / 520
GroupService	0.00% covered (danger)	0.00%	0 / 1	0.00% covered (danger)	0.00%	0 / 22	17822.00	0.00% covered (danger)	0.00%	0 / 520
__construct				0.00% covered (danger)	0.00%	0 / 1	2.00	0.00% covered (danger)	0.00%	0 / 2
saveGroup				0.00% covered (danger)	0.00%	0 / 1	72.00	0.00% covered (danger)	0.00%	0 / 32
validateSaveGroupRequest				0.00% covered (danger)	0.00%	0 / 1	12.00	0.00% covered (danger)	0.00%	0 / 6
insertGroup				0.00% covered (danger)	0.00%	0 / 1	20.00	0.00% covered (danger)	0.00%	0 / 15
updateGroup				0.00% covered (danger)	0.00%	0 / 1	20.00	0.00% covered (danger)	0.00%	0 / 20
deleteGroup				0.00% covered (danger)	0.00%	0 / 1	12.00	0.00% covered (danger)	0.00%	0 / 18
restoreGroup				0.00% covered (danger)	0.00%	0 / 1	12.00	0.00% covered (danger)	0.00%	0 / 18
searchGroup				0.00% covered (danger)	0.00%	0 / 1	380.00	0.00% covered (danger)	0.00%	0 / 52
getGroupDetails				0.00% covered (danger)	0.00%	0 / 1	12.00	0.00% covered (danger)	0.00%	0 / 25
getBatchDetailsByClusterAndBatchGroupId				0.00% covered (danger)	0.00%	0 / 1	20.00	0.00% covered (danger)	0.00%	0 / 26
saveBatchGroup				0.00% covered (danger)	0.00%	0 / 1	56.00	0.00% covered (danger)	0.00%	0 / 26
saveSubjectStudentGroup				0.00% covered (danger)	0.00%	0 / 1	56.00	0.00% covered (danger)	0.00%	0 / 26
addStudentsGroup				0.00% covered (danger)	0.00%	0 / 1	2.00	0.00% covered (danger)	0.00%	0 / 7
getAssignedSyllabusesFromGroupId				0.00% covered (danger)	0.00%	0 / 1	6.00	0.00% covered (danger)	0.00%	0 / 15
getStudentsBatchGroupFromBatchId				0.00% covered (danger)	0.00%	0 / 1	2.00	0.00% covered (danger)	0.00%	0 / 5
getAllGroups				0.00% covered (danger)	0.00%	0 / 1	240.00	0.00% covered (danger)	0.00%	0 / 40
getAllBatchAcademicYears				0.00% covered (danger)	0.00%	0 / 1	42.00	0.00% covered (danger)	0.00%	0 / 31
findGroupByProperties				0.00% covered (danger)	0.00%	0 / 1	30.00	0.00% covered (danger)	0.00%	0 / 16
deleteGroupPermanently				0.00% covered (danger)	0.00%	0 / 1	20.00	0.00% covered (danger)	0.00%	0 / 18
updateGroupProperties				0.00% covered (danger)	0.00%	0 / 1	702.00	0.00% covered (danger)	0.00%	0 / 91
setGroupToGroupRelations				0.00% covered (danger)	0.00%	0 / 1	12.00	0.00% covered (danger)	0.00%	0 / 17
haveId				0.00% covered (danger)	0.00%	0 / 1	20.00	0.00% covered (danger)	0.00%	0 / 14

1	<?php
2
3	namespace com\linways\core\ams\professional\service\academic;
4
5	use com\linways\base\util\SecurityUtils;
6	use com\linways\base\util\MakeSingletonTrait;
7	use com\linways\core\ams\professional\service\BaseService;
8	use com\linways\core\ams\professional\request\academic\MapStudentGroupRequest;
9	use com\linways\core\ams\professional\mapper\academic\GroupServiceMapper;
10	use com\linways\core\ams\professional\request\academic\SearchGroupRequest;
11	use com\linways\core\ams\professional\constant\academic\GroupTypeConstant;
12	use com\linways\core\ams\professional\constant\academic\StatusConstants;
13	use com\linways\core\ams\professional\dto\academics\BatchProperties as AcademicsBatchProperties;
14	use com\linways\core\ams\professional\dto\academics\SubjectProperties as AcademicsSubjectProperties;
15	use com\linways\core\ams\professional\exception\ProfessionalException;
16	use com\linways\core\ams\professional\dto\api\Group;
17	use com\linways\core\dto\BatchProperties;
18
19	class GroupService extends BaseService
20	{
21	use MakeSingletonTrait;
22
23	private function __construct() {
24	$this->mapper = GroupServiceMapper::getInstance()->getMapper();
25	}
26
27	/**
28	* Save group
29	* @param Group $group
30	* @return String $id
31	*/
32	public function saveGroup (Group $group)
33	{
34	$group = $this->realEscapeObject($group);
35	$group->createdBy = $GLOBALS['userId'] ?? $group->createdBy;
36	$group->updatedBy = $GLOBALS['userId'] ?? $group->updatedBy;
37
38	try{
39	$this->validateSaveGroupRequest($group);
40
41	if(!empty($group->id))
42	{
43	$group->id = $this->updateGroup($group);
44	}
45	else
46	{
47	$group->id = $this->insertGroup($group);
48	}
49
50	}catch(\Exception $e) {
51	if($e->getCode() !== ProfessionalException::INVALID_PARAMETER && $e->getCode() !== ProfessionalException::EMPTY_PARAMETERS && $e->getCode() !== ProfessionalException::DUPLICATE_ENTRY) {
52	throw new ProfessionalException($e->getCode(),"Failed to save Group! Please try again");
53	} else if ($e->getCode() === ProfessionalException::DUPLICATE_ENTRY) {
54	throw new ProfessionalException (ProfessionalException::DUPLICATE_ENTRY,"Cannot create group.$group->name already exists!");
55	} else {
56	throw new ProfessionalException ($e->getCode(),$e->getMessage());
57	}
58	}
59
60	switch ($group->type) {
61	case GroupTypeConstant::SUBJECT:
62	$this->setGroupToGroupRelations($group,'batchGroupIds');
63	break;
64	default:
65	break;
66	}
67
68	return $group->id;
69	}
70
71	/**
72	* Validate Group Request Before Saving
73	* @param Group $group
74	* @return NULL
75	*/
76	private function validateSaveGroupRequest(Group $group)
77	{
78	if(empty($group->name))
79	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Group name is empty! Please enter a name for group");
80	if(empty($group->type))
81	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Group type is empty! Please choose a type for group");
82	}
83
84	/**
85	* Insert Group
86	* @param Group $group
87	* @return String $id
88	*/
89	private function insertGroup(Group $group)
90	{
91	$properties = !empty($group->properties) ? "'" . json_encode($group->properties) . "'" : "NULL";
92	$identifyingContext = !empty($group->identifyingContext) ? "'" . json_encode($group->identifyingContext) . "'" : "NULL";
93	$id = SecurityUtils::getRandomString();
94
95	$query = "INSERT INTO `groups`
96	(`id`,`identifying_context`,`name`,`type`,`properties`,`created_by`,`updated_by`)
97	VALUES
98	('$id',$identifyingContext,'$group->name','$group->type',$properties,'$group->createdBy','$group->updatedBy')";
99
100	try {
101	$this->executeQuery($query);
102	return $id;
103	} catch (\Exception $e) {
104	throw new ProfessionalException($e->getCode(),$e->getMessage());
105	}
106	}
107
108	/**
109	* Update Group
110	* @param Group $group
111	* @return NULL
112	*/
113	private function updateGroup(Group $group)
114	{
115	$properties = !empty($group->properties) ? "'".json_encode($group->properties)."'" : "NULL";
116	$identifyingContext = !empty($group->identifying_context) ? "'" . json_encode($group->identifyingContext) . "'" : "NULL";
117
118	$query = "UPDATE
119	`groups`
120	SET
121	`identifying_context` = $identifyingContext,
122	`name` = '$group->name',
123	`type` = '$group->type',
124	`properties` = $properties,
125	`updated_by` = '$group->updatedBy'
126	WHERE
127	`id` = '$group->id'";
128
129	try {
130	$this->executeQuery($query);
131	return $group->id;
132	} catch (\Exception $e) {
133	throw new ProfessionalException($e->getCode(),$e->getMessage());
134	}
135	}
136
137	/**
138	* Delete Group (Soft Delete)
139	* @param String $id
140	* @return NULL
141	*/
142	public function deleteGroup($id)
143	{
144	$id = $this->realEscapeString($id);
145	$updatedBy = $GLOBALS['userId'];
146
147	if(empty($id))
148	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Group is invalid! Please enter a valid group");
149
150	$query = "UPDATE
151	`groups`
152	SET
153	`trashed` = UTC_TIMESTAMP(),
154	`updated_by` = '$updatedBy'
155	WHERE
156	`id` = '$id'";
157
158	try {
159	$this->executeQuery($query);
160	} catch (\Exception $e) {
161	throw new ProfessionalException(ProfessionalException::ERROR_DELETING,"Error deleting group! Please try again");
162	}
163	}
164
165	/**
166	* Restore Group
167	* @param String $id
168	* @return NULL
169	*/
170	public function restoreGroup($id)
171	{
172	$id = $this->realEscapeString($id);
173	$updatedBy = $GLOBALS['userId'];
174
175	if(empty($id))
176	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Group is invalid! Please enter a valid group");
177
178	$query = "UPDATE
179	`groups`
180	SET
181	`trashed` = NULL,
182	`updated_by` = '$updatedBy'
183	WHERE
184	`id` = '$id'";
185
186	try {
187	$this->executeQuery($query);
188	} catch (\Exception $e) {
189	throw new ProfessionalException(ProfessionalException::ERROR_RESTORING,"Error restoring academic term! Please try again");
190	}
191	}
192
193	/**
194	* Search Academic term Details
195	* @param SearchGroupRequest $request
196	* @return Group
197	*/
198	public function searchGroup(SearchGroupRequest $request)
199	{
200	$request = $this->realEscapeObject($request);
201
202	$whereQuery = "";
203	$limitQuery = "";
204	$where = [];
205
206
207
208	!empty($request->startYear)?$where [] = " JSON_CONTAINS(g.properties, '{\"startYear\":\"$request->startYear\"}') ":null;
209
210	!empty($request->endYear)?$where [] = " JSON_CONTAINS(g.properties, '{\"endYear\":\"$request->endYear\"}') ":null;
211
212	!empty($request->programId)?$where [] = " JSON_CONTAINS(g.properties, '{\"programId\":\"$request->programId\"}') ":null;
213
214
215	!empty($request->departmentId)?$where [] = " JSON_CONTAINS(g.properties, '{\"departmentId\":\"$request->departmentId\"}') ":null;
216
217	!empty($request->currentTermId)?$where [] = " JSON_CONTAINS(g.properties, '{\"currentTermId\":\"$request->currentTermId\"}') ":null;
218
219	!empty($request->curriculumId)?$where [] = " JSON_CONTAINS(g.properties, '{\"curriculumId\":\"$request->curriculumId\"}') ":null;
220
221	if(count($request->syllabusIds)){
222	$or = [];
223	foreach ($request->syllabusIds as $key => $syllabusId) {
224	$or [] = " JSON_CONTAINS(g.properties->'$.extraSyllabusId', '\"$syllabusId\"' ,'$') ";
225	}
226	$where [] = " (".implode(" OR ",$or).") ";
227	}
228
229	!empty($request->id)?$where [] = " g.id = '$request->id' ":null;
230
231	$request->trashed === StatusConstants::ACTIVE ? $where [] = " g.trashed IS NULL ":null;
232
233	$request->trashed === StatusConstants::TRASHED ? $where [] = " g.trashed IS NOT NULL ":null;
234
235	!empty($request->name) ? $where [] = " g.name LIKE '%$request->name%' ":null;
236
237	!empty($request->type) ? $where [] = " g.type LIKE '%$request->type%' ":null;
238
239
240
241	if($request->startIndex !== "" && $request->endIndex !== "")
242	{
243	$limitQuery .= " LIMIT $request->startIndex,$request->endIndex";
244	}
245
246	$query = "SELECT
247	g.id,
248	g.identifying_context,
249	g.name,
250	g.type,
251	g.properties,
252	g.trashed,
253	g.created_by,
254	g.created_date,
255	g.updated_by,
256	g.updated_date
257	FROM
258	`groups` g
259	".(count($where)? " WHERE ".implode(' AND ',$where):"");
260
261	try {
262	$groups = $this->executeQueryForList($query." ".$limitQuery, $this->mapper[GroupServiceMapper::SEARCH_GROUPS]);
263	} catch (\Exception $e) {
264	throw new ProfessionalException(ProfessionalException::ERROR_FETCHING,"Cannot fetch group details! Please try again.");
265	}
266
267	if(empty($groups))
268	{
269	$groups = [];
270	}
271
272	return $groups;
273	}
274
275	/**
276	* get Academic term by id
277	* @param String $id
278	* @return Group
279	*/
280	public function getGroupDetails($id)
281	{
282	$id = $this->realEscapeObject($id);
283
284	if(empty($id))
285	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Group is invalid! Please enter a valid group");
286
287
288	$query = "SELECT
289	g.id,
290	g.identifying_context,
291	g.name,
292	g.type,
293	g.trashed,
294	g.created_by,
295	g.created_date,
296	g.updated_by,
297	g.updated_date
298	FROM
299	`groups` g
300	WHERE
301	`id` = $id";
302
303	try {
304	$group = $this->executeQueryForObject($query, $this->mapper[GroupServiceMapper::SEARCH_GROUPS]);
305	} catch (\Exception $e) {
306	throw new ProfessionalException(ProfessionalException::ERROR_FETCHING,"Cannot fetch group details! Please try again");
307	}
308
309	return $group;
310	}
311
312	/**
313	* get Academic term by id
314	* @param String $id
315	* @return Group
316	*/
317	public function getBatchDetailsByClusterAndBatchGroupId($request)
318	{
319	$request = $this->realEscapeObject($request);
320
321	if(empty($request->batchId)\|\|empty($request->clusterId))
322	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Invalid request");
323
324
325	$query = "SELECT
326	g.id,
327	g.identifying_context,
328	g.name,
329	g.type,
330	g.trashed,
331	g.created_by,
332	g.created_date,
333	g.updated_by,
334	g.updated_date
335	FROM
336	cluster_groups_relations cgr
337	inner join groups_relations gr ON gr.child_groups_id = cgr.groups_id
338	inner join `groups` g ON g.id = gr.child_groups_id
339	where gr.parent_groups_id = '$request->batchId' and cgr.cluster_id = '$request->clusterId'";
340
341	try {
342	$group = $this->executeQueryForObject($query, $this->mapper[GroupServiceMapper::SEARCH_GROUPS]);
343	} catch (\Exception $e) {
344	throw new ProfessionalException(ProfessionalException::ERROR_FETCHING,"Cannot fetch group details! Please try again");
345	}
346
347	return $group;
348	}
349
350	/**
351	* Save a batch
352	* @param Group $group
353	* @return String $id
354	*/
355	public function saveBatchGroup (Group $group)
356	{
357	$group = $this->realEscapeObject($group);
358	$group->createdBy = $GLOBALS['userId'] ?? $group->createdBy;
359	$group->updatedBy = $GLOBALS['userId'] ?? $group->updatedBy;
360	$group->type = GroupTypeConstant::BATCH;
361
362	try{
363	$this->validateSaveGroupRequest($group);
364
365	if(!empty($group->id))
366	{
367	$group->id = $this->updateGroup($group);
368	}
369	else
370	{
371	$group->id = $this->insertGroup($group);
372	}
373
374	}catch(\Exception $e) {
375	if($e->getCode() !== ProfessionalException::INVALID_PARAMETER && $e->getCode() !== ProfessionalException::EMPTY_PARAMETERS && $e->getCode() !== ProfessionalException::DUPLICATE_ENTRY) {
376	throw new ProfessionalException($e->getCode(),"Failed to save Batch! Please try again");
377	} else if ($e->getCode() === ProfessionalException::DUPLICATE_ENTRY) {
378	throw new ProfessionalException (ProfessionalException::DUPLICATE_ENTRY,"Cannot create batch.$group->name already exists!");
379	} else {
380	throw new ProfessionalException ($e->getCode(),$e->getMessage());
381	}
382	}
383
384	return $group->id;
385	}
386
387	/**
388	* Save a subject student group
389	* @param Group $group
390	* @return String $id
391	*/
392	public function saveSubjectStudentGroup (Group $group)
393	{
394	$group = $this->realEscapeObject($group);
395	$group->createdBy = $GLOBALS['userId'] ?? $group->createdBy;
396	$group->updatedBy = $GLOBALS['userId'] ?? $group->updatedBy;
397	$group->type = GroupTypeConstant::SUBJECT;
398
399	try{
400	$this->validateSaveGroupRequest($group);
401
402	if(!empty($group->id))
403	{
404	$group->id = $this->updateGroup($group);
405	}
406	else
407	{
408	$group->id = $this->insertGroup($group);
409	}
410
411	}catch(\Exception $e) {
412	if($e->getCode() !== ProfessionalException::INVALID_PARAMETER && $e->getCode() !== ProfessionalException::EMPTY_PARAMETERS && $e->getCode() !== ProfessionalException::DUPLICATE_ENTRY) {
413	throw new ProfessionalException($e->getCode(),"Failed to save Subject Student Group! Please try again");
414	} else if ($e->getCode() === ProfessionalException::DUPLICATE_ENTRY) {
415	throw new ProfessionalException (ProfessionalException::DUPLICATE_ENTRY,"Cannot create subject student group.$group->name already exists!");
416	} else {
417	throw new ProfessionalException ($e->getCode(),$e->getMessage());
418	}
419	}
420
421	return $group->id;
422	}
423
424
425	/**
426	* Save a subject student group
427	* @param MapStudentGroupRequest $mapStudentGroupRequest
428	* @return String $id
429	*/
430	public function addStudentsGroup ($mapStudentGroupRequest)
431	{
432	$mapStudentGroupRequest = $this->realEscapeObject($mapStudentGroupRequest);
433	$mapStudentGroupRequest->createdBy = $GLOBALS['userId'] ?? $mapStudentGroupRequest->createdBy;
434	$mapStudentGroupRequest->updatedBy = $GLOBALS['userId'] ?? $mapStudentGroupRequest->updatedBy;
435
436	// try{
437	// $this->validateSaveGroupRequest($group);
438
439	// if(!empty($group->id))
440	// {
441	// $group->id = $this->updateGroup($group);
442	// }
443	// else
444	// {
445	// $group->id = $this->insertGroup($group);
446	// }
447
448	// }catch(\Exception $e) {
449	// if($e->getCode() !== ProfessionalException::INVALID_PARAMETER && $e->getCode() !== ProfessionalException::EMPTY_PARAMETERS && $e->getCode() !== ProfessionalException::DUPLICATE_ENTRY) {
450	// throw new ProfessionalException($e->getCode(),"Failed to save Subject Student Group! Please try again");
451	// } else if ($e->getCode() === ProfessionalException::DUPLICATE_ENTRY) {
452	// throw new ProfessionalException (ProfessionalException::DUPLICATE_ENTRY,"Cannot create subject student group.$group->name already exists!");
453	// } else {
454	// throw new ProfessionalException ($e->getCode(),$e->getMessage());
455	// }
456	// }
457	$group = new Group();
458
459	return $group->id;
460	}
461
462
463
464	public function getAssignedSyllabusesFromGroupId ($groupId)
465	{
466
467	$groupId = $this->realEscapeObject($groupId);
468	$this->haveId($groupId,GroupTypeConstant::BATCH);
469	$query = "SELECT distinct s.id as `SyllabusId`, s.name AS `SyllabusName`
470	FROM `groups` bg
471	INNER JOIN `cm_curriculum_syllabus_relation` csr ON csr.cm_curriculum_id = bg.properties->'$.curriculumId'
472	INNER JOIN `cm_syllabus` s ON s.id = csr.cm_syllabus_id OR JSON_CONTAINS(bg.properties->'$.extraSyllabusId',concat('\"',s.id,'\"'),'$')
473	WHERE bg.type = '".GroupTypeConstant::BATCH."' AND bg.id = '$groupId';";
474
475	try {
476	$AssignedSyllabus = $this->executeQueryForList($query);
477	} catch (\Exception $e) {
478	throw new ProfessionalException(ProfessionalException::ERROR_FETCHING,"Cannot fetch group details! Please try again");
479	}
480
481	return $AssignedSyllabus;
482
483	}
484
485	/**
486	* Get a group id of batch
487	* @param Integer $batchId
488	* @return String $groupId
489	*/
490	public function getStudentsBatchGroupFromBatchId ($batchId)
491	{
492	$batchId = $this->realEscapeString($batchId);
493
494	// try{
495	// TODO: fetch group id of a batch
496	$groupId = "q85pNu5563WjsfMBd";
497	// }catch(\Exception $e) {
498	// if($e->getCode() !== ProfessionalException::INVALID_PARAMETER && $e->getCode() !== ProfessionalException::EMPTY_PARAMETERS && $e->getCode() !== ProfessionalException::DUPLICATE_ENTRY) {
499	// throw new ProfessionalException($e->getCode(),"Failed to save Subject Student Group! Please try again");
500	// } else if ($e->getCode() === ProfessionalException::DUPLICATE_ENTRY) {
501	// throw new ProfessionalException (ProfessionalException::DUPLICATE_ENTRY,"Cannot create subject student group.$group->name already exists!");
502	// } else {
503	// throw new ProfessionalException ($e->getCode(),$e->getMessage());
504	// }
505	// }
506
507	return $groupId;
508	}
509
510	/**
511	* Search Academic term Details
512	* @return Group
513	*/
514	public function getAllGroups(SearchGroupRequest $request)
515	{
516	$request = $this->realEscapeObject($request);
517
518	$where = [];
519	$limitQuery = "";
520	!empty($request->batchStartYear)?$where [] = "JSON_CONTAINS(g.properties, '{\"batchStartYear\":\"$request->batchStartYear\"}')":null;
521	!empty($request->programId)?$where [] = "JSON_CONTAINS(g.properties, '{\"programId\":\"$request->programId\"}')":null;
522	!empty($request->courseTypeId)?$where [] = "JSON_CONTAINS(g.properties, '{\"courseTypeId\":\"$request->courseTypeId\"}')":null;
523	!empty($request->id)?$where[] = "g.id='$request->id'":null;
524	($request->trashed === StatusConstants::ACTIVE)?$where []= "g.trashed IS NULL":null;
525	($request->trashed === StatusConstants::TRASHED)?$where[]= "g.trashed IS NOT NULL ":null;
526	!empty($request->name)?$where []= "g.name LIKE '%$request->name%'":null;
527	!empty($request->type)?$where []= "g.type = '$request->type'":null;
528
529	$select = ["g.id","g.identifying_context","g.name","g.type","g.properties","g.trashed","g.created_by","g.created_date","g.updated_by","g.updated_date"];
530
531	if($request->getGroupMembers){
532	$where []= " gm.academic_status = '".$request->memberStatus."'";
533	$select = array_merge($select,["stdp.id as studentId","std.studentName","stdp.properties->>'$.rollNumber' as rollNo","stdp.properties->>'$.registerNumber' as regNo","gm.properties","gm.groups_id","gm.trashed","gm.id as member_id"]);
534	$innerJoin[] = "INNER JOIN `group_members` gm ON gm.groups_id = g.id AND gm.trashed is null";
535	$innerJoin[] = "INNER JOIN `student_program_account` stdp ON stdp.id = gm.student_id";
536	$innerJoin[] = "INNER JOIN `studentaccount` std ON std.studentID = stdp.student_id";
537	}
538
539	if($request->startIndex !== "" && $request->endIndex !== "")
540	{
541	$limitQuery .= " LIMIT $request->startIndex,$request->endIndex";
542	}
543
544	$query = "
545	SELECT ".implode(',',$select)." FROM
546	`groups` g
547	".implode(' ',$innerJoin)."
548	".(!empty($where)?"WHERE ".implode(' AND ',$where):"").$limitQuery;
549
550	try {
551	if($request->getGroupMembers){
552	$groups = $this->executeQueryForList($query, $this->mapper[GroupServiceMapper::SEARCH_GROUPS_WITH_GROUP_MEMBERS]);
553	}else{
554	$groups = $this->executeQueryForList($query, $this->mapper[GroupServiceMapper::SEARCH_GROUPS]);
555	}
556	} catch (\Exception $e) {
557	throw new ProfessionalException(ProfessionalException::ERROR_FETCHING,"Cannot fetch group details! Please try again.");
558	}
559
560	return $groups;
561	}
562
563	/**
564	* get all batch academic years
565	* @param $year START_YEAR, END_YEAR, ACADEMIC_YEAR
566	* @return Group
567	*/
568	public function getAllBatchAcademicYears($year="START_YEAR")
569	{
570	$year = $this->realEscapeString($year);
571	$columns = "";
572
573	if ($year === "START_YEAR") {
574	$columns = "g.properties->>'$.startYear' AS year";
575	}
576	if ($year === "END_YEAR") {
577	$columns = "g.properties->>'$.batchEndYear' AS year";
578	}
579	if ($year === "ACADEMIC_YEAR") {
580	$columns = "CONCAT(g.properties->>'$.startYear', '-', g.properties->>'\$batchEndYear') AS year";
581	}
582	$query = "SELECT DISTINCT
583	$columns
584	FROM
585	`groups` g
586	WHERE
587	g.trashed IS NULL AND g.properties->>'$.startYear' IS NOT NULL";
588
589	try {
590	$groups = $this->executeQueryForList($query);
591	} catch (\Exception $e) {
592	throw new ProfessionalException(ProfessionalException::ERROR_FETCHING,"Cannot fetch group details! Please try again.");
593	}
594
595	usort($groups,function($groupA, $groupB){
596	return $groupA->year > $groupB->year;
597	});
598	$groups = array_values(array_filter($groups, function($g) { return $g->year; }));
599
600	if(empty($groups))
601	{
602	throw new ProfessionalException(ProfessionalException::EMPTY_SEARCH_ITEMS,"No Batch Groups Found");
603	}
604
605	return $groups;
606	}
607
608	/**
609	* Search group by properties
610	* //$request->properties { property : value, property : value }
611	* @return Group
612	*/
613	public function findGroupByProperties($request)
614	{
615	$where = [];
616	if(empty($request->properties)){
617	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Invalid group properties! Please enter a valid properties");
618	}
619
620	try {
621	$request->type ? $where [] = " type = '$request->type' ": [];
622	foreach ($request->properties as $property => $value) {
623	$where [] = " properties->'$.$property' = '$value' ";
624	}
625	$query = "SELECT `id`,`identifying_context`,`name`,`type`,`properties`,`trashed`,`created_by`,`created_date`,`updated_by`,`updated_date` FROM `groups` WHERE ".implode(' AND ',$where);
626
627	return $this->executeQueryForList($query, $this->mapper[GroupServiceMapper::SEARCH_GROUPS]);
628	} catch (\Exception $e) {
629	throw new ProfessionalException(ProfessionalException::ERROR_FETCHING,"Cannot fetch group details! Please try again.");
630	}
631	}
632
633	/**
634	* Delete Group (Permanent Delete)
635	* @param String $id
636	* @return NULL
637	*/
638
639	public function deleteGroupPermanently($id){
640	$id = $this->realEscapeString($id);
641
642	if(empty($id))
643	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Group is invalid! Please enter a valid group");
644
645	GroupMemberService::getInstance()->deleteMembersPermanently($id);
646
647	$query [] = "DELETE FROM `cluster_groups_relations` WHERE `groups_id` = '$id'";
648	$query [] = "DELETE FROM `groups_relations` WHERE `parent_groups_id` = '$id'";
649	$query [] = "DELETE FROM `groups_relations` WHERE `child_groups_id` = '$id'";
650	$query [] = "DELETE FROM `group_members` WHERE `groups_id` = '$id'";
651	$query [] = "UPDATE `batches` set `groups_id` = null WHERE `groups_id` = '$id'";
652	$query [] = "DELETE FROM `groups` WHERE `id` = '$id'";
653
654
655	try {
656	foreach ($query as $value) {
657	$this->executeQuery($value);
658	}
659	} catch (\Exception $e) {
660	throw new ProfessionalException(ProfessionalException::ERROR_DELETING,"Error deleting group! Please try again");
661	}
662	}
663
664	/**
665	* Restore Group
666	* @param Object $batch
667	* @param Array $properties
668	* @param Object $groupProperties
669	* @return NULL
670	*/
671	public function updateGroupProperties($group,$properties,$type,$column = 'properties',$appendProperties = false,$removeProperties = false)
672	{
673	$group = (object)$this->realEscapeObject($group);
674	$group->properties = (object)$group->properties;
675	switch ($type) {
676	case GroupTypeConstant::BATCH:
677	$groupProperties = new AcademicsBatchProperties();
678	break;
679	case GroupTypeConstant::SUBJECT:
680	$groupProperties = new AcademicsSubjectProperties();
681	break;
682	default:
683	# code...
684	break;
685	}
686
687	if(empty($groupProperties))
688	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Invalid properties! Please enter a valid group");
689
690	$updatedBy = $GLOBALS['userId'];
691	$id = $group->id;
692	if(empty($id))
693	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Group is invalid! Please enter a valid group");
694
695	$set = [];
696	if($appendProperties==true \|\| $removeProperties == true ){
697
698	if($appendProperties==true){
699	$externalSyllabusIds =[];
700	foreach ($properties as $key => $property) {
701	foreach ($property->value as $ele) {
702	$externalSyllabusIds [] = $ele;
703	}
704	}
705	$selectQuery = "SELECT g.properties->>'$.extraSyllabusId' as extraSyllabusId FROM `groups` g WHERE g.id= '$id';";
706	$existingSyllabus = $this->executeQueryForObject($selectQuery);
707	$newArray = [];
708	if ($existingSyllabus->extraSyllabusId === null \|\| $existingSyllabus->extraSyllabusId === "" \|\| $existingSyllabus->extraSyllabusId === [""] \|\| $existingSyllabus->extraSyllabusId === `"[""]"` ) {
709	$newArray = $externalSyllabusIds;
710
711	}else{
712	$existingSyllabusArray = [];
713	$existingSyllabusArray = json_decode($existingSyllabus->extraSyllabusId);
714
715
716
717	$newArray = array_merge($existingSyllabusArray,$externalSyllabusIds);
718
719	}
720	}if($removeProperties == true){
721	$externalSyllabusIds =[];
722	foreach ($properties as $key => $property) {
723	foreach ($property->value as $ele) {
724	$externalSyllabusIds [] = $ele;
725	}
726	}
727	$selectQuery = "SELECT g.properties->>'$.extraSyllabusId' as extraSyllabusId FROM `groups` g WHERE g.id= '$id';";
728	$existingSyllabus = $this->executeQueryForObject($selectQuery);
729	$existingSyllabusArray = [];
730	$existingSyllabusArray = json_decode($existingSyllabus->extraSyllabusId);
731	$newArray = array_diff($existingSyllabusArray, $externalSyllabusIds);
732
733	}
734	$value = json_encode($newArray);
735	try {
736	$query = "UPDATE `groups`
737	SET `".$column."` = JSON_SET(`".$column."`, '$.".$property->name."', CAST('$value' AS JSON)),
738	updated_by = '$updatedBy',
739	updated_date = utc_timestamp()
740	WHERE id = '$id';";
741
742	$this->executeQuery($query);
743	}catch (\Exception $e) {
744	throw new ProfessionalException(ProfessionalException::ERROR_RESTORING,"Error restoring academic term! Please try again");
745	}
746
747	}else{
748	try {
749	foreach ($properties as $key => $property) {
750	if(property_exists($groupProperties, $property->name)){
751	if(is_object($property->value)){
752
753	}else if(is_array($property->value)){
754	$value = "JSON_ARRAY(\"".implode('","',$property->value)."\")";
755	}else if(is_string($property->value)){
756	$value = "'".$property->value."'";
757	}else if(is_bool($property->value)){
758	$value = $property->value ? "true":"false";
759	}
760	$query = "UPDATE
761	`groups`
762	SET
763	`".$column."` = JSON_SET(`".$column."`, '$.".$property->name."', $value),
764	updated_by = '$updatedBy',
765	updated_date = utc_timestamp()
766	WHERE
767	id = '$id'";
768
769	$this->executeQuery($query);
770	}
771
772	}
773	}
774
775	catch (\Exception $e) {
776	throw new ProfessionalException(ProfessionalException::ERROR_RESTORING,"Error restoring academic term! Please try again");
777	}
778	}
779	}
780
781	public function setGroupToGroupRelations($groups,$propertyName){
782
783	$propertyName = $this->realEscapeString($propertyName);
784	$groups = $this->realEscapeObject($groups);
785
786	$parentGroupIds = (array)$groups->properties->{$propertyName};
787	$createdBy = $GLOBALS['userId'];
788	if(empty($groups->id)){
789	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Invalid group! Please try again");
790	}
791	try{
792	$deleteGroupRelations = "DELETE FROM `groups_relations` WHERE `child_groups_id` = '$groups->id' AND properties->'$.".$propertyName."' NOT IN (\"".implode('","',$parentGroupIds)."\");";
793	$this->executeQuery($deleteGroupRelations);
794	$createGroupRelations = "INSERT IGNORE INTO `groups_relations` (`id`,`parent_groups_id`,`child_groups_id`,`properties`,`created_by`)
795	SELECT LEFT(REPLACE(UUID(),'-',''), 17),`id`,'$groups->id',json_object(),'".$createdBy."' FROM `groups` WHERE id IN (\"".implode('","',$parentGroupIds)."\");";
796	$this->executeQuery($createGroupRelations);
797	}catch(\Exception $e) {
798	throw new ProfessionalException ($e->getCode(),$e->getMessage());
799	}
800
801	}
802
803	public function haveId($id,$type = ''){
804	if(empty($id)){
805	switch ($type) {
806	case GroupTypeConstant::BATCH:
807	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Batch is invalid! Please try again");
808	break;
809	case GroupTypeConstant::SUBJECT:
810	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Subject is invalid! Please try again");
811	break;
812	default:
813	throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"invalid parameters! Please try again");
814	break;
815	}
816	}
817	}
818
819	}