Code Coverage for /opt/homebrew/var/www/html/Linways/examcontroller-api/src/com/linways/core/service/MarkMigrationGenerator/Template15MigrationdResultGenerator.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 / 11	CRAP	0.00% covered (danger)	0.00%	0 / 1753
Template15MigrationdResultGenerator	0.00% covered (danger)	0.00%	0 / 1	0.00% covered (danger)	0.00%	0 / 11	148610.00	0.00% covered (danger)	0.00%	0 / 1753
__construct					n/a	0 / 0	1		n/a	0 / 0
processData				0.00% covered (danger)	0.00%	0 / 1	30.00	0.00% covered (danger)	0.00%	0 / 34
getStudentsOverallMarkReport				0.00% covered (danger)	0.00%	0 / 1	29070.00	0.00% covered (danger)	0.00%	0 / 702
markListProcessing				0.00% covered (danger)	0.00%	0 / 1	14520.00	0.00% covered (danger)	0.00%	0 / 588
getStudentSubjectGradeDetailsForMarkHistory				0.00% covered (danger)	0.00%	0 / 1	20.00	0.00% covered (danger)	0.00%	0 / 37
getGradeByPercentage				0.00% covered (danger)	0.00%	0 / 1	20.00	0.00% covered (danger)	0.00%	0 / 8
getStudentImprovementExamDetailsForThisExam				0.00% covered (danger)	0.00%	0 / 1	30.00	0.00% covered (danger)	0.00%	0 / 16
getStudentExamDetails				0.00% covered (danger)	0.00%	0 / 1	30.00	0.00% covered (danger)	0.00%	0 / 15
getSupplyMarkHistory				0.00% covered (danger)	0.00%	0 / 1	30.00	0.00% covered (danger)	0.00%	0 / 22
checkIsFailedByPassPercentCriteria				0.00% covered (danger)	0.00%	0 / 1	380.00	0.00% covered (danger)	0.00%	0 / 43
getSemesterGradeDetials				0.00% covered (danger)	0.00%	0 / 1	2.00	0.00% covered (danger)	0.00%	0 / 9
getStudentsSupplyMarkReport				0.00% covered (danger)	0.00%	0 / 1	2162.00	0.00% covered (danger)	0.00%	0 / 279

1	<?php
2	// For Carmel Mala
3
4	namespace com\linways\ec\core\service\MarkMigrationGenerator;
5	use com\linways\ec\core\service\StudentMarkListService;
6	use com\linways\ec\core\service\ExamRegistrationService;
7	use com\linways\ec\core\exception\ExamControllerException;
8	use com\linways\base\util\TwigRenderer;
9	use com\linways\core\ams\professional\util\PdfUtil;
10	use com\linways\ec\core\service\CommonExamService;
11	use com\linways\ec\core\service\MarkMigrationGenerator\MarkMigrationResultDataGenerator;
12	use com\linways\ec\core\service\StudentsOverAllMarkReportService;
13	use com\linways\ec\core\service\ExamRevaluationService;
14	use com\linways\ec\core\request\ConsolidatedOverAllMarkReportRequest;
15	use com\linways\core\ams\professional\dto\ExamType;
16	use com\linways\ec\core\service\GradeSchemeService;
17	use com\linways\core\ams\professional\constant\examcontroller\ExamSubjectTypeConstants;
18	use com\linways\ec\core\constant\ExamRegistrationTypeConstants;
19
20	class Template15MigrationdResultGenerator extends MarkMigrationResultDataGenerator
21	{
22	public function __construct(){}
23
24
25	/**
26	* Process Student data college base
27	* @param $request
28	*/
29	protected function processData($searchReq){
30
31	$request = new ConsolidatedOverAllMarkReportRequest();
32	$request->isStudentWiseImport = $searchReq->isStudentWiseImport;
33	$request->groupId = $searchReq->groupId;
34	$request->isConsolidatedRequest = TRUE;
35	$request->examRegistrationType = "REGULAR";
36	$request->fetchMarkHistory = 1;
37	$request->isRoundOff = 1;
38	$request->considerSupplyImproveCombined = 1;
39	// $request->academicTermId = 1;
40	$request->studentId = $searchReq->studentId;
41	// $request->studentId = 939;
42	$request->staffId = $searchReq->staffId;
43	$pulishedSupplyRegId = StudentsOverAllMarkReportService::getInstance()->getPublishedSupplyExamRegistrationByStudentId($request);
44	$request->supplyRegIdArray = $pulishedSupplyRegId;
45
46	$studentRegularExamDetails = StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($request);
47	if(empty($studentRegularExamDetails)){
48	return;
49	throw new ExamControllerException(ExamControllerException::NO_DETAILS_FOUND,"No Details Found");
50	}
51	$studentDetails = $this->getStudentsOverallMarkReport($request, $studentRegularExamDetails);
52
53	$consolidatedMarkDetails = reset($this->markListProcessing($request, $studentDetails, $studentRegularExamDetails));
54
55	if (!empty($consolidatedMarkDetails)) {
56	StudentsOverAllMarkReportService::getInstance()->updateStudentSubjectActiveStatus($request);
57	foreach ($consolidatedMarkDetails->semMarks as $semester) {
58	foreach ($semester->subject as $subject) {
59	$subject->consolidated->staffId = $request->staffId;
60	StudentsOverAllMarkReportService::getInstance()->insertStudentSubjectConsolidatedMarkDetails($subject->consolidated);
61	}
62	$semester->consolidated->staffId = $request->staffId;
63	StudentsOverAllMarkReportService::getInstance()->insertStudentSemesterConsolidatedMarkDetails($semester->consolidated);
64	}
65	$consolidatedMarkDetails->consolidated->staffId = $request->staffId;
66	StudentsOverAllMarkReportService::getInstance()->insertStudentCourseConsolidatedMarkDetails($consolidatedMarkDetails->consolidated);
67	StudentsOverAllMarkReportService::getInstance()->deleteStudentEditstatus($request);
68	}
69
70	}
71
72	/**
73	* @param ConsolidatedOverAllMarkReportRequest $request
74	* @param $examDetails
75	* @return array
76	*/
77	protected function getStudentsOverallMarkReport ( ConsolidatedOverAllMarkReportRequest $request, $examDetails )
78	{
79
80	if ( empty ( $examDetails ) ) {
81	return null;
82	}
83	if ($request->fetchOnlyMark) {
84	$subjectMark = [];
85	}
86	$examGroupId = current($examDetails)->batch->groupId;
87	$searchRequest = new \stdClass();
88	$searchRequest->groupId = $examGroupId;
89	$searchRequest->academicTermId = $request->academicTermId;
90	// $subjectGradeSchemeArray = GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest);
91	// $searchRequest->requestType = "SEMESTER";
92	// $semesterGradeSchemeArray = GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest);
93	$searchRequest->requestType = "CURRICULAM";
94	$cgpaGradeSchemeArray = GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest);
95	$cgpaGradeDetails = reset($cgpaGradeSchemeArray)->grades;
96	if ( $request->considerImprovement ) {
97	$request->examRegistrationType = ExamRegistrationTypeConstants::SUPPLEMENTARY;
98	$request->subjectRegistrationType = ExamRegistrationTypeConstants::IMPROVEMENT;
99	$improvementExamDetails = StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($request);
100	$request->subjectRegistrationType = "";
101	}
102	if ( $request->considerSupplementary ) {
103	$request->examRegistrationType = ExamRegistrationTypeConstants::SUPPLEMENTARY;
104	$request->subjectRegistrationType = ExamRegistrationTypeConstants::SUPPLEMENTARY;
105	$supplyExamDetails = StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($request);
106	$request->subjectRegistrationType = "";
107	// if ( $request->considerCombinedRegistration ) {
108	// $request->examRegistrationType = "SUPPLEMENTARY";
109	// $request->considerSupplyImproveCombined = 1;
110	// $supplyCombinedExamDetails = StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($request);
111	// $request->considerSupplyImproveCombined = "";
112	// }
113	}
114	if ( $request->considerModerationMark ) {
115	$request->examRegistrationType = "";
116	$request->requestType = "MODERATION";
117	$moderationMarkDetails = StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($request);
118	}
119	if ( $request->considerGraceMark ) {
120	$request->examRegistrationType = "";
121	$request->requestType = "GRACEMARK";
122	$graceMarkDetails = StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($request);
123	}
124
125	$student = [];
126	$passCriteriaArray = [];
127	$creditGradePoint = 0;
128	$aggregatePassCriteria = null;
129	$batchStartYear = reset($examDetails)->batch->startYear;
130	$courseTypeId = reset($examDetails)->batch->courseTypeId;
131	$courseType = new \stdClass();
132	$courseType->courseTypeMethod = reset($examDetails)->batch->courseType;
133	$courseType->isPG = 0;
134	if ($courseType->courseTypeMethod == 'PG') {
135	$courseType->isPG = 1;
136	}
137
138	$failedSemMarks = [];
139	$lastExamYear = $lastExamMonth = 0;
140	foreach ($examDetails as $exam) {
141	$lastSubjectExamYear = $lastSubjectExamMonth = 0;
142	$searchRequest = new \stdClass();
143	$searchRequest->groupId = $exam->batch->groupId;;
144	$searchRequest->academicTermId = $exam->semester->academicTermId;
145	$searchRequest->academicPaperSubjectId = $exam->subject->academicPaperSubjectId;
146	$subjectGradeSchemeArray = GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest);
147	$searchRequest->requestType = "SEMESTER";
148	$semesterGradeSchemeArray = GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest);
149
150	$lastSubjectExamYear = $exam->examRegistrations->year;
151	$lastSubjectExamMonth = $exam->examRegistrations->month;
152	if ($lastExamYear < $exam->examRegistrations->year) {
153	$lastExamYear = $exam->examRegistrations->year;
154	$lastExamMonth = $exam->examRegistrations->month;
155	} else if ($lastExamYear == $exam->examRegistrations->year) {
156	$lastExamMonth = $lastExamMonth < $exam->examRegistrations->month ? $exam->examRegistrations->month : $lastExamMonth;
157	}
158
159	$semesterGradeKey = array_search($exam->semester->academicTermId, array_column( $semesterGradeSchemeArray, "id"));
160	if($semesterGradeKey \|\| $semesterGradeKey === 0){
161	$semesterGradeDetails = $semesterGradeSchemeArray[$semesterGradeKey]->grades;
162	}
163	$maxSemesterGradePercent = $semesterGradeDetails[0]->rangeTo;
164
165	$subjectGradeKey = array_search($exam->subject->academicPaperSubjectId, array_column( $subjectGradeSchemeArray, "id"));
166	$gradeDetails = '';
167	if($subjectGradeKey \|\| $subjectGradeKey === 0){
168	$gradeDetails = $subjectGradeSchemeArray[$subjectGradeKey]->grades;
169	}
170	$maxGradePercent = $gradeDetails[0]->rangeTo;
171	$maxGradePoint = max(array_column($gradeDetails,"gradePoint"));
172
173	$academicTermId = $exam->semester->academicTermId;
174	$academicPaperSubjectId = $exam->subject->academicPaperSubjectId;
175	$schemeType = "PERCENTAGE";
176	$passCriteriaArray[$academicPaperSubjectId] = GradeSchemeService::getInstance()->getSubjectPassCriteriaByAcademicPaperSubject($academicPaperSubjectId, $schemeType);
177
178	$internalPassCriteria = $externalPassCriteria = $overallPassCriteria = $aggregatePassCriteria = null;
179	$internalPassCriteria = $passCriteriaArray[$academicPaperSubjectId]->internalPassCriteria;
180	$externalPassCriteria = $passCriteriaArray[$academicPaperSubjectId]->externalPassCriteria;
181	$overallPassCriteria = $passCriteriaArray[$academicPaperSubjectId]->overallPassCriteria;
182
183	if (!empty ($exam->studentMarks)) {
184	foreach ($exam->studentMarks as $studentMark) {
185	$isFailed = 0;
186	$isInternalFailed = 0;
187	$isExternalFailed = 0;
188	$examTotal = 0;
189	$studentExamTotal = 0;
190	$studentExternalMark = null;
191	$grade = null;
192	$studentId = $studentMark->student->studentId;
193	$isExempted = $studentMark->isExempted;
194
195	$student[$studentId]->semMarks[$academicTermId]->academicTermName = $exam->semester->academicTermName;
196
197	$markHistory = [];
198
199	$examMonth = $exam->examRegistrations->month;
200	$examYear = $exam->examRegistrations->year;
201	$monthYearOfPassing = date ( "M Y", strtotime ( $exam->examRegistrations->year . "-" . $exam->examRegistrations->month . "-01"));
202	$examRegTypeOfPassing = ExamType::REGULAR;
203
204	if ( $isExempted == 0 ) {
205
206	$considerOverallPassCriteriaOnly = 0;
207	if ( $exam->subject->subjectType == ExamSubjectTypeConstants::OPEN_ELECTIVE \|\|
208	$exam->subject->subjectType == ExamSubjectTypeConstants::FOUNDATION_COURSE \|\|
209	$exam->subject->subjectType == ExamSubjectTypeConstants::TERM_PAPER ) {
210	$considerOverallPassCriteriaOnly = 1;
211	}
212	/**
213	* Object created for checking whether a student is passed for a subject by the pass percent
214	* criteria
215	*/
216	$checkPassPercentCriteria = new \stdClass();
217	$checkPassPercentCriteria->isInternal = $exam->subject->isInternal;
218	$checkPassPercentCriteria->internalMaxMark = $exam->internalMaxMark;
219
220	$checkPassPercentCriteria->isExternal = $exam->subject->isExternal;
221	$checkPassPercentCriteria->externalMaxMark = $exam->externalMaxMark;
222
223	$checkPassPercentCriteria->internalMark = round($studentMark->internalMark);
224	$checkPassPercentCriteria->considerOverallPassCriteriaOnly = $considerOverallPassCriteriaOnly;
225	$checkPassPercentCriteria->passPercentConfig = $passCriteriaArray[$academicPaperSubjectId];
226	/ Code ends /
227
228	if ( !$student[$studentId]->lastExamYear \|\| $student[$studentId]->lastExamYear < $lastExamYear ) {
229	$student[$studentId]->lastExamYear = $lastExamYear;
230	$student[$studentId]->lastExamMonth = $lastExamMonth;
231	$student[$studentId]->lastExamReg = ExamType::REGULAR;
232	} else if ( $student[$studentId]->lastExamYear == $lastExamYear &&
233	$student[$studentId]->lastExamMonth < $lastExamMonth ) {
234	$student[$studentId]->lastExamMonth = $lastExamMonth;
235	$student[$studentId]->lastExamReg = ExamType::REGULAR;
236	}
237	if ( !$student[$studentId]->semMarks[$academicTermId]->lastExamYear \|\| $student[$studentId]->semMarks[$academicTermId]->lastExamYear < $lastSubjectExamYear ) {
238	$student[$studentId]->semMarks[$academicTermId]->lastExamYear = $lastSubjectExamYear;
239	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth = $lastSubjectExamMonth;
240	$student[$studentId]->semMarks[$academicTermId]->lastExamReg = ExamType::REGULAR;
241	} else if ( $student[$studentId]->semMarks[$academicTermId]->lastSubjectExamYear == $lastSubjectExamYear &&
242	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth < $lastSubjectExamMonth ) {
243	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth = $lastSubjectExamMonth;
244	$student[$studentId]->semMarks[$academicTermId]->lastExamReg = ExamType::REGULAR;
245	}
246
247	$studentMark->externalAttendanceStatus = $studentMark->externalAttendanceStatus? $studentMark->externalAttendanceStatus : 'PRESENT';
248	$studentExternalMark = $studentMark->externalMark;
249	$checkPassPercentCriteria->externalMark = $studentExternalMark;
250	$isRegularFailed = $this->checkIsFailedByPassPercentCriteria (
251	$checkPassPercentCriteria );
252	$markHistory["REGULAR"]->isFailed = $isRegularFailed;
253	$markHistory["REGULAR"]->mark = $studentMark->externalMark;
254	$markHistory["REGULAR"]->markObtainedInExam = round($studentMark->externalMark);
255	$markHistory["REGULAR"]->examRegistrationId = $exam->examRegistrations->examRegistrationId;
256	$markHistory["REGULAR"]->month = $exam->examRegistrations->month;
257	$markHistory["REGULAR"]->year = $exam->examRegistrations->year;
258	$markHistory["REGULAR"]->assessmentId = $exam->assessmentId;
259	$markHistory["REGULAR"]->oeExamId = $exam->oeExamId;
260	$markHistory["REGULAR"]->externalAttendanceStatus = $studentMark->externalAttendanceStatus;
261	$markHistory["REGULAR"]->name = $exam->examRegistrations->examRegistartionName;
262	// Only if there is any significant improvement in the mark then only there will be entry in the revaluation mark table
263	if ( $request->considerRevaluation) {
264	$revalRequest = new \stdClass();
265	$revalRequest->studentId = $studentId;
266	$revalRequest->assessmentId = $exam->assessmentId;
267	$revalRequest->orderByHighestMark = 1;
268	$studentRevaluationDetails = StudentsOverAllMarkReportService::getInstance()->getStudentFinalizedRevaluationMark($revalRequest);
269	if($studentRevaluationDetails){
270	$studentRevaluationDetail = current(current($studentRevaluationDetails)->students);
271	if($studentRevaluationDetail->revaluationMark){
272	$studentExternalMark = $studentRevaluationDetail->revaluationMark;
273	$markHistory["REGULAR"]->mark = $studentRevaluationDetail->revaluationMark;
274	$markHistory["REGULAR"]->markType['REVALUATION']->mark = $studentRevaluationDetail->revaluationMark;
275	// $markHistory["REVALUATION"]->examRegId = $studentRevaluationDetail->revaluationId;
276	// $markHistory["REVALUATION"]->isAbsent = false;
277	// $markHistory["REVALUATION"]->name = $studentRevaluationDetail->revalDesc;
278	}
279	}
280	}
281	if ( $request->considerModerationMark ) {
282	$studentModerationMark = $this->getStudentExamDetails($exam->assessmentId, $studentId, $moderationMarkDetails);
283	if($studentModerationMark){
284	$studentExternalMark += $studentModerationMark->externalMark;
285	$markHistory["REGULAR"]->markType['MODERATION']->mark = $studentModerationMark->externalMark;
286	// $markHistory["REGULAR"]->mark = $studentMark->externalMark;
287	}
288	}
289	if ( $request->considerGraceMark ) {
290	$studentGraceMark = $this->getStudentExamDetails($exam->assessmentId, $studentId, $graceMarkDetails);
291	if($studentGraceMark){
292	$studentExternalMark+= $studentGraceMark->externalMark;
293	$markHistory["REGULAR"]->markType['GRACEMARK']->mark = $studentGraceMark->externalMark;
294	}
295	}
296	if ( $request->considerImprovement ) {
297	$studentImproveExamMark = $this->getStudentImprovementExamDetailsForThisExam($academicPaperSubjectId, $studentId, $improvementExamDetails);
298	if ($studentImproveExamMark !== null){
299	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->mark = $studentImproveExamMark->externalMark;
300	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->markObtainedInExam = round($studentImproveExamMark->externalMark);
301	$improveExamDetails = $studentImproveExamMark->examRegistrations;
302	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->name = $improveExamDetails->examRegistartionName;
303	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->id = $improveExamDetails->examRegistrationId;
304	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->examMonth = $improveExamDetails->month;
305	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->examYear = $improveExamDetails->year;
306	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->externalAttendanceStatus = $studentImproveExamMark->externalAttendanceStatus;
307	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->supplyName = $improveExamDetails->examRegistartionName;
308	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->assessmentId = $studentImproveExamMark->assessmentId;
309	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->oeExamId = $studentImproveExamMark->oeExamId;
310	if ($student[$studentId]->lastExamYear < $improveExamDetails->year) {
311	$student[$studentId]->lastExamYear = $improveExamDetails->year;
312	$student[$studentId]->lastExamMonth = $improveExamDetails->month;
313	$student[$studentId]->lastExamReg = ExamType::IMPROVEMENT;
314	} else if ($student[$studentId]->lastExamYear == $improveExamDetails->year &&
315	$student[$studentId]->lastExamMonth < $improveExamDetails->month) {
316	$student[$studentId]->lastExamMonth = $improveExamDetails->month;
317	$student[$studentId]->lastExamReg = ExamType::IMPROVEMENT;
318	}
319	if ($student[$studentId]->semMarks[$academicTermId]->lastExamYear < $improveExamDetails->year) {
320	$student[$studentId]->semMarks[$academicTermId]->lastExamYear = $improveExamDetails->year;
321	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth = $improveExamDetails->month;
322	$student[$studentId]->semMarks[$academicTermId]->lastExamReg = ExamType::IMPROVEMENT;
323	} else if ($student[$studentId]->semMarks[$academicTermId]->lastExamYear == $improveExamDetails->year &&
324	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth < $improveExamDetails->month) {
325	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth = $improveExamDetails->month;
326	$student[$studentId]->semMarks[$academicTermId]->lastExamReg = ExamType::IMPROVEMENT;
327	}
328	$examMonth = $improveExamDetails->month;
329	$examYear = $improveExamDetails->year;
330	$monthYearOfPassing = date("M Y", strtotime($improveExamDetails->year . "-" . $improveExamDetails->month . "-01"));
331	$examRegTypeOfPassing = ExamType::IMPROVEMENT;
332	}
333	if ($studentImproveExamMark !== null && $studentImproveExamMark->externalMark > $studentExternalMark) {
334	$studentExternalMark = $studentImproveExamMark->externalMark;
335
336	if ( $request->considerRevaluation) {
337	$revalRequest = new \stdClass();
338	$revalRequest->studentId = $studentId;
339	$revalRequest->assessmentId = $studentImproveExamMark->assessmentId;
340	$revalRequest->orderByHighestMark = 1;
341	$studentRevaluationDetails = StudentsOverAllMarkReportService::getInstance()->getStudentFinalizedRevaluationMark($revalRequest);
342	if($studentRevaluationDetails){
343	$studentRevaluationDetail = current(current($studentRevaluationDetails)->students);
344	if($studentRevaluationDetail->revaluationMark){
345	$studentImproveExamMark->externalMark = $studentRevaluationDetail->revaluationMark;
346	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->mark = $studentRevaluationDetail->revaluationMark;
347	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->markType['REVALUATION']->mark = $studentRevaluationDetail->revaluationMark;
348	}
349	}
350	}
351
352	if ( $request->considerModerationMark ) {
353	$studentModerationMark = $this->getStudentExamDetails($studentImproveExamMark->assessmentId, $studentId, $moderationMarkDetails);
354	if($studentModerationMark){
355	$studentImproveExamMark->externalMark += $studentModerationMark->externalMark;
356	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->markType['MODERATION']->mark = $studentModerationMark->externalMark;
357	// $markHistory["REGULAR"]->mark = $studentMark->externalMark;
358	}
359	}
360	if ( $request->considerGraceMark ) {
361	$studentGraceMark = $this->getStudentExamDetails($studentImproveExamMark->assessmentId, $studentId, $graceMarkDetails);
362	if($studentGraceMark){
363	$studentImproveExamMark->externalMark += $studentGraceMark->externalMark;
364	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->markType['GRACEMARK']->mark = $studentModerationMark->externalMark;
365	}
366	}
367	$studentExternalMark = $studentImproveExamMark->externalMark;
368	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->mark = $studentImproveExamMark->externalMark;
369	$improveExamDetails = $studentImproveExamMark->examRegistrations;
370	$markHistory["IMPROVEMENT"]->supplyMarks['IMPROVEMENT']->name = $improveExamDetails->examRegistartionName;
371	}
372	}
373	if ( $request->considerSupplementary ) {
374	$studentSupplyExam = null;
375	// Get the mark of the last supplementary exam registered by that student
376	$supplyRequest = new ConsolidatedOverAllMarkReportRequest();
377	$supplyRequest->groupId = $request->groupId;
378	$supplyRequest->isConsolidatedRequest = TRUE;
379	$supplyRequest->examRegistrationType = ExamRegistrationTypeConstants::SUPPLEMENTARY;
380	$supplyRequest->academicPaperSubjectId = $academicPaperSubjectId;
381	$supplyRequest->studentId = $studentId;
382	$supplyRequest->orderBy = "HIGHEST";
383	$supplyRequest->yearUpperLimit = $request->supplementaryYearUpperLimit;
384	$supplyRequest->monthUpperLimit = $request->supplementaryMonthUpperLimit;
385	$supplyRequest->considerSupplyImproveCombined = $request->considerSupplyImproveCombined;
386	$supplyRequest->studentSupplyRequest = true;
387	$studentSupplyExam = reset(StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($supplyRequest));
388	$supplyRequest->studentSupplyRequest = false;
389
390	$studentExternalMark = round($studentExternalMark, 2);
391	if (!empty ($studentSupplyExam)) {
392	$supplyStudentDetails = current($studentSupplyExam->studentMarks);
393	$studentSupplyExamMark = round($supplyStudentDetails->externalMark, 2);
394
395	if( $supplyStudentDetails->studentExamRegType == ExamType::IMPROVEMENT){
396	$lastSupplyRegType = ExamType::IMPROVEMENT;
397	$supplyExamMonth = (int)$studentSupplyExam->examRegistrations->month;
398	$supplyExamYear = (int)$studentSupplyExam->examRegistrations->year;
399
400	if ($student[$studentId]->lastExamYear < $supplyExamYear) {
401	$student[$studentId]->lastExamYear = $supplyExamYear;
402	$student[$studentId]->lastExamMonth = $supplyExamMonth;
403	$student[$studentId]->lastExamReg = $lastSupplyRegType;
404	} else if ($student[$studentId]->lastExamYear == $supplyExamYear &&
405	$student[$studentId]->lastExamMonth < $supplyExamMonth) {
406	$student[$studentId]->lastExamMonth = $supplyExamMonth;
407	$student[$studentId]->lastExamReg = $lastSupplyRegType;
408	}
409	if ($student[$studentId]->semMarks[$academicTermId]->lastExamYear < $supplyExamYear) {
410	$student[$studentId]->semMarks[$academicTermId]->lastExamYear = $supplyExamYear;
411	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth = $supplyExamMonth;
412	$student[$studentId]->semMarks[$academicTermId]->lastExamReg = $lastSupplyRegType;
413	} else if ($student[$studentId]->semMarks[$academicTermId]->lastExamYear == $supplyExamYear &&
414	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth < $supplyExamMonth) {
415	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth = $supplyExamMonth;
416	$student[$studentId]->semMarks[$academicTermId]->lastExamReg = $lastSupplyRegType;
417	}
418	$examMonth = $supplyExamMonth;
419	$examYear = $supplyExamYear;
420	$monthYearOfPassing = date("M Y", strtotime($supplyExamYear . "-" . $supplyExamMonth . "-01"));
421	$examRegTypeOfPassing = $lastSupplyRegType;
422	}
423
424	if ($studentSupplyExamMark && $studentSupplyExamMark > $studentExternalMark) {
425	$studentExternalMark = $studentSupplyExamMark;
426	$studentMark->externalAttendanceStatus = $supplyStudentDetails->externalAttendanceStatus ? $supplyStudentDetails->externalAttendanceStatus : $studentMark->externalAttendanceStatus;
427
428	if ( $request->considerRevaluation) {
429	$revalRequest = new \stdClass();
430	$revalRequest->studentId = $studentId;
431	$revalRequest->assessmentId = $studentSupplyExam->assessmentId;
432	$revalRequest->orderByHighestMark = 1;
433	$studentRevaluationDetails = StudentsOverAllMarkReportService::getInstance()->getStudentFinalizedRevaluationMark($revalRequest);
434	if($studentRevaluationDetails){
435	$studentRevaluationDetail = current(current($studentRevaluationDetails)->students);
436	if($studentRevaluationDetail->revaluationMark){
437	$studentExternalMark = $studentRevaluationDetail->revaluationMark;
438	}
439	}
440	}
441	if ( $request->considerModerationMark ) {
442	$studentModerationMark = $this->getStudentExamDetails($studentSupplyExam->assessmentId, $studentId, $moderationMarkDetails);
443	if($studentModerationMark){
444	$studentExternalMark += $studentModerationMark->externalMark;
445	// $markHistory["REGULAR"]->mark = $studentMark->externalMark;
446	}
447	}
448
449	if ( $request->considerGraceMark ) {
450	$studentGraceMark = $this->getStudentExamDetails($studentSupplyExam->assessmentId, $studentId, $graceMarkDetails);
451	if($studentGraceMark){
452	$studentExternalMark += $studentGraceMark->externalMark;
453	}
454	}
455	$lastSupplyRegType = ExamType::SUPPLY;
456	if( $supplyStudentDetails->studentExamRegType == ExamType::IMPROVEMENT){
457	$lastSupplyRegType = ExamType::IMPROVEMENT;
458	}
459
460	$supplyExamMonth = (int)$studentSupplyExam->examRegistrations->month;
461	$supplyExamYear = (int)$studentSupplyExam->examRegistrations->year;
462
463	if ($student[$studentId]->lastExamYear < $supplyExamYear) {
464	$student[$studentId]->lastExamYear = $supplyExamYear;
465	$student[$studentId]->lastExamMonth = $supplyExamMonth;
466	$student[$studentId]->lastExamReg = $lastSupplyRegType;
467	} else if ($student[$studentId]->lastExamYear == $supplyExamYear &&
468	$student[$studentId]->lastExamMonth < $supplyExamMonth) {
469	$student[$studentId]->lastExamMonth = $supplyExamMonth;
470	$student[$studentId]->lastExamReg = $lastSupplyRegType;
471	}
472	if ($student[$studentId]->semMarks[$academicTermId]->lastExamYear < $supplyExamYear) {
473	$student[$studentId]->semMarks[$academicTermId]->lastExamYear = $supplyExamYear;
474	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth = $supplyExamMonth;
475	$student[$studentId]->semMarks[$academicTermId]->lastExamReg = $lastSupplyRegType;
476	} else if ($student[$studentId]->semMarks[$academicTermId]->lastExamYear == $supplyExamYear &&
477	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth < $supplyExamMonth) {
478	$student[$studentId]->semMarks[$academicTermId]->lastExamMonth = $supplyExamMonth;
479	$student[$studentId]->semMarks[$academicTermId]->lastExamReg = $lastSupplyRegType;
480	}
481	$examMonth = $supplyExamMonth;
482	$examYear = $supplyExamYear;
483	$monthYearOfPassing = date("M Y", strtotime($supplyExamYear . "-" . $supplyExamMonth . "-01"));
484	$examRegTypeOfPassing = $lastSupplyRegType;
485	}
486	}
487	}
488	$studentExamTotal = 0;
489	$examTotal = 0;
490
491	if ($exam->subject->isInternal) {
492	$studentExamTotal = round($studentMark->internalMark);
493	$examTotal = $exam->internalMaxMark;
494	if (!empty ($internalPassCriteria)) {
495	$internalPercent = $exam->internalMaxMark ? (100 * $studentMark->internalMark/ $exam->internalMaxMark) : 0;
496	if ( $considerOverallPassCriteriaOnly == 0 ) {
497	$isFailed = $internalPassCriteria <= $internalPercent ? $isFailed : 1;
498	$isInternalFailed = $internalPassCriteria <= $internalPercent ? 0 : 1;
499	}
500	}
501	}
502	$markNeededToPass = $markNeededToPassExternal = $passMark = 0;
503	if ($exam->subject->isExternal) {
504	$studentExamTotal += round($studentExternalMark);
505	$examTotal += $exam->externalMaxMark;
506	if (!empty ($externalPassCriteria)) {
507	$externalPassMark = $exam->externalMaxMark * ($externalPassCriteria /100);
508	if($request->isRoundOff){
509	$externalPercent = $exam->externalMaxMark ? (100 * round($studentExternalMark) / $exam->externalMaxMark) : 0;
510	}else{
511	$externalPercent = $exam->externalMaxMark ? (100 * $studentExternalMark / $exam->externalMaxMark) : 0;
512	}
513	if ( $considerOverallPassCriteriaOnly == 0 ) {
514	$isFailed = $externalPassCriteria <= $externalPercent ? $isFailed : 1;
515	$isExternalFailed = $externalPassCriteria <= $externalPercent ? 0 : 1;
516	}
517	$markNeededToPass = $markNeededToPassExternal = $isFailed ? ($externalPassMark - $studentExternalMark ): 0;
518	}
519	}
520	else{
521	$studentExternalMark = 0;
522	}
523
524	if (!empty ($overallPassCriteria)) {
525	$overallPercent = $examTotal ? 100 * $studentExamTotal / $examTotal : 0;
526	$isFailed = $overallPassCriteria <= $overallPercent ? $isFailed : 1;
527
528	$overallPassMark = round($overallPassCriteria * ($examTotal / 100),2);
529	$markNeededToPassOverAll = $isFailed ? ($overallPassMark - $studentExamTotal) : 0;
530	if ($markNeededToPassOverAll > $markNeededToPassExternal) {
531	$markNeededToPass = $markNeededToPassOverAll;
532	$passMark = $overallPassMark;
533	}
534	}
535
536	if ( $request->fetchMarkHistory ) {
537	$studentSupplyExams = $this->getSupplyMarkHistory ($exam->subject->academicPaperSubjectId, $studentId, $supplyExamDetails);
538	foreach ( $studentSupplyExams as $studentSupplyExam ) {
539	$checkPassPercentCriteria->externalMark = $studentSupplyExam->mark;
540	if ( $request->considerRevaluation) {
541	$revalRequest = new \stdClass();
542	$revalRequest->studentId = $studentId;
543	$revalRequest->assessmentId = $studentSupplyExam->assessmentId;
544	$revalRequest->orderByHighestMark = 1;
545	$studentSupplyExam->markObtainedInExam = round($studentSupplyExam->mark, 2) ;
546	$studentRevaluationDetails = StudentsOverAllMarkReportService::getInstance()->getStudentFinalizedRevaluationMark($revalRequest);
547	if($studentRevaluationDetails){
548	$studentRevaluationDetail = current(current($studentRevaluationDetails)->students);
549	if($studentRevaluationDetail->revaluationMark){
550	$studentSupplyExam->mark = $studentRevaluationDetail->revaluationMark;
551	$studentSupplyExam->markType['REVALUATION']->mark = $studentRevaluationDetail->revaluationMark;
552	}
553	}
554	}
555
556	if ( $request->considerModerationMark ) {
557	$studentModerationMark = $this->getStudentExamDetails($studentSupplyExam->assessmentId, $studentId, $moderationMarkDetails);
558	if($studentModerationMark){
559	$studentSupplyExam->mark += $studentModerationMark->externalMark;
560	$studentSupplyExam->markType['MODERATION']->mark = $studentModerationMark->externalMark;
561	// $markHistory["REGULAR"]->mark = $studentMark->externalMark;
562	}
563	}
564	if ( $request->considerGraceMark ) {
565	$studentGraceMark = $this->getStudentExamDetails($studentSupplyExam->assessmentId, $studentId, $graceMarkDetails);
566	if($studentGraceMark){
567	$studentSupplyExam->mark += $studentGraceMark->externalMark;
568	$studentSupplyExam->markType['GRACEMARK']->mark = $studentGraceMark->externalMark;
569	}
570	}
571	$studentSupplyExam->mark = round($studentSupplyExam->mark, 2) ;
572
573	$isSupplyFailed = $this->checkIsFailedByPassPercentCriteria (
574	$checkPassPercentCriteria );
575	$studentSupplyExam->isFailed = $isSupplyFailed;
576	$studentSupplyExam->studentExamRegType = $supplyStudentDetails->studentExamRegType;
577	$markHistory["SUPPLY"]->supplyMarks[] = $studentSupplyExam;
578	}
579	$markHistory["REGULAR"]->maxMark = $examTotal;
580	}
581
582	// if ($exam->subject->isInternal && $studentMark->internalMark === null) {
583	// $isFailed = true;
584	// }
585
586	/**
587	* $maxGradePercent is used so that, we get the percentage in 'out of' the values in the db
588	* ie, 6, 10 or 100, different values for different colleges for different colleges...
589	*/
590	if ( $isFailed ) {
591	$percentageObtained = 0;
592	$semesterGradePercentObtained = 0;
593	}
594	else {
595	$percentageObtained = $maxGradePercent * $studentExamTotal / $examTotal;
596	$percentageObtained = round($percentageObtained, 2);
597
598	$semesterGradePercentObtained = $maxSemesterGradePercent * $studentExamTotal / $examTotal;
599	$semesterGradePercentObtained = round($semesterGradePercentObtained, 2);
600	}
601	$grade = $this->getGradeByPercentage($percentageObtained, $gradeDetails);
602	if ($courseType->courseTypeMethod == "PG") {
603	$exam->externalMaxMark = $exam->externalMaxMark? $exam->externalMaxMark : 0;
604	$internalMarkPer = $externalMarkPer = 0;
605	$x = 1;
606	// $isFailed = 0;
607	$studentExternalMark = round($studentExternalMark);
608	if ($exam->subject->isInternal) {
609	$internalMarkPer = round($maxGradePercent * $studentMark->internalMark / $exam->internalMaxMark, 2);
610	}
611	if ($exam->subject->isExternal) {
612	$externalMarkPer = round($maxGradePercent * $studentExternalMark / $exam->externalMaxMark, 2);
613	}
614
615	if ($exam->subject->isInternal && $exam->subject->isExternal) {
616	$gradePoint = round((($x * $internalMarkPer) + ( ($maxGradePercent-$x) * $externalMarkPer ) ) / $maxGradePercent, 2);
617	}
618	else {
619	$gradePoint = $internalMarkPer + $externalMarkPer;
620	}
621
622	$overallPercentPG = 100 * $gradePoint / $maxGradePercent ?? 0;
623	if (!empty ($overallPassCriteria)) {
624	$isFailed = $overallPassCriteria <= $overallPercentPG ? $isFailed : 1;
625
626	}
627	if ($isFailed) {
628	$gradePoint = 0;
629	}
630	$grade = $this->getGradeByPercentage($gradePoint, $gradeDetails);
631	$grade->gradePoint = $gradePoint ?? 0;
632	$isFailed = $grade->failStatus ? 1 : $isFailed;
633
634	}
635	if (!empty ($grade)) {
636	$creditGradePoint = ($exam->subject->credit * $grade->gradePoint);
637	if ($grade->failStatus == 1) {
638	$isFailed = 1;
639	}
640	}
641	} // Exempted ends
642
643	if($studentMark->internalAttendanceStatus == "ABSENT"){
644	$isFailed = 1;
645	$isInternalFailed = 1;
646	}
647
648	$student[$studentId]->semMarks[$academicTermId]->regularExamRegId = $exam->examRegistrations->examRegistrationId;
649	$student[$studentId]->semMarks[$academicTermId]->examRegName = $exam->examRegistrations->examRegistartionName;
650	$student[$studentId]->semMarks[$academicTermId]->examAttendedGroupId= $exam->batch->groupId;
651
652	$student[$studentId]->name = $studentMark->student->studentName;
653	$student[$studentId]->regNo = $studentMark->student->regNo;
654	$student[$studentId]->admissionNo = $studentMark->student->admissionNo;
655	$student[$studentId]->studentId = $studentId;
656	$student[$studentId]->myImage = $studentMark->student->myImage;
657	$student[$studentId]->groupId = $studentMark->student->groupId;
658	$student[$studentId]->batchName = $exam->batch->name;
659	$student[$studentId]->gender = $studentMark->student->studentGender;
660	if( !$exam->subject->excludeSubjectFromTotal ){
661	$student[$studentId]->totalArrears += $isFailed;
662	$student[$studentId]->semMarks[$academicTermId]->arrears += $isFailed;
663	}
664	$student[$studentId]->batchStartYear = $exam->batch->startYear;
665	$student[$studentId]->batchEndYear = $exam->batch->endYear ;
666	$student[$studentId]->yearOfStudy = $exam->batch->startYear . " - " . $exam->batch->endYear ;
667
668
669	$subject = new \stdClass();
670	$subject->id = $academicPaperSubjectId;
671	$subject->subjectName = $exam->subject->subjectName;
672	$subject->syllabusCode = $exam->subject->syllabusCode;
673	$subject->subjectDesc = filter_var(html_entity_decode($exam->subject->subjectDesc), FILTER_UNSAFE_RAW, FILTER_FLAG_STRIP_LOW \| FILTER_FLAG_STRIP_HIGH);
674	$subject->subjectCatId = $exam->subject->subjectCatId;
675	$subject->subjectCatName = $exam->subject->subjectCatName;
676	$subject->subjectCatCode = $exam->subject->subjectCatCode;
677	$subject->categoryCode = $exam->subject->categoryCode;
678
679	$subject->isInternal = $exam->subject->isInternal;
680	$subject->internalMark = $courseType->courseTypeMethod == "PG"? round($studentMark->internalMark, 2) : round($studentMark->internalMark) ;
681	$subject->internalMaxMark = $exam->internalMaxMark;
682	$subject->isInternalFailed = $isInternalFailed;
683	$subject->isInternalAbsent = $studentMark->internalAbsentStatus;
684	$subject->internalMarkDecimal = $studentMark->internalMark;
685
686	$subject->isExternal = $exam->subject->isExternal;
687	$subject->externalMark = round($studentExternalMark);
688	$subject->externalMark2Decimal = round($studentExternalMark, 2);
689	$subject->externalMaxMark = $exam->externalMaxMark;
690	$subject->isExternalFailed = $isExternalFailed;
691
692	$subject->internalGradePoint = $internalMarkPer;
693	$subject->externalGradePoint = $externalMarkPer;
694
695	$subject->credit = $exam->subject->credit;
696	$subject->grade = $grade->letterGrade;
697	$subject->maxGradePercent = $maxGradePercent;
698	$subject->maxGradePoint = $maxGradePoint;
699
700	$subject->examMonth = $examMonth;
701	$subject->examYear = $examYear;
702	$subject->monthYearOfPassing = $monthYearOfPassing;
703	$subject->examRegTypeOfPassing = $examRegTypeOfPassing;
704	$subject->examAttendedGroupId = $exam->batch->groupId;
705
706	$subject->subjectOrder = (int) $exam->subject->subjectOrder;
707	$subject->subjectPriority = (int) $exam->subject->subjectPriority;
708	$subject->isTheory = (int) $exam->subject->isTheory;
709
710	$subject->regularExamId = $exam->id;
711	$subject->supplyAttemptCount = StudentsOverAllMarkReportService::getInstance()->getSupplyAttemptCount($studentId, $academicPaperSubjectId);
712
713	$subject->internalPassCriteria = $internalPassCriteria;
714	$subject->externalPassCriteria = $externalPassCriteria;
715	$subject->overallPassCriteria = $overallPassCriteria;
716
717
718	$subject->externalPassMark = $externalPassMark;
719	$subject->overallPassMark = $overallPassMark;
720	$subject->markNeededToPassExternal = abs($markNeededToPassExternal);
721	$subject->markNeededToPassOverAll = abs($markNeededToPassOverAll);
722	$subject->markNeededToPass = abs($markNeededToPass);
723	$subject->passMark = $passMark;
724
725	// isAbsent is only to know whether the student was present/absent for regular exam only
726	$subject->isAbsent = $studentMark->externalAttendanceStatus;
727	$subject->isFailed = $isFailed;
728	$subject->isExempted = $isExempted;
729
730	$subject->excludeSubjectFromTotal = $exam->subject->excludeSubjectFromTotal;
731	$subject->subjectType = $exam->subject->subjectType;
732	$subject->markHistory = $markHistory;
733
734	/**
735	* Here 'Class' is fetched from 'semesterGrades' which is for temporary purposes
736	* The class has to be fetched from 'subjectGrades'
737	* A feature has to be added to examController to add ClassName in subjectGrades
738	*/
739
740	$subject->className = $grade->className;
741	// $subject->className = $this->getGradeByPercentage($semesterGradePercentObtained, $semesterGradeDetails)->className;
742	$student[$studentId]->semMarks[$academicTermId]->subject[$academicPaperSubjectId] = $subject;
743	$student[$studentId]->semMarks[$academicTermId]->subject[$academicPaperSubjectId]->academicPaperSubjectId = $academicPaperSubjectId;
744
745	// max count of supply attempted in the semester
746	if($student[$studentId]->semMarks[$academicTermId]->supplyAttemptCount < $subject->supplyAttemptCount){
747	$student[$studentId]->semMarks[$academicTermId]->supplyAttemptCount = $subject->supplyAttemptCount;
748	}
749
750	// max count of supply attempted in all semesters
751	if($student[$studentId]->supplyAttemptCount < $subject->supplyAttemptCount){
752	$student[$studentId]->supplyAttemptCount = $subject->supplyAttemptCount;
753	}
754
755	if ( $isExempted == 1 ) {
756	continue;
757	}
758
759	$student[$studentId]->allCredit += $exam->subject->credit;
760
761	if ($courseType->isPG == 1 &&
762	$exam->batch->startYear >= 2017 &&
763	$exam->subject->subjectType == ExamSubjectTypeConstants::OPEN_ELECTIVE) {
764	// Exclude open electives from totalMarks and CGPA for pg 2017 onwards
765	continue;
766	} else if ($courseType->isPG == 0 &&
767	$exam->batch->startYear <= 2015 &&
768	$exam->subject->subjectType == ExamSubjectTypeConstants::OPEN_ELECTIVE) {
769	// Exclude open elective from Total mark & CGPA Calculation for UG passout students
770	continue;
771	} else if ($courseType->isPG == 0 &&
772	$exam->batch->startYear >= 2016 && (
773	$exam->subject->subjectType == ExamSubjectTypeConstants::OPEN_ELECTIVE \|\|
774	$exam->subject->subjectType == ExamSubjectTypeConstants::FOUNDATION_COURSE \|\|
775	$exam->subject->subjectType == ExamSubjectTypeConstants::TERM_PAPER)) {
776	// Exclude open elective, term paper, foundation course from Total mark & CGPA Calculation for UG 2016 onwards
777	continue;
778	}
779
780	$student[$studentId]->credit += $exam->subject->credit;
781	$student[$studentId]->creditGradePoint += $creditGradePoint;
782	if( !$exam->subject->excludeSubjectFromTotal ){
783	$student[$studentId]->semMarks[$academicTermId]->credit += $exam->subject->credit;
784	$student[$studentId]->semMarks[$academicTermId]->creditGradePoint += $creditGradePoint;
785
786
787	}
788	$student[$studentId]->semMarks[$academicTermId]->subject[$academicPaperSubjectId]->gradePoint = $grade->gradePoint;
789	$student[$studentId]->semMarks[$academicTermId]->subject[$academicPaperSubjectId]->creditGradePoint = $creditGradePoint;
790	$student[$studentId]->semMarks[$academicTermId]->subject[$academicPaperSubjectId]->totalMarkObtained = round($studentExamTotal, 2);
791	$student[$studentId]->semMarks[$academicTermId]->subject[$academicPaperSubjectId]->creditxMark = $exam->subject->credit * $studentExamTotal;
792	$student[$studentId]->semMarks[$academicTermId]->subject[$academicPaperSubjectId]->totalMaxMark = $examTotal;
793	if ( $exam->subject->excludeSubjectFromTotal != 1 ) {
794	$totalMark = round($studentExamTotal, 2);
795	$student[$studentId]->semMarks[$academicTermId]->subject[$academicPaperSubjectId]->totalMark = $totalMark;
796	$student[$studentId]->semMarks[$academicTermId]->subject[$academicPaperSubjectId]->percentage = round(100 *
797	$totalMark / $examTotal, 2);
798	unset ( $totalMark );
799	}
800
801	if ($courseType->isPG == 0 && (
802	$exam->subject->subjectType == ExamSubjectTypeConstants::FOUNDATION_COURSE \|\|
803	$exam->subject->subjectType == ExamSubjectTypeConstants::OPEN_ELECTIVE \|\|
804	$exam->subject->subjectType == ExamSubjectTypeConstants::TERM_PAPER)) {
805	continue;
806	} else if ($courseType->isPG == 0 && $exam->subject->excludeSubjectFromTotal == 1) {
807	continue;
808	} else if ($courseType->isPG == 1 && (
809	$exam->subject->subjectType == ExamSubjectTypeConstants::OPEN_ELECTIVE \|\|
810	$exam->subject->subjectType == ExamSubjectTypeConstants::IGNITORS )) {
811	continue;
812	}
813
814	$student[$studentId]->totalMarkObtained += $studentExamTotal;
815	$student[$studentId]->totalMark += $examTotal;
816	$student[$studentId]->semMarks[$academicTermId]->totalMarks += $studentExamTotal;
817	$student[$studentId]->semMarks[$academicTermId]->examTotalMarks += $examTotal;
818	$student[$studentId]->creditForConvocation += $exam->subject->credit;
819	$student[$studentId]->creditGradePointForConvocation += $creditGradePoint;
820	}
821	}
822	}
823	if ($request->fetchOnlyMark) {
824	return $subjectMark;
825	}
826
827	foreach ($student as $studentId => $studentObj) {
828	$totalMark = $studentObj->totalMark;
829	$maxPercent = $semesterGradeDetails[0]->rangeTo;
830
831	$studentObj->isFailed = false;
832	$studentObj->isPG = $courseType->isPG;
833	foreach ($studentObj->semMarks as $actTermId => $semMark) {
834	$semMarkGrade = null;
835	$semIsFailed = false;
836	$searchRequest = new \stdClass();
837	$searchRequest->groupId = $semMark->examAttendedGroupId;
838	$searchRequest->academicTermId = $actTermId;
839	$searchRequest->requestType = "SEMESTER";
840	$semesterGradeSchemeArray = GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest);
841
842	$semesterGradeDetails = current($semesterGradeSchemeArray)->grades;
843
844	$maxPercent = $semesterGradeDetails[0]->rangeTo;
845
846	if ( $semMark->arrears ) {
847	$semMark->sgpa = "0"; // Please don't update "-"
848	$semMarkGrade = $this->getGradeByPercentage(0, $semesterGradeDetails);
849	$semIsFailed = true;
850	} else {
851	/**
852	* Semester wise aggregate percentage criteria check
853	*/
854	$semesterPercentage = round ( ( $semMark->examTotalMarks ? 100 * $semMark->totalMarks / $semMark->examTotalMarks : 0) , 2);
855	if ( $courseType->isPG == 1 && $semesterPercentage < $aggregatePassCriteria ) {
856	$studentObj->isFailed = true;
857	$semIsFailed = true;
858	}
859	/ codeEnds /
860	if ( !$studentObj->isFailed ) {
861	$semMark->sgpa = $semMark->credit ? round($semMark->creditGradePoint / $semMark->credit, 2) : 0;
862	$semMarkGrade = $this->getGradeByPercentage($semMark->sgpa, $semesterGradeDetails);
863	}
864	}
865	$semMark->grade = $semMarkGrade->letterGrade;
866	$semMark->class = $semMarkGrade->className;
867	$semMark->isFailed = $semIsFailed;
868	$semCreditxMark = array_sum(array_column($semMark->subject, "creditxMark"));
869	$semMark->WAS = $semMark->credit ? ($semCreditxMark / $semMark->credit) : 0;
870
871	$semMark->rawSgpa = $semMark->credit ? ($semMark->creditGradePoint / $semMark->credit) : 0;
872	}
873
874	if ($studentObj->totalArrears > 0) {
875	$studentObj->isFailed = true;
876	}
877
878	/**
879	* In 'semesterGradeDetails' the percentage cannot be always in 100.
880	* So inorder to handle that '$maxPercent' is used.
881	*/
882	$studentObj->percentage = $totalMark ? ( $maxPercent * $studentObj->totalMarkObtained / $totalMark) : 0;
883	$studentObj->percentage = round($studentObj->percentage, 2);
884	$schemeType = current($semesterGradeDetails)->schemeType;
885	$studentObj->totalSgpaCreditGradePoint = 0;
886	$studentObj->totalSgpaCredits = 0;
887	if ($studentObj->credit) {
888	foreach ($studentObj->semMarks as $actTermId => $semMark) {
889	$semMark->roundedSgpaxCredit = round($semMark->rawSgpa,2) * $semMark->credit;
890	$studentObj->totalSgpaCreditGradePoint += $semMark->roundedSgpaxCredit;
891	$studentObj->totalSgpaCredits += $semMark->credit;
892	}
893	$studentObj->cgpa = $studentObj->totalSgpaCreditGradePoint / $studentObj->totalSgpaCredits;
894	// $studentObj->cgpa = $totalCreditGradePoint / $totalCredit;
895	if($request->considerRoundingOffCgpa){
896	$studentObj->cgpa = $studentObj->cgpa ? round($studentObj->cgpa,$request->roundingOffCgpaUpto) : $studentObj->cgpa;
897	}
898	// if ($studentObj->totalArrears > 0 \|\| $studentObj->isFailed ) {
899	// $percentageGrade = $this->getGradeByPercentage(0, $semesterGradeDetails);
900	// } else {
901	// if ( $schemeType == "CREDIT") {
902	$percentageGrade = $this->getGradeByPercentage($studentObj->cgpa, $cgpaGradeDetails);
903	// }
904	// else {
905	// $percentageGrade = $this->getGradeByPercentage($studentObj->percentage, $semesterGradeDetails);
906	// }
907	// }
908	if (!empty ($percentageGrade)) {
909	$studentObj->grade = $percentageGrade->letterGrade;
910	$studentObj->class = $percentageGrade->className;
911	}
912	}
913	}
914	if ($request->getFailedStudentDetailsOnly){
915	return $failedSemMarks;
916	}
917	return $student;
918	}
919	protected function markListProcessing($request, $studentDetails, $studentRegularExamDetails)
920	{
921	$searchRequest = new \stdClass();
922	$searchRequest->groupId = $request->groupId;
923	$searchRequest->academicTermId = $request->academicTermId;
924	$subjectGradeSchemeArray = GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest);
925	// $reqWithoutGracemark = clone $request;
926	// $reqWithoutGracemark->considerGraceMark = false;
927	// $studentDetailsWithoutGracemark = reset($this->getStudentsOverallMarkReport($reqWithoutGracemark, $studentRegularExamDetails));
928	$searchRequest->requestType = "CURRICULAM";
929	$cgpaGradeSchemeArray = GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest);
930	$cgpaGradeDetails = reset($cgpaGradeSchemeArray)->grades;
931
932	foreach ($studentDetails as $studentId => $student) {
933	$student->consolidated->groupId = $student->groupId;
934	$student->consolidated->studentId = $studentId;
935
936	$examRegHistoryDetails = null;
937	$studentSemHistoryDetails = null;
938	$semHistoryArray = [];
939	$supplyRegDetails = [];
940
941	$historyRequest = new ConsolidatedOverAllMarkReportRequest();
942	$historyRequest = clone $request;
943	$historyRequest->considerSupplementary = false;
944	$historyRequest->considerImprovement = false;
945	$historyRequest->studentId = $request->studentId;
946	$historyRequest->groupId = $request->groupId;
947	$historyRequest->examRegistrationType = ExamType::REGULAR;
948	$historyRequest->requestType = "";
949	$examRegHistoryDetails = StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($historyRequest);
950	if ( !empty ( $examRegHistoryDetails ) ) {
951	$studentSemHistoryDetails = $this->getStudentsOverallMarkReport($historyRequest, $examRegHistoryDetails);
952	$historyRequest->considerGraceMark = false;
953	$studentSemHistoryDetailsWithoutGrace = $this->getStudentsOverallMarkReport($historyRequest, $examRegHistoryDetails);
954	foreach (reset($studentSemHistoryDetails)->semMarks as $semMarkHisId => $semMarkHis) {
955	$semHistory = new \stdClass();
956	$semHistory->wgp = $semMarkHis->wgp;
957	$semHistory->creditGradePoint = $semMarkHis->creditGradePoint;
958	$semHistory->groupId = $semMarkHis->examAttendedGroupId;
959	$semHistory->academicTermId = $semMarkHisId;
960	$semHistory->examRegistrationId = $semMarkHis->regularExamRegId;
961	$semHistory->sgpa = $semMarkHis->rawSgpa;
962	$semHistory->wgpa = $semMarkHis->wgpa ?? 0;
963	$semHistory->class = $semMarkHis->class;
964	$semHistory->grade = $semMarkHis->grade;
965	$semHistory->examYear = $semMarkHis->lastExamYear;
966	$semHistory->examMonth = $semMarkHis->lastExamMonth;
967	$semHistory->totalMark = $semMarkHis->examTotalMarks;
968	$semHistory->gradePoint = $semMarkHis->gradePoint ?? 0;
969	$semHistory->markObtained = $semMarkHis->totalMarks;
970	$semHistory->totalMarks = $semMarkHis->examTotalMarks;
971	$semHistory->percentage = ($semHistory->markObtained / $semHistory->totalMarks) * 100;
972	$semHistory->creditxMark = $semMarkHis->creditxMark;
973	$semHistory->failedStatus = $semMarkHis->isFailed ? "FAILED" : "PASSED";
974	$semHistory->historyType = ExamType::REGULAR;
975	$student->semMarks[$semMarkHisId]->consolidated->markHistory[] = $semHistory;
976	$student->semMarks[$semMarkHisId]->consolidated->regularExamMarkDetails = $semHistory;
977	}
978	}
979
980	foreach ($request->supplyRegIdArray as $supplyReg) {
981	$supplyHistoryRequest = new ConsolidatedOverAllMarkReportRequest();
982	$supplyHistoryRequest = clone $request;
983	$supplyHistoryRequest->examRegistrationId = $supplyReg->id;
984	$supplyHistoryRequest->examRegistrationType = "";
985	$supplyHistoryRequest->requestType = "";
986	$supplyHistoryRequest->academicTermId = $supplyReg->academicTermId;
987	$supplyRegDetails[$supplyReg->id] = $this->getStudentsSupplyMarkReport($supplyHistoryRequest);
988
989	if (empty($supplyRegDetails[$supplyReg->id])) continue;
990
991	$semMarkHis = reset($supplyRegDetails[$supplyReg->id])->overAllMarkDetails->semMarks[$supplyReg->academicTermId];
992	$supplySemMarkHis = reset($supplyRegDetails[$supplyReg->id])->semMarks[$supplyReg->academicTermId];
993
994	$semHistory = new \stdClass();
995	$semHistory->wgp = $semMarkHis->wgp;
996	$semHistory->creditGradePoint = $supplySemMarkHis->creditGradePoint;
997	$semHistory->groupId = $semMarkHis->examAttendedBatchId;
998	$semHistory->academicTermId = $supplyReg->academicTermId;
999	$semHistory->sgpa = $semMarkHis->rawSgpa;
1000	$semHistory->wgpa = $semMarkHis->wgpa ?? 0;
1001	$semHistory->class = $semMarkHis->class;
1002	$semHistory->grade = $semMarkHis->grade;
1003	$semHistory->examYear = $semMarkHis->lastExamYear;
1004	$semHistory->examMonth = $semMarkHis->lastExamMonth;
1005	$semHistory->totalMarks = $supplySemMarkHis->examTotalMarks;
1006	$semHistory->gradePoint = $supplySemMarkHis->supplyGradePoint ?? 0;
1007	$semHistory->markObtained = $supplySemMarkHis->totalMarks;
1008	$semHistory->supplyMarkObtained = $supplySemMarkHis->supplyRegularTotalMarks;
1009	$semHistory->supplyGradePoint = $supplySemMarkHis->supplyRegularGradePoint;
1010
1011	$semHistory->percentage = ($semHistory->markObtained / $semHistory->totalMarks) * 100;
1012	$semHistory->creditxMark = $supplySemMarkHis->supplyCreditxMarks;
1013	$semHistory->failedStatus = $semMarkHis->isFailed ? "FAILED" : "PASSED";
1014	$semHistory->historyType = reset($supplyRegDetails[$supplyReg->id])->examRegType;
1015	$semHistory->examRegistrationId = $supplyReg->id;
1016	$student->semMarks[$supplyReg->academicTermId]->consolidated->markHistory[] = $semHistory;
1017	}
1018
1019	foreach ($student->semMarks as $semId => $semMarks) {
1020	$semMarks->consolidated->groupId = $semMarks->examAttendedGroupId;
1021	$semMarks->consolidated->semId = $semId;
1022	$semMarks->consolidated->academicTermId = $semId;
1023	$semMarks->consolidated->studentId = $studentId;
1024	$semMarks->consolidated->wgpa = 0;
1025
1026	if(!$student->isPG){
1027	$semGradeObject = new \stdClass();
1028	$semGradeObject->groupId = $request->groupId;
1029	$semGradeObject->academicTermId = $semId;
1030	$semesterGradeDetials = $this->getSemesterGradeDetials($semGradeObject, ($semMarks->arrears > 0 ? 0 : round($semMarks->sgpa, 3) * 10));
1031	}
1032	foreach ($semMarks->subject as $subjectId => $subject) {
1033	$subject->consolidated->examAttendedGroupId = $subject->examAttendedGroupId;
1034	$subject->consolidated->groupId = $subject->examAttendedGroupId;
1035	$subject->consolidated->academicTermId = $semId;
1036	$subject->consolidated->academicPaperSubjectId = $subject->id;
1037	$subject->consolidated->id = $subject->id;
1038	$subject->consolidated->studentId = $studentId;
1039
1040	$searchRequest = new \stdClass();
1041	$searchRequest->groupId = $request->groupId;
1042	$searchRequest->academicTermId = $semId;
1043	$searchRequest->academicPaperSubjectId = $subject->id;
1044	$subjectGradeSchemeArray = GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest);
1045	$gradeDetails[$subject->id] = current($subjectGradeSchemeArray)->grades;
1046	$maxGradePercent = current($gradeDetails[$subject->id])->rangeTo;
1047
1048	$subject->lastMonthYear = strtotime("01 $subject->monthYearOfPassing");
1049	$subject->consolidated->totalMarks = $subject->totalMarkObtained ? $subject->totalMarkObtained : 0;
1050	$subject->consolidated->internalMark = $subject->internalMark;
1051	$subject->consolidated->isInternalNull = $subject->isInternalNull;
1052	$subject->consolidated->internalAttendanceStatus = $subject->isInternalAbsent?"ABSENT":"PRESENT";
1053	$subject->consolidated->percentage = $subject->percentage ? $subject->percentage : 0;
1054	$subject->consolidated->credit = $subject->credit ? $subject->credit : 0;
1055	$subject->consolidated->grade = $subject->grade ? $subject->grade : "";
1056	$subject->consolidated->class = $subject->className ? $subject->className : "";
1057	$subject->consolidated->gradePoint = $subject->gradePoint ? $subject->gradePoint : 0;
1058	$subject->consolidated->creditGradePoint = $subject->creditGradePoint ? $subject->creditGradePoint : 0;
1059	$subject->consolidated->noOfChancesTaken = $subject->supplyAttemptCount + 1;
1060
1061	$internalGrade = $this->getGradeByPercentage(($subject->internalMark/$subject->internalMaxMark)*$maxGradePercent, $gradeDetails[$subjectId]);
1062	$internalGrade->gradePoint = $student->isPG ?$subject->internalGradePoint : $internalGrade->gradePoint;
1063	$subject->internalGrade = $internalGrade->letterGrade;
1064	$subject->internalGradePoint = $internalGrade->gradePoint;
1065
1066	$subjectmarkHistory = [];
1067	foreach ($subject->markHistory as $markHistoryType => $markHistory) {
1068	if($markHistoryType == ExamType::SUPPLY \|\| $markHistoryType == ExamType::IMPROVEMENT \|\| $markHistoryType == ExamType::REGULAR_SPECIAL_EXAM) {
1069	foreach ($markHistory->supplyMarks as $supplyMarksHistory){
1070	$subjectmarkHistoryObj = new \stdClass();
1071	$subjectmarkHistoryObj->examMarkType = $markHistoryType;
1072	if($supplyMarksHistory->studentExamRegType == 'IMPROVEMENT'){
1073	$subjectmarkHistoryObj->examMarkType = $supplyMarksHistory->studentExamRegType;
1074	}
1075	$subjectmarkHistoryObj->examRegId = $supplyMarksHistory->id;
1076	$subjectmarkHistoryObj->examRegistrationId = $supplyMarksHistory->id;
1077	$subjectmarkHistoryObj->assessmentId = $supplyMarksHistory->assessmentId;
1078	$subjectmarkHistoryObj->oeExamId = $supplyMarksHistory->oeExamId;
1079
1080	if (empty($supplyRegDetails[$subjectmarkHistoryObj->examRegistrationId])) continue;
1081	$supplyRegDetail = reset($supplyRegDetails[$subjectmarkHistoryObj->examRegId])->semMarks[$semId]->subject[$subjectId];
1082
1083	$subjectmarkHistoryObj->examId = $supplyRegDetail->supplyExamId;
1084	$subjectmarkHistoryObj->externalMark = $supplyRegDetail->externalMark;
1085	$subjectmarkHistoryObj->externalMarkObtainedInExam = $supplyMarksHistory->markObtainedInExam;
1086
1087	$subjectmarkHistoryObj->externalMaxMark = $supplyRegDetail->externalMaxMark;
1088
1089	$externalGradePointForGradeCalc = $student->isPG ? $supplyRegDetail->externalGradePoint : (($subjectmarkHistoryObj->externalMark+$subject->graceMark)/$subjectmarkHistoryObj->externalMaxMark)*$maxGradePercent;
1090	$externalGrade = $this->getGradeByPercentage($externalGradePointForGradeCalc, $gradeDetails[$subjectId]);
1091	$externalGrade->gradePoint = $student->isPG ? $supplyRegDetail->externalGradePoint : $externalGrade->gradePoint;
1092	$subjectmarkHistoryObj->externalGrade = $externalGrade->letterGrade;
1093	$subjectmarkHistoryObj->externalGradePoint = $externalGrade->gradePoint ?? 0;
1094
1095	$subjectmarkHistoryObj->markObtained = $supplyRegDetail->totalMark ?? 0;
1096	$subjectmarkHistoryObj->totalMark = $supplyRegDetail->totalMaxMark ?? ($subject->internalMaxMark + $subject->externalMaxMark);
1097	$subjectmarkHistoryObj->percentage = ($subjectmarkHistoryObj->markObtained/$subjectmarkHistoryObj->totalMark) * 100;
1098	$subjectmarkHistoryObj->internalMark = $subject->internalMark;
1099	$subjectmarkHistoryObj->isInternalNull = $subject->isInternalNull;
1100	$subjectmarkHistoryObj->internalAttendanceStatus = $subject->isInternalAbsent?"ABSENT":"PRESENT";
1101	$subjectmarkHistoryObj->internalGrade = $subject->internalGrade;
1102	$subjectmarkHistoryObj->internalGradePoint = $subject->internalGradePoint;
1103
1104	$percentageObtainedInternal = round(($maxGradePercent * $subject->internalMark / $subject->internalMaxMark), 2);
1105	$percentageObtainedExternal = round(($maxGradePercent * $subjectmarkHistoryObj->externalMark / $subjectmarkHistoryObj->externalMaxMark), 2);
1106	if($student->batchStartYear > 2018 && $subject->isInternal && $subject->isExternal){
1107	$subjectmarkHistoryObj->wgpa = ($percentageObtainedInternal + (4 * $percentageObtainedExternal)) / $subject->maxGradePoint;
1108	$subjectmarkHistoryObj->wgpa = round($subjectmarkHistoryObj->wgpa, 2) ?? 0;
1109	}else if ($subject->isInternal && $subject->isExternal) {
1110	$subjectmarkHistoryObj->wgpa = ($percentageObtainedInternal + (3 * $percentageObtainedExternal)) / $subject->maxGradePoint;
1111	$subjectmarkHistoryObj->wgpa = round($subjectmarkHistoryObj->wgpa, 2) ?? 0;
1112	}
1113	else if ($subject->isInternal){
1114	$subjectmarkHistoryObj->wgpa = round($percentageObtainedInternal, 2) ?? 0;
1115	}
1116	else if ($subject->isExternal){
1117	$subjectmarkHistoryObj->wgpa = round($percentageObtainedExternal, 2) ?? 0;
1118	}
1119
1120	$subjectmarkHistoryObj->creditxMark = $supplyRegDetail->creditxMark;
1121	$subjectmarkHistoryObj->grade = $supplyRegDetail->grade;
1122	$subjectmarkHistoryObj->class = $supplyRegDetail->class;
1123	$subjectmarkHistoryObj->gradePoint = $supplyRegDetail->gradePoint ?? 0;
1124	$subjectmarkHistoryObj->creditGradePoint = $subject->credit * $subjectmarkHistoryObj->gradePoint;
1125	$subjectmarkHistoryObj->percentageObtainedExternal = $percentageObtainedExternal;
1126	$subjectmarkHistoryObj->percentageObtainedInternal = $percentageObtainedInternal;
1127	$subjectmarkHistoryObj->isInternal = $subject->isInternal;
1128	$subjectmarkHistoryObj->excludeSubjectFromTotal = $subject->excludeSubjectFromTotal;
1129	$subjectmarkHistoryObj->isExternal = $subject->isExternal;
1130
1131	$subjectmarkHistoryObj->examMonth = $supplyMarksHistory->examMonth;
1132	$subjectmarkHistoryObj->examYear = $supplyMarksHistory->examYear;
1133	$subjectmarkHistoryObj->attendanceStatus = $supplyMarksHistory->externalAttendanceStatus;
1134	$subjectmarkHistoryObj->resultStatus = $supplyRegDetail->isFailed ? "FAILED" : "PASSED";
1135	$passMarkForMarkHistory = $subject->externalPassMark ?? ($subject->overallPassMark ?? 0);
1136	$subjectmarkHistoryObj->markNeededToPass = $supplyRegDetail->isFailed ? $passMarkForMarkHistory - $subjectmarkHistoryObj->externalMark : 0;
1137	$subjectmarkHistoryObj->markNeededToPass = abs($subjectmarkHistoryObj->markNeededToPass);
1138	$subjectmarkHistoryObj->examName = trim($supplyMarksHistory->supplyName);
1139
1140	//for exam written mark details
1141	$regularHistory = new \stdClass();
1142	$regularHistory->mark = $subjectmarkHistoryObj->externalMarkObtainedInExam;
1143	$markHistoryStatus = $this->getStudentSubjectGradeDetailsForMarkHistory($request, $subject, $semId, $regularHistory);
1144	$typeVariable = "externalMarkObtainedInExam";
1145
1146	if ( $markHistoryStatus ){
1147	$gradeVar = $typeVariable."Grade";
1148	$subjectmarkHistoryObj->$gradeVar = $markHistoryStatus->letterGrade;
1149
1150	$gradePointVar = $typeVariable."GradePoint";
1151	$subjectmarkHistoryObj->$gradePointVar = $markHistoryStatus->gradePoint;
1152
1153	$creditGradePointVar = $typeVariable."CreditGradePoint";
1154	$subjectmarkHistoryObj->$creditGradePointVar = $markHistoryStatus->creditGradePoint;
1155
1156	$isFailedVar = $typeVariable."IsFailed";
1157	$subjectmarkHistoryObj->$isFailedVar = $markHistoryStatus->isFailed;
1158	}
1159
1160	//for getting gracemark, revaluation, moderation - gradepoints and marks
1161	foreach ($supplyMarksHistory->markType as $typeKey => $subjectMarkType){
1162
1163	$typeVariable = "";
1164	if($typeKey == "REVALUATION"){
1165	$typeVariable = "revaluation";
1166	}
1167	else if($typeKey == "GRACEMARK"){
1168	$typeVariable = "graceMark";
1169	}
1170	else if($typeKey == "MODERATION"){
1171	$typeVariable = "moderation";
1172	}
1173	if( $typeVariable ){
1174	$markVar = $typeVariable."Mark";
1175	if($typeKey == "GRACEMARK"){
1176	$markVar = "graceMark";
1177	}
1178	$subjectmarkHistoryObj->$markVar = $subjectMarkType->mark;
1179	if($typeKey == "GRACEMARK" \|\| $typeKey == "MODERATION"){
1180	$subjectMarkType->mark += $subjectmarkHistoryObj->externalMarkObtainedInExam;
1181	}
1182	$markHistoryStatus = $this->getStudentSubjectGradeDetailsForMarkHistory($request, $subject, $semId, $subjectMarkType);
1183
1184
1185	if ( $markHistoryStatus ){
1186	$gradeVar = $typeVariable."Grade";
1187	$subjectmarkHistoryObj->$gradeVar = $markHistoryStatus->letterGrade;
1188
1189	$gradePointVar = $typeVariable."GradePoint";
1190	$subjectmarkHistoryObj->$gradePointVar = $markHistoryStatus->gradePoint;
1191
1192	$creditGradePointVar = $typeVariable."CreditGradePoint";
1193	$subjectmarkHistoryObj->$creditGradePointVar = $markHistoryStatus->creditGradePoint;
1194
1195	$isFailedVar = $typeVariable."IsFailed";
1196	$subjectmarkHistoryObj->$isFailedVar = $markHistoryStatus->isFailed;
1197	}
1198	}
1199	}
1200
1201	$subjectmarkHistory[] = $subjectmarkHistoryObj;
1202	}
1203	}
1204	else if($markHistoryType == ExamType::REGULAR ) {
1205	$regularExamSubjectData = reset($studentSemHistoryDetails)->semMarks[$semId]->subject[$subject->id];
1206	$regularExamSubjectDataWithoutGraceMark = reset($studentSemHistoryDetailsWithoutGrace)->semMarks[$semId]->subject[$subject->id];
1207	$subjectmarkHistoryObj = new \stdClass();
1208	$subjectmarkHistoryObj->examMarkType = $markHistoryType;
1209	$subjectmarkHistoryObj->examRegistrationId = $markHistory->examRegistrationId;
1210	$subjectmarkHistoryObj->assessmentId = $markHistory->assessmentId;
1211	$subjectmarkHistoryObj->oeExamId = $markHistory->oeExamId;
1212
1213	$subjectmarkHistoryObj->externalMark = $regularExamSubjectData->externalMark;
1214	$subjectmarkHistoryObj->externalMarkObtainedInExam = $markHistory->markObtainedInExam;
1215	$subjectmarkHistoryObj->externalMaxMark = $subject->externalMaxMark;
1216
1217	$externalGradePointForGradeCalc = $student->isPG ? $regularExamSubjectData->externalGradePoint : (($subjectmarkHistoryObj->externalMark+$subject->graceMark)/$subjectmarkHistoryObj->externalMaxMark)*$maxGradePercent;
1218	$externalGrade = $this->getGradeByPercentage($externalGradePointForGradeCalc, $gradeDetails[$subjectId]);
1219	$externalGrade->gradePoint = $student->isPG ? $regularExamSubjectData->externalGradePoint : $externalGrade->gradePoint;
1220	$subjectmarkHistoryObj->externalGrade = $externalGrade->letterGrade;
1221	$subjectmarkHistoryObj->externalGradePoint = $externalGrade->gradePoint ?? 0;
1222
1223	$subjectmarkHistoryObj->markObtained = $regularExamSubjectData->totalMarkObtained;
1224	$subjectmarkHistoryObj->totalMark = $subject->internalMaxMark + $subject->externalMaxMark;
1225	$subjectmarkHistoryObj->percentage = ($subjectmarkHistoryObj->markObtained/$subjectmarkHistoryObj->totalMark) * 100;
1226	$subjectmarkHistoryObj->internalMark = $subject->internalMark;
1227	$subjectmarkHistoryObj->isInternalNull = $subject->isInternalNull;
1228	$subjectmarkHistoryObj->internalAttendanceStatus = $subject->isInternalAbsent?"ABSENT":"PRESENT";
1229	$subjectmarkHistoryObj->internalGrade = $subject->internalGrade;
1230	$subjectmarkHistoryObj->internalGradePoint = $subject->internalGradePoint;
1231
1232	$percentageObtainedInternal = round(($maxGradePercent * $subject->internalMark / $subject->internalMaxMark), 2);
1233	$percentageObtainedExternal = round(($maxGradePercent * $subjectmarkHistoryObj->externalMark / $subjectmarkHistoryObj->externalMaxMark), 2);
1234	if($student->batchStartYear > 2018 && $subject->isInternal && $subject->isExternal){
1235	$subjectmarkHistoryObj->wgpa = ($percentageObtainedInternal + (4 * $percentageObtainedExternal)) / $subject->maxGradePoint;
1236	$subjectmarkHistoryObj->wgpa = round($subjectmarkHistoryObj->wgpa, 2) ?? 0;
1237	}else if ($subject->isInternal && $subject->isExternal) {
1238	$subjectmarkHistoryObj->wgpa = ($percentageObtainedInternal + (3 * $percentageObtainedExternal)) / $subject->maxGradePoint;
1239	$subjectmarkHistoryObj->wgpa = round($subjectmarkHistoryObj->wgpa, 2) ?? 0;
1240	}
1241	else if ($subject->isInternal){
1242	$subjectmarkHistoryObj->wgpa = round($percentageObtainedInternal, 2) ?? 0;
1243	}
1244	else if ($subject->isExternal){
1245	$subjectmarkHistoryObj->wgpa = round($percentageObtainedExternal, 2) ?? 0;
1246	}
1247
1248	$grade = $this->getGradeByPercentage($subjectmarkHistoryObj->percentage * $maxGradePercent/100, $gradeDetails[$subjectId]);
1249	$grade->gradePoint = $regularExamSubjectData->gradePoint;
1250	$subjectmarkHistoryObj->creditxMark = $subject->credit * $subjectmarkHistoryObj->markObtained;
1251	$subjectmarkHistoryObj->grade = $regularExamSubjectData->grade;
1252	$subjectmarkHistoryObj->class = $regularExamSubjectData->className;
1253	$subjectmarkHistoryObj->percentageObtainedExternal = $percentageObtainedExternal;
1254	$subjectmarkHistoryObj->percentageObtainedInternal = $percentageObtainedInternal;
1255	$subjectmarkHistoryObj->gradePoint = $grade->gradePoint ?? 0;
1256	$subjectmarkHistoryObj->creditGradePoint = $subject->credit * $subjectmarkHistoryObj->gradePoint ;
1257	$subjectmarkHistoryObj->examMonth = $markHistory->month;
1258	$subjectmarkHistoryObj->examYear = $markHistory->year;
1259	$subjectmarkHistoryObj->attendanceStatus = $markHistory->externalAttendanceStatus;
1260	$subjectmarkHistoryObj->resultStatus = $regularExamSubjectData->isFailed ? "FAILED" : "PASSED";
1261	$subjectmarkHistoryObj->resultStatusWithoutGraceMark = $regularExamSubjectDataWithoutGraceMark->isFailed ? "FAILED" : "PASSED";
1262
1263	$subjectmarkHistoryObj->markNeededToPass = $regularExamSubjectData->isFailed ? $regularExamSubjectData->markNeededToPass : 0;
1264	$subjectmarkHistoryObj->markNeededToPassWithoutGraceMark = $regularExamSubjectDataWithoutGraceMark->isFailed ? $regularExamSubjectDataWithoutGraceMark->markNeededToPass : 0;
1265	$subjectmarkHistoryObj->markNeededToPassExternal = $regularExamSubjectData->isExternalFailed ? $regularExamSubjectData->markNeededToPassExternal : 0;
1266	$subjectmarkHistoryObj->markNeededToPassOverAll = $regularExamSubjectData->isFailed ? $regularExamSubjectData->markNeededToPassOverAll : 0;
1267	$subjectmarkHistoryObj->isInternal = $subject->isInternal;
1268	$subjectmarkHistoryObj->excludeSubjectFromTotal = $subject->excludeSubjectFromTotal;
1269	$subjectmarkHistoryObj->isExternal = $subject->isExternal;
1270
1271	$subjectmarkHistoryObj->examName = trim($markHistory->name);
1272
1273	//for exam written mark details
1274	$regularHistory = new \stdClass();
1275	$regularHistory->mark = $subjectmarkHistoryObj->externalMarkObtainedInExam;
1276	$markHistoryStatus = $this->getStudentSubjectGradeDetailsForMarkHistory($request, $subject, $semId, $regularHistory);
1277	$typeVariable = "externalMarkObtainedInExam";
1278
1279	if ( $markHistoryStatus ){
1280	$gradeVar = $typeVariable."Grade";
1281	$subjectmarkHistoryObj->$gradeVar = $markHistoryStatus->letterGrade;
1282
1283	$gradePointVar = $typeVariable."GradePoint";
1284	$subjectmarkHistoryObj->$gradePointVar = $markHistoryStatus->gradePoint;
1285
1286	$creditGradePointVar = $typeVariable."CreditGradePoint";
1287	$subjectmarkHistoryObj->$creditGradePointVar = $markHistoryStatus->creditGradePoint;
1288
1289	$isFailedVar = $typeVariable."IsFailed";
1290	$subjectmarkHistoryObj->$isFailedVar = $markHistoryStatus->isFailed;
1291	}
1292
1293	//for getting gracemark, revaluation, moderation - gradepoints and marks
1294	foreach ($markHistory->markType as $typeKey => $subjectMarkType){
1295
1296	$typeVariable = "";
1297	if($typeKey == "REVALUATION"){
1298	$typeVariable = "revaluation";
1299	}
1300	else if($typeKey == "GRACEMARK"){
1301	$typeVariable = "graceMark";
1302	}
1303	else if($typeKey == "MODERATION"){
1304	$typeVariable = "moderation";
1305	}
1306	if( $typeVariable ){
1307	$markVar = $typeVariable."Mark";
1308	if($typeKey == "GRACEMARK"){
1309	$markVar = "graceMark";
1310	}
1311	$subjectmarkHistoryObj->$markVar = $subjectMarkType->mark;
1312	if($typeKey == "GRACEMARK" \|\| $typeKey == "MODERATION"){
1313	$subjectMarkType->mark += $subjectmarkHistoryObj->externalMarkObtainedInExam;
1314	}
1315	$markHistoryStatus = $this->getStudentSubjectGradeDetailsForMarkHistory($request, $subject, $semId, $subjectMarkType);
1316
1317
1318	if ( $markHistoryStatus ){
1319	$gradeVar = $typeVariable."Grade";
1320	$subjectmarkHistoryObj->$gradeVar = $markHistoryStatus->letterGrade;
1321
1322	$gradePointVar = $typeVariable."GradePoint";
1323	$subjectmarkHistoryObj->$gradePointVar = $markHistoryStatus->gradePoint;
1324
1325	$creditGradePointVar = $typeVariable."CreditGradePoint";
1326	$subjectmarkHistoryObj->$creditGradePointVar = $markHistoryStatus->creditGradePoint;
1327
1328	$isFailedVar = $typeVariable."IsFailed";
1329	$subjectmarkHistoryObj->$isFailedVar = $markHistoryStatus->isFailed;
1330	}
1331	}
1332	}
1333
1334	$subjectmarkHistory[] = $subjectmarkHistoryObj;
1335	}
1336	else {
1337	$subjectmarkHistoryObj = new \stdClass();
1338	$subjectmarkHistoryObj->examMarkType = $markHistoryType;
1339	$subjectmarkHistoryObj->examRegId = $markHistory->examRegId;
1340	$subjectmarkHistoryObj->examId = $markHistory->examId;
1341	$subjectmarkHistoryObj->externalMark = $markHistory->mark;
1342	$subjectmarkHistoryObj->externalMaxMark = $subject->externalMaxMark;
1343	$subjectmarkHistoryObj->internalMark = $subject->internalMark;
1344	$subjectmarkHistoryObj->isInternalNull = $subject->isInternalNull;
1345	$subjectmarkHistoryObj->internalAttendanceStatus = $subject->isInternalAbsent?"ABSENT":"PRESENT";
1346	$subjectmarkHistoryObj->internalGrade = $subject->internalGrade;
1347	$subjectmarkHistoryObj->internalGradePoint = $subject->internalGradePoint;
1348
1349	$externalGrade = $this->getGradeByPercentage((($subjectmarkHistoryObj->externalMark+$subject->graceMark)/$subjectmarkHistoryObj->externalMaxMark)*$maxGradePercent, $gradeDetails[$subjectId]);
1350	$externalGrade->gradePoint = $student->isPG ? $markHistory->externalGradePoint : $externalGrade->gradePoint;
1351	$subjectmarkHistoryObj->externalGrade = $externalGrade->letterGrade;
1352	$subjectmarkHistoryObj->externalGradePoint = $externalGrade->gradePoint ?? 0;
1353
1354	$subjectmarkHistoryObj->markObtained = $subjectmarkHistoryObj->externalMark+$subject->graceMark;
1355	$subjectmarkHistoryObj->totalMark = $subject->internalMaxMark + $subject->externalMaxMark;
1356	$subjectmarkHistoryObj->percentage = ($subjectmarkHistoryObj->markObtained/$subjectmarkHistoryObj->totalMark) * 100;
1357
1358	$percentageObtainedInternal = round(($maxGradePercent * $subject->internalMark / $subject->internalMaxMark), 2);
1359	$percentageObtainedExternal = round(($maxGradePercent * $subjectmarkHistoryObj->externalMark / $subjectmarkHistoryObj->externalMaxMark), 2);
1360	if($student->batchStartYear > 2018 && $subject->isInternal && $subject->isExternal){
1361	$subjectmarkHistoryObj->wgpa = ($percentageObtainedInternal + (4 * $percentageObtainedExternal)) / $subject->maxGradePoint;
1362	$subjectmarkHistoryObj->wgpa = round($subjectmarkHistoryObj->wgpa, 2) ?? 0;
1363	}else if ($subject->isInternal && $subject->isExternal) {
1364	$subjectmarkHistoryObj->wgpa = ($percentageObtainedInternal + (3 * $percentageObtainedExternal)) / $subject->maxGradePoint;
1365	$subjectmarkHistoryObj->wgpa = round($subjectmarkHistoryObj->wgpa, 2) ?? 0;
1366	}
1367	else if ($subject->isInternal){
1368	$subjectmarkHistoryObj->wgpa = round($percentageObtainedInternal, 2) ?? 0;
1369	}
1370	else if ($subject->isExternal){
1371	$subjectmarkHistoryObj->wgpa = round($percentageObtainedExternal, 2) ?? 0;
1372	}
1373
1374	$grade = $this->getGradeByPercentage($subjectmarkHistoryObj->percentage * $maxGradePercent/100, $gradeDetails[$subjectId]);
1375	$subjectmarkHistoryObj->creditxMark = $subject->credit * $subjectmarkHistoryObj->markObtained;
1376	$subjectmarkHistoryObj->grade = $grade->letterGrade;
1377	$subjectmarkHistoryObj->class = $grade->className;
1378	$subjectmarkHistoryObj->percentageObtainedExternal = $percentageObtainedExternal;
1379	$subjectmarkHistoryObj->percentageObtainedInternal = $percentageObtainedInternal;
1380	$subjectmarkHistoryObj->gradePoint = $grade->gradePoint ?? 0;
1381	$subjectmarkHistoryObj->creditGradePoint = $subject->credit * $subjectmarkHistoryObj->gradePoint ;
1382	$subjectmarkHistoryObj->examMonth = $markHistory->month;
1383	$subjectmarkHistoryObj->examYear = $markHistory->year;
1384	$subjectmarkHistoryObj->attendanceStatus = $markHistory->externalAttendanceStatus;
1385	$subjectmarkHistoryObj->resultStatus = $markHistory->isFailed ? "FAILED" : "PASSED";
1386	$subjectmarkHistoryObj->markNeededToPass = $markHistory->isFailed ? $subject->externalPassMark - $subjectmarkHistoryObj->externalMark : 0;
1387	$subjectmarkHistoryObj->markNeededToPass = abs($subjectmarkHistoryObj->markNeededToPass);
1388	$subjectmarkHistoryObj->examName = trim($markHistory->name);
1389	$subjectmarkHistoryObj->isInternal = $subject->isInternal;
1390	$subjectmarkHistoryObj->excludeSubjectFromTotal = $subject->excludeSubjectFromTotal;
1391	$subjectmarkHistoryObj->isExternal = $subject->isExternal;
1392	$subjectmarkHistory[] = $subjectmarkHistoryObj;
1393	}
1394	}
1395
1396	$subject->consolidated->markHistory = $subjectmarkHistory;
1397	$subject->consolidated->status = $subject->isFailed ? "FAILED" : "PASSED";
1398
1399	$subjectMarkDetails = new \stdClass();
1400	$subjectMarkDetails->code = $subject->subjectName;
1401	$subjectMarkDetails->syllabusCode = $subject->syllabusCode;
1402	$subjectMarkDetails->priority = $subject->subjectPriority;
1403	$subjectMarkDetails->categoryId = $subject->subjectCatId;
1404	$subjectMarkDetails->categoryName = $subject->subjectCatName;
1405	$subjectMarkDetails->categoryCode = $subject->subjectCatCode;
1406	$subjectMarkDetails->isInternal = $subject->isInternal;
1407	$subjectMarkDetails->excludeSubjectFromTotal = $subject->excludeSubjectFromTotal;
1408	$subjectMarkDetails->internalMark = $subject->internalMark;
1409	$subjectMarkDetails->isInternalNull = $subject->isInternalNull;
1410	$subjectMarkDetails->internalAttendanceStatus = $subject->isInternalAbsent?"ABSENT":"PRESENT";
1411	$subjectMarkDetails->internalMaxMark = $subject->internalMaxMark;
1412	$subjectMarkDetails->graceMark = $subject->graceMark;
1413
1414	$subjectMarkDetails->internalGrade = $subject->letterGrade;
1415	$subjectMarkDetails->internalGradePoint = $subject->gradePoint;
1416
1417	$subjectMarkDetails->isInternalFailed = $subject->isInternalFailed;
1418	$subjectMarkDetails->internalAttendance = $subject->isInternalAbsent?"ABSENT":"PRESENT";
1419	$subjectMarkDetails->isExternal = $subject->isExternal;
1420	$subjectMarkDetails->externalMark = $subject->externalMark;
1421	$subjectMarkDetails->externalMaxMark = $subject->externalMaxMark;
1422
1423	$externalGrade = $this->getGradeByPercentage(($subjectMarkDetails->externalMark/$subjectMarkDetails->externalMaxMark)*$maxGradePercent, $gradeDetails[$subjectId]);
1424	$externalGrade->gradePoint = $student->isPG ? $subject->externalGradePoint : $externalGrade->gradePoint;
1425	$subjectMarkDetails->externalGrade = $externalGrade->letterGrade;
1426	$subjectMarkDetails->externalGradePoint = $externalGrade->gradePoint;
1427
1428	$subjectMarkDetails->isExternalFailed = $subject->isExternalFailed;
1429	$subjectMarkDetails->maxGradePercent = $subject->maxGradePercent;
1430	$subjectMarkDetails->maxGradePoint = $subject->maxGradePoint;
1431	$subjectMarkDetails->examMonth = $subject->examMonth;
1432	$subjectMarkDetails->examYear = $subject->examYear;
1433	$subjectMarkDetails->monthYearOfPassing = $subject->monthYearOfPassing;
1434	$subjectMarkDetails->isTheory = $subject->isTheory;
1435	$subjectMarkDetails->supplyAttemptCount = $subject->supplyAttemptCount;
1436	$subjectMarkDetails->credit = $subject->credit;
1437	$subjectMarkDetails->creditGradePoint = $subject->creditGradePoint;
1438	$subjectMarkDetails->markNeededToPass = abs($subject->markNeededToPass);
1439	$subjectMarkDetails->gradePoint = $subject->gradePoint;
1440
1441	$percentageObtainedInternal = round(($maxGradePercent * $subject->internalMark / $subject->internalMaxMark), 2);
1442	$percentageObtainedExternal = round(($maxGradePercent * ($subjectMarkDetails->externalMark + $subject->graceMark) / $subjectMarkDetails->externalMaxMark), 2);
1443	if($student->batchStartYear > 2018 && $subject->isInternal && $subject->isExternal){
1444	$subjectMarkDetails->wgpa = ($percentageObtainedInternal + (4 * $percentageObtainedExternal)) / $subject->maxGradePoint;
1445	$subjectMarkDetails->wgpa = round($subjectMarkDetails->wgpa, 2) ?? 0;
1446	}else if ($subject->isInternal && $subject->isExternal) {
1447	$subjectMarkDetails->wgpa = ($percentageObtainedInternal + (3 * $percentageObtainedExternal)) / $subject->maxGradePoint;
1448	$subjectMarkDetails->wgpa = round($subjectMarkDetails->wgpa, 2) ?? 0;
1449	}
1450	else if ($subject->isInternal){
1451	$subjectMarkDetails->wgpa = round($percentageObtainedInternal, 2) ?? 0;
1452	}
1453	else if ($subject->isExternal){
1454	$subjectMarkDetails->wgpa = round($percentageObtainedExternal, 2) ?? 0;
1455	}
1456
1457	$subjectMarkDetails->grade = $subject->grade;
1458	$subjectMarkDetails->class = $subject->className ? $subject->className : "";
1459	$subjectMarkDetails->creditxMark = $subject->creditxMark;
1460	$subjectMarkDetails->markObtained = $subject->totalMark;
1461	$subjectMarkDetails->totalMarks = $subject->totalMaxMark;
1462	$subjectMarkDetails->isFailed = $subject->isFailed;
1463	$subjectMarkDetails->percentageObtainedExternal = $percentageObtainedExternal;
1464	$subjectMarkDetails->percentageObtainedInternal = $percentageObtainedInternal;
1465	$subjectMarkDetails->internalPassPercentage = $subject->internalPassCriteria;
1466	$subjectMarkDetails->externalPassPercentage = $subject->externalPassCriteria;
1467	$subjectMarkDetails->aggregatePassPercentage = $subject->overallPassCriteria;
1468	$subjectMarkDetails->attendance = $subject->externalAttendanceStatus;
1469
1470	$subjectMarkDetails->latestExamYear = date("Y",strtotime("01 $subject->monthYearOfPassing"));
1471	$subjectMarkDetails->latestExamMonth = date("m",strtotime("01 $subject->monthYearOfPassing"));
1472	$subjectMarkDetails->latestExamType = $subject->examRegTypeOfPassing;
1473	$subjectMarkDetails->attendanceStatus = $subject->isAbsent ;
1474	$subjectMarkDetails->internalMark = $subject->internalMark;
1475	$subjectMarkDetails->internalMaxMark = $subject->internalMaxMark;
1476	$subjectMarkDetails->internalResultStatus = $subject->isInternalFailed ? "FAILED" : "PASSED";
1477	$subjectMarkDetails->externalMark = $subject->externalMark;
1478	$subjectMarkDetails->externalMaxMark = $subject->externalMaxMark;
1479	$subjectMarkDetails->externalResultStatus = $subject->isExternalFailed ? "FAILED" : "PASSED";
1480	$subjectMarkDetails->maxGradePoint = $subject->maxGradePoint;
1481	$subjectMarkDetails->maxGradePercentage = $subject->maxGradePercent;
1482	$subject->consolidated->markDetails = $subjectMarkDetails;
1483
1484	$semMarks->consolidated->wgpa += $subjectMarkDetails->wgpa;
1485	}
1486	$totalCreditxGradePoint = array_sum(array_column($semMarks->subject,'creditGradePoint'));
1487	$semMarks->sgpa = $totalCreditxGradePoint / $semMarks->credit;
1488	$semMarks->creditGradePoint = $totalCreditxGradePoint;
1489	$semGradeObject = new \stdClass();
1490	$semGradeObject->groupId = $request->groupId;
1491	$semGradeObject->academicTermId = $semId;
1492	$semesterGradeDetials = $this->getSemesterGradeDetials($semGradeObject, round(($semMarks->isFailed ? 0 : $semMarks->sgpa), 2));
1493	$semMarks->grade = $semesterGradeDetials->letterGrade;
1494	$semMarks->class = $semesterGradeDetials->className;
1495
1496	$semMarks->consolidated->noOfArrears = $semMarks->arrears ? $semMarks->arrears : 0;
1497	$semMarks->consolidated->supplyAttemptCount = $semMarks->supplyAttemptCount ? $semMarks->supplyAttemptCount : 0;
1498	$semMarks->consolidated->totalMarks = $semMarks->totalMarks ? $semMarks->totalMarks : 0;
1499	$semMarks->consolidated->percentage = ($semMarks->totalMarks / $semMarks->examTotalMarks) * 100;
1500	$semMarks->consolidated->grade = $semMarks->grade ? $semMarks->grade : "";
1501	$semMarks->consolidated->class = $semMarks->class ? $semMarks->class : "";
1502	$semMarks->consolidated->sgpa = $student->batchStartYear > 2018 ? round($semMarks->sgpa, 3) : round($semMarks->sgpa, 2);
1503
1504	// without Gracemark
1505	$semMarks->consolidated->sgpaWithoutGracemark = $studentDetailsWithoutGracemark->batchStartYear > 2018 ? round($studentDetailsWithoutGracemark->semMarks[$semId]->sgpa, 3) : round($studentDetailsWithoutGracemark->semMarks[$semId]->sgpa, 2);
1506	$semMarks->consolidated->rawSgpaWithoutGracemark = $studentDetailsWithoutGracemark->semMarks[$semId]->rawSgpa;
1507
1508	$semMarks->consolidated->rawSgpa = $semMarks->rawSgpa;
1509	$semMarks->consolidated->status = $semMarks->isFailed ? "FAILED" : "PASSED";
1510
1511	$semMarkDetails = new \stdClass();
1512	$semMarkDetails->noOfChancesTaken = max(array_column(array_column($semMarks->subject,"consolidated"),"noOfChancesTaken"));
1513	$semMarkDetails->id = $semMarks->consolidated->academicTermId;
1514	$semMarkDetails->name = $semMarks->semName;
1515	$semMarkDetails->credit = $semMarks->credit;
1516	$semMarkDetails->creditGradePoint = $semMarks->creditGradePoint;
1517	$semMarkDetails->latestExamMonth = $semMarks->lastExamMonth;
1518	$semMarkDetails->latestExamYear = $semMarks->lastExamYear;
1519	$semMarkDetails->latestExamType = $semMarks->lastExamReg;
1520	$semMarkDetails->arrearCount = $semMarks->consolidated->noOfArrears;
1521	$semMarkDetails->supplyAttemptCount = $semMarks->consolidated->supplyAttemptCount;
1522	$semMarkDetails->sgpa = $semMarks->consolidated->sgpa;
1523	$semMarkDetails->rawSgpa = $semMarks->consolidated->rawSgpa;
1524	$semMarkDetails->wgpa = $semMarks->consolidated->wgpa ?? 0;
1525	$semMarkDetails->gradePoint = $semMarks->gradePoint;
1526	$semMarkDetails->grade = $semMarks->consolidated->grade;
1527	$semMarkDetails->class = $semMarks->consolidated->class;
1528	$semMarkDetails->percentage = $semMarks->consolidated->percentage;
1529	$semMarkDetails->creditxMark = $semMarks->creditxMark;
1530	$semMarkDetails->markObtained = $semMarks->totalMarks;
1531	$semMarkDetails->totalMarks = $semMarks->examTotalMarks;
1532	$semMarkDetails->passPercentage = $student->aggregatePassCriteria;
1533	$semMarkDetails->isFailed = $semMarks->isFailed;
1534	$semMarks->consolidated->markDetails = $semMarkDetails;
1535	if ($student->isPG == 1) {
1536	$semMarks->creditGradePoint = $semMarks->consolidated->sgpa * $semMarks->credit;
1537	}
1538	}
1539
1540	$student->creditGradePoint = array_sum(array_column($student->semMarks,"creditGradePoint"));
1541	$student->credit = array_sum(array_column($student->semMarks,"credit"));
1542	// $student->cgpa = $student->creditGradePoint / $student->credit;
1543	$studentObj->cgpa = $student->totalSgpaCreditGradePoint / $student->totalSgpaCredits;
1544	$student->rawCgpa = $student->cgpa;
1545	$student->cgpa = round($student->cgpa, 2);
1546
1547	$percentageGrade = $this->getGradeByPercentage($student->cgpa, $cgpaGradeDetails);
1548	if (!empty ($percentageGrade)) {
1549	$student->grade = $percentageGrade->letterGrade;
1550	$student->class = $percentageGrade->className;
1551	}
1552	$student->consolidated->noOfArrears = $student->totalArrears ? $student->totalArrears : 0;
1553	$student->consolidated->supplyAttemptCount = $student->supplyAttemptCount ? $student->supplyAttemptCount : 0;
1554	$student->consolidated->totalMark = $student->totalMarkObtained ? $student->totalMarkObtained : 0;
1555	$student->consolidated->percentage = ($student->totalMarkObtained / $student->totalMark) * 100;
1556	$student->consolidated->grade = $student->grade ? $student->grade : "";
1557	$student->consolidated->cgpa = $student->cgpa ? $student->cgpa : 0;
1558	$student->consolidated->rawCgpa = $student->rawCgpa ?? 0;
1559
1560	// without gracemark
1561	$student->consolidated->cgpaWithoutGracemark = $studentDetailsWithoutGracemark->cgpa;
1562	$student->consolidated->rawCgpaWithoutGracemark = $studentDetailsWithoutGracemark->rawCgpa;
1563
1564	$student->consolidated->class = $student->class ? $student->class : "";
1565	$student->consolidated->status = $student->isFailed ? "FAILED" : "PASSED";
1566
1567	$studentMarkDetails = new \stdClass();
1568	$studentMarkDetails->noOfChancesTaken = max(array_column(array_column(array_column($student->semMarks,"consolidated"),"markDetails"),"noOfChancesTaken"));
1569	$studentMarkDetails->credit = $student->credit;
1570	$studentMarkDetails->creditGradePoint = $student->creditGradePoint;
1571	$studentMarkDetails->latestExamYear = $student->lastExamYear;
1572	$studentMarkDetails->latestExamMonth = $student->lastExamMonth;
1573	$studentMarkDetails->latestExamType = $student->lastExamReg;
1574	$studentMarkDetails->totalMaxMark = $student->totalMark;
1575	$studentMarkDetails->arrearCount = $student->totalArrears;
1576	$studentMarkDetails->supplyAttemptCount = $student->supplyAttemptCount;
1577	$studentMarkDetails->credit = $student->credit;
1578	$studentMarkDetails->creditGradePoint = $student->creditGradePoint;
1579	$studentMarkDetails->markObtained = $student->totalMarkObtained;
1580	$studentMarkDetails->totalMarks = $student->totalMark;
1581	$studentMarkDetails->isFailed = $student->isFailed;
1582	$studentMarkDetails->cgpa = $student->cgpa;
1583	$studentMarkDetails->rawCgpa = $student->rawCgpa;
1584	$studentMarkDetails->cgpaWithoutGracemark = $studentDetailsWithoutGracemark->cgpa;
1585	$studentMarkDetails->rawCgpaWithoutGracemark = $studentDetailsWithoutGracemark->rawCgpa;
1586	// $studentMarkDetails->wgp = $student->wgp;
1587	$studentMarkDetails->wgpa = $student->wgpa ?? 0;
1588	$studentMarkDetails->gradePoint = $student->gradePoint;
1589	$studentMarkDetails->creditxMark = $student->creditxMark;
1590	$studentMarkDetails->grade = $student->grade;
1591	$studentMarkDetails->class = $student->class;
1592	$studentMarkDetails->creditxMark = $student->creditxMark;
1593
1594	$student->consolidated->markDetails = $studentMarkDetails;
1595	}
1596	return $studentDetails;
1597	}
1598	protected function getStudentSubjectGradeDetailsForMarkHistory($request, $subject, $semId, $markHistory)
1599	{
1600	$schemeType = "PERCENTAGE";
1601	$passCriteriaArrayOfSubject = GradeSchemeService::getInstance()->getSubjectPassCriteriaByAcademicPaperSubject($subject->id, $schemeType);
1602
1603	$searchRequest = new \stdClass();
1604	$searchRequest->groupId = $request->groupId;
1605	$searchRequest->academicTermId = $semId;
1606	$searchRequest->academicPaperSubjectId = $subject->academicPaperSubjectId;
1607	$subjectGradeSchemeArray = GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest);
1608	$gradeDetails = current($subjectGradeSchemeArray)->grades;
1609	$maxGradePercent = $gradeDetails[0]->rangeTo;
1610
1611	$checkPassPercentCriteria = new \stdClass();
1612	$checkPassPercentCriteria->isInternal = $subject->isInternal;
1613	$checkPassPercentCriteria->internalMaxMark = $subject->internalMaxMark;
1614
1615	$checkPassPercentCriteria->isExternal = $subject->isExternal;
1616	$checkPassPercentCriteria->externalMaxMark = $subject->externalMaxMark;
1617
1618	$checkPassPercentCriteria->internalMark = round($subject->internalMark);
1619	// $checkPassPercentCriteria->considerOverallPassCriteriaOnly = $considerOverallPassCriteriaOnly;
1620	$checkPassPercentCriteria->passPercentConfig = $passCriteriaArrayOfSubject;
1621
1622	$checkPassPercentCriteria->externalMark = $markHistory->mark;
1623	$isFailedForTheSubject = $this->checkIsFailedByPassPercentCriteria ( $checkPassPercentCriteria );
1624
1625	if ( $isFailedForTheSubject ) {
1626	$percentageObtained = 0;
1627	// $semesterGradePercentObtained = 0;
1628	}
1629	else {
1630	$percentageObtained = $maxGradePercent * (round($subject->internalMark) + $markHistory->mark) / ($subject->externalMaxMark + $subject->internalMaxMark);
1631	$percentageObtained = round($percentageObtained, 2);
1632
1633	// $semesterGradePercentObtained = $maxSemesterGradePercent * $studentExamTotal / $examTotal;
1634	// $semesterGradePercentObtained = round($semesterGradePercentObtained, 2);
1635	}
1636	$grade = $this->getGradeByPercentage($percentageObtained, $gradeDetails);
1637	if (!empty ($grade)) {
1638	$creditGradePoint = ($subject->credit * $grade->gradePoint);
1639	if ($grade->failStatus == 1) {
1640	$isFailedForTheSubject = 1;
1641	}
1642	}
1643	$grade->isFailed = $isFailedForTheSubject;
1644	$grade->creditGradePoint = $creditGradePoint;
1645	return $grade;
1646	}
1647	protected function getGradeByPercentage($percentage, $gradeDetails)
1648	{
1649	foreach ($gradeDetails as $grade) {
1650	if ($grade->rangeFrom <= $percentage && $grade->rangeTo >= $percentage) {
1651	return $grade;
1652	}
1653	}
1654	return null;
1655	}
1656	protected function getStudentImprovementExamDetailsForThisExam($academicPaperSubjectId, $studentId, $improveExamDetails)
1657	{
1658	$examMark = null;
1659	foreach ($improveExamDetails as $improveExam) {
1660	if ($improveExam->subject->academicPaperSubjectId == $academicPaperSubjectId) {
1661	foreach ($improveExam->studentMarks as $studentMarks) {
1662	if ($studentMarks->student->studentId == $studentId) {
1663	$examMark = $studentMarks;
1664	$examMark->assessmentId = $improveExam->assessmentId;
1665	$examMark->oeExamId = $improveExam->oeExamId;
1666	$examMark->examRegistrations = $improveExam->examRegistrations;
1667	}
1668	}
1669	}
1670	}
1671	return $examMark;
1672	}
1673	protected function getStudentExamDetails($assessmentId, $studentId, $examDetails)
1674	{
1675	$examMark = null;
1676	foreach ($examDetails as $exam) {
1677	if ($exam->assessmentId == $assessmentId) {
1678	foreach ($exam->studentMarks as $studentMarks) {
1679	if ($studentMarks->student->studentId == $studentId) {
1680	$examMark = $studentMarks;
1681	$examMark->assessmentId = $exam->assessmentId;
1682	$examMark->examRegistrations = $exam->examRegistrations;
1683	}
1684	}
1685	}
1686	}
1687	return $examMark;
1688	}
1689	public function getSupplyMarkHistory ($academicPaperSubjectId, $studentId, $supplyExamDetails) {
1690	$supplyExamMarks = [];
1691	foreach ($supplyExamDetails as $supplyExam) {
1692	if ($supplyExam->subject->academicPaperSubjectId == $academicPaperSubjectId) {
1693	foreach ($supplyExam->studentMarks as $studentMarks) {
1694	if ($studentMarks->student->studentId == $studentId) {
1695	$supplyExamMark = new \stdClass();
1696	$supplyExamMark->id = $supplyExam->examRegistrations->examRegistrationId;
1697	$supplyExamMark->assessmentId = $supplyExam->assessmentId;
1698	$supplyExamMark->oeExamId = $supplyExam->oeExamId;
1699	$supplyExamMark->mark = $studentMarks->externalMark;
1700	$supplyExamMark->externalAttendanceStatus = $studentMarks->externalAttendanceStatus;
1701	$supplyExamMark->examMonth = $supplyExam->examRegistrations->month;
1702	$supplyExamMark->examYear = $supplyExam->examRegistrations->year;
1703	$supplyExamMark->supplyName = $supplyExam->examRegistrations->name;
1704	$supplyExamMarks[] = $supplyExamMark;
1705	break;
1706	}
1707	}
1708	}
1709	}
1710	return $supplyExamMarks;
1711	}
1712	public function checkIsFailedByPassPercentCriteria ( $checkPassPercentCriteria ) {
1713	$studentExamTotal = 0;
1714	$examTotal = 0;
1715	$isFailed = 0;
1716
1717	$internalPassCriteria = $externalPassCriteria = $overallPassCriteria = null;
1718	if ($checkPassPercentCriteria->passPercentConfig->internalPassCriteria) {
1719	$internalPassCriteria = (float) $checkPassPercentCriteria->passPercentConfig->internalPassCriteria;
1720	}
1721	if ($checkPassPercentCriteria->passPercentConfig->externalPassCriteria) {
1722	$externalPassCriteria = (float) $checkPassPercentCriteria->passPercentConfig->externalPassCriteria;
1723	}
1724	if ($checkPassPercentCriteria->passPercentConfig->overallPassCriteria) {
1725	$overallPassCriteria = (float) $checkPassPercentCriteria->passPercentConfig->overallPassCriteria;
1726	}
1727
1728	if ($checkPassPercentCriteria->isInternal) {
1729	$studentExamTotal = round($checkPassPercentCriteria->internalMark);
1730	$examTotal = $checkPassPercentCriteria->internalMaxMark;
1731	if (!empty ($internalPassCriteria)) {
1732	$internalPercent = $checkPassPercentCriteria->internalMaxMark ? (100 * $checkPassPercentCriteria->internalMark / $checkPassPercentCriteria->internalMaxMark) : 0;
1733	if ( $checkPassPercentCriteria->considerOverallPassCriteriaOnly == 0 ) {
1734	$isFailed = $internalPassCriteria <= $internalPercent ? $isFailed : 1;
1735	}
1736	}
1737	}
1738	if ($checkPassPercentCriteria->isExternal) {
1739	$studentExamTotal += round($checkPassPercentCriteria->externalMark);
1740	$examTotal += $checkPassPercentCriteria->externalMaxMark;
1741	if (!empty ($externalPassCriteria)) {
1742	$externalPercent = $checkPassPercentCriteria->externalMaxMark ? (100 *
1743	$checkPassPercentCriteria->externalMark / $checkPassPercentCriteria->externalMaxMark) : 0;
1744	if ( $checkPassPercentCriteria->considerOverallPassCriteriaOnly == 0 ) {
1745	$isFailed = $externalPassCriteria <= $externalPercent ? $isFailed : 1;
1746	}
1747	}
1748	}
1749
1750	if (!empty ($overallPassCriteria)) {
1751	if (empty($checkPassPercentCriteria->studentExamTotal))
1752	$overallPercent = $examTotal ? 100 * $studentExamTotal / $examTotal : 0;
1753	else
1754	$overallPercent = $checkPassPercentCriteria->totalMaxMark ? 100 * $checkPassPercentCriteria->studentExamTotal / $checkPassPercentCriteria->totalMaxMark : 0;
1755	$isFailed = $overallPassCriteria <= $overallPercent ? $isFailed : 1;
1756	}
1757
1758	return $isFailed;
1759	}
1760	public function getSemesterGradeDetials($searchReq, $sgpa)
1761	{
1762	$searchRequest = new \stdClass();
1763	$searchRequest->groupId = $searchReq->groupId;
1764	$searchRequest->academicTermId = $searchReq->academicTermId;
1765	$searchRequest->requestType = "SEMESTER";
1766	$semesterGradeDetails = reset(GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest))->grades;
1767	$semMarkGrade = $this->getGradeByPercentage($sgpa, $semesterGradeDetails);
1768	return $semMarkGrade;
1769	}
1770
1771	/**
1772	* Get Students supplementary mark report
1773	*/
1774	public function getStudentsSupplyMarkReport ( $request, $supplyExamDetails = null ) {
1775	$students = [];
1776	$subjects = [];
1777	$passCriteriaArray = [];
1778	$includeImprovement = false;
1779	$includeImprovement = $request->includeImprovement ?? false;
1780
1781	if( empty ( $supplyExamDetails ) ){
1782	;
1783	$request->examRegistrationType = ExamRegistrationTypeConstants::SUPPLEMENTARY;
1784	$supplyExamDetails = StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($request);
1785	}
1786	if ( !empty ( $supplyExamDetails ) ) {
1787	$examMonth = current($supplyExamDetails)->examRegistrations->month;
1788	$examYear = current($supplyExamDetails)->examRegistrations->year;
1789
1790
1791	$request->examYear = $examYear;
1792	$request->examMonth = $examMonth;
1793
1794	$studentObj = null;
1795	/ Getting the mark details of that batch /
1796	if ( empty ( $studentObj ) ) {
1797	$request->examRegistrationType = ExamType::REGULAR;
1798	$request->examRegistrationId = "";
1799	$examDetails = StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($request);
1800	$request->supplementaryYearUpperLimit = $examYear;
1801	$request->supplementaryMonthUpperLimit = $examMonth;
1802	$studentObj = $this->getStudentsOverallMarkReport($request, $examDetails);
1803	$request->supplementaryYearUpperLimit = '';
1804	$request->supplementaryMonthUpperLimit = '';
1805	}
1806	if ( $request->considerModerationMark ) {
1807	$request->examRegistrationType = "";
1808	$request->requestType = "MODERATION";
1809	$moderationMarkDetails = StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($request);
1810	}
1811	if ( $request->considerGraceMark ) {
1812	$request->examRegistrationType = "";
1813	$request->requestType = "GRACEMARK";
1814	$graceMarkDetails = StudentsOverAllMarkReportService::getInstance()->getStudentExamMarkDetails($request);
1815	}
1816
1817	foreach ($supplyExamDetails as $examDetail) {
1818	$totalMaxMark = 0;
1819	$academicPaperSubjectId = $examDetail->subject->academicPaperSubjectId;
1820	$batchId = $examDetail->batch->id;
1821	$academicTermId = $examDetail->semester->academicTermId;
1822	$courseTypeId = $examDetail->batch->courseTypeId;
1823	$regularSubjectDetails = $studentObj[$request->studentId]->semMarks[$academicTermId]->subject[$academicPaperSubjectId];
1824
1825	$schemeType = "PERCENTAGE";
1826	$passCriteriaArray[$academicPaperSubjectId] = GradeSchemeService::getInstance()->getSubjectPassCriteriaByAcademicPaperSubject($academicPaperSubjectId, $schemeType);
1827
1828
1829	$searchRequest = new \stdClass();
1830	$searchRequest->groupId = $request->groupId;
1831	$searchRequest->academicTermId = $academicTermId;
1832	$searchRequest->academicPaperSubjectId = $examDetail->subject->academicPaperSubjectId;
1833	$subjectGradeSchemeArray = GradeSchemeService::getInstance()->getAllSubjectGradeSchemesByRequest($searchRequest);
1834	$gradeDetails = current($subjectGradeSchemeArray)->grades;
1835	$maxGradePercent = $gradeDetails[0]->rangeTo;
1836
1837	$considerOverallPassCriteriaOnly = 0;
1838	if ( $examDetail->subject->subjectType == ExamSubjectTypeConstants::OPEN_ELECTIVE \|\|
1839	$examDetail->subject->subjectType == ExamSubjectTypeConstants::FOUNDATION_COURSE \|\|
1840	$examDetail->subject->subjectType == ExamSubjectTypeConstants::TERM_PAPER ) {
1841	$considerOverallPassCriteriaOnly = 1;
1842	}
1843	/ Object checking whether a student is passed for a subject by the pass percent criteria /
1844	$checkPassPercentCriteria = new \stdClass();
1845	$checkPassPercentCriteria->isInternal = $examDetail->subject->isInternal;
1846	$checkPassPercentCriteria->internalMaxMark = $examDetail->internalMaxMark;
1847
1848	$checkPassPercentCriteria->isExternal = $examDetail->subject->isExternal;
1849	$checkPassPercentCriteria->externalMaxMark = $examDetail->externalMaxMark;
1850
1851	$checkPassPercentCriteria->considerOverallPassCriteriaOnly = $considerOverallPassCriteriaOnly;
1852
1853	/ For getting the supplementary subject details /
1854	$subjects[$academicPaperSubjectId]->id = $academicPaperSubjectId;
1855	$subjects[$academicPaperSubjectId]->subjectOrder = $examDetail->subject->subjectOrder;
1856
1857	$subjects[$academicPaperSubjectId]->subjectName = $examDetail->subject->subjectName;
1858	$subjects[$academicPaperSubjectId]->subjectDesc = filter_var(html_entity_decode($examDetail->subject->subjectDesc), FILTER_UNSAFE_RAW, FILTER_FLAG_STRIP_LOW \| FILTER_FLAG_STRIP_HIGH);
1859	$subjects[$academicPaperSubjectId]->syllabusCode = $examDetail->subject->syllabusCode;
1860	$subjects[$academicPaperSubjectId]->subjectCatId = $examDetail->subject->subjectCatId;
1861
1862	$subjects[$academicPaperSubjectId]->internalMaxMark = $examDetail->internalMaxMark;
1863	$subjects[$academicPaperSubjectId]->externalMaxMark = $examDetail->externalMaxMark;
1864	$subjects[$academicPaperSubjectId]->supplyAssessmentId= $examDetail->assessmentId;
1865	if ($examDetail->subject->isInternal == 1) {
1866	$totalMaxMark += $examDetail->internalMaxMark;
1867	}
1868	if ($examDetail->subject->isExternal == 1) {
1869	$totalMaxMark += $examDetail->externalMaxMark;
1870	}
1871	$subjects[$academicPaperSubjectId]->totalMaxMark = $totalMaxMark;
1872	$subjects[$academicPaperSubjectId]->excludeSubjectFromTotal = $examDetail->subject->excludeSubjectFromTotal;
1873	/ Subject details ends /
1874
1875	foreach ($examDetail->studentMarks as $studentMark) {
1876	$isFailed = null;
1877	$examTotal = 0;
1878	$studentExamTotal = 0;
1879	$studentId = $studentMark->student->studentId;
1880	if ( $request->considerRevaluation) {
1881	$revalRequest = new \stdClass();
1882	$revalRequest->studentId = $studentId;
1883	$revalRequest->assessmentId = $examDetail->assessmentId;
1884	$revalRequest->orderByHighestMark = 1;
1885	$studentRevaluationDetails = StudentsOverAllMarkReportService::getInstance()->getStudentFinalizedRevaluationMark($revalRequest);
1886	if($studentRevaluationDetails){
1887	$studentRevaluationDetail = current(current($studentRevaluationDetails)->students);
1888	if($studentRevaluationDetail->revaluationMark){
1889	$studentMark->externalMark = $studentRevaluationDetail->revaluationMark;
1890	}
1891	}
1892	}
1893	if ( $request->considerModerationMark ) {
1894	$studentModerationMark = $this->getStudentExamDetails($examDetail->assessmentId, $studentId, $moderationMarkDetails);
1895	if($studentModerationMark){
1896	$studentMark->externalMark += $studentModerationMark->externalMark;
1897	}
1898	}
1899	if ( $request->considerGraceMark ) {
1900	$studentGraceMark = $this->getStudentExamDetails($examDetail->assessmentId, $studentId, $graceMarkDetails);
1901	if($studentGraceMark){
1902	$studentMark->externalMark += $studentGraceMark->externalMark;
1903	}
1904	}
1905	$checkPassPercentCriteria->internalMark = round($studentMark->internalMark, 2 );
1906	$checkPassPercentCriteria->passPercentConfig = $passCriteriaArray[$academicPaperSubjectId];
1907	$checkPassPercentCriteria->externalMark = round ( $studentMark->externalMark, 2 );
1908
1909	$isFailed = $this->checkIsFailedByPassPercentCriteria ( $checkPassPercentCriteria );
1910	/ code ends /
1911
1912	$student = $students[$studentId];
1913	$studentSemMark = $student->semMarks[$academicTermId];
1914	$studentSubject = $studentSemMark->subject[$academicPaperSubjectId];
1915
1916	if (empty($studentSubject)){
1917	$studentSubject = json_decode(json_encode($studentObj[$studentId]->semMarks[$academicTermId]->subject[$academicPaperSubjectId]));
1918	unset($studentSubject->markHistory);
1919	}
1920	if (empty($studentSemMark)){
1921	$studentSemMark = json_decode(json_encode($studentObj[$studentId]->semMarks[$academicTermId]));
1922	unset($studentSemMark->subject);
1923	}
1924	if (empty($student)){
1925	$student = json_decode(json_encode($studentObj[$studentId]));
1926	unset($student->semMarks);
1927	}
1928
1929	$studentSemMark->supplyCredit = empty($studentSemMark->supplyCredit) ? 0 : $studentSemMark->supplyCredit;
1930
1931	$student->id = $studentId;
1932	$student->name = $studentMark->student->studentName;
1933	$student->regNo = $studentMark->student->regNo;
1934	$student->examRegType = $studentMark->studentExamRegType;
1935
1936	/ Subject's common details /
1937	$studentSubject->code = $examDetail->subject->subjectCode;
1938	$studentSubject->name = $examDetail->subject->subjectName;
1939	$studentSubject->desc = filter_var(html_entity_decode($examDetail->subject->subjectDesc), FILTER_UNSAFE_RAW, FILTER_FLAG_STRIP_LOW \| FILTER_FLAG_STRIP_HIGH);
1940	$studentSubject->syllabusCode = $examDetail->subject->syllabusCode;
1941	$studentSubject->subjectCatId = $examDetail->subject->subjectCatId;
1942	$studentSubject->excludeSubjectFromTotal = $examDetail->subject->excludeSubjectFromTotal;
1943	$studentSubject->credit = round ( $examDetail->subject->credit, 2 );
1944	$studentSubject->subjectOrder = $examDetail->subject->subjectOrder;
1945	/** Subject's common details ends here */
1946
1947	$studentSubject->id = $academicPaperSubjectId;
1948	$studentSubject->isExempted = $studentMark->isExempted;
1949	$studentSubject->isAbsent = $studentMark->externalAttendanceStatus;
1950
1951	$studentSubject->isInternal = $examDetail->subject->isInternal;
1952	$studentSubject->isInternalAbsent = $studentMark->internalAttendanceStatus;
1953	$studentSubject->isExternal = $examDetail->subject->isExternal;
1954	$studentSubject->supplyExamId = $examDetail->id;
1955
1956	if ( $examDetail->subject->isInternal == 1 ) {
1957	$internalMark = round ( $studentMark->internalMark, 2 );
1958	$internalMaxMark = round ( $examDetail->internalMaxMark, 2 );
1959
1960	$studentSubject->internalMark = $internalMark;
1961	$studentSubject->internalMaxMark = $internalMaxMark;
1962
1963	$studentExamTotal += $internalMark;
1964	$examTotal += $internalMaxMark;
1965	}
1966	if ( $examDetail->subject->isExternal == 1 ) {
1967	$externalMark = round ( $studentMark->externalMark, 2 );
1968	$externalMaxMark = round ( $examDetail->externalMaxMark, 2 );
1969
1970	$studentExamTotal += $externalMark;
1971	$examTotal += $externalMaxMark;
1972
1973	$studentSubject->externalMark = $externalMark;
1974	$studentSubject->graceMark = $regularSubjectDetails->graceMark;
1975	$studentSubject->externalMaxMark = $externalMaxMark;
1976	}
1977	$studentSubject->totalMark = $studentExamTotal;
1978
1979	if ( $isFailed ) {
1980	$percentageObtained = 0;
1981	} else {
1982	$percentageObtained = $maxGradePercent * $studentExamTotal / $examTotal;
1983	$percentageObtained = round($percentageObtained, 2);
1984	}
1985	$grade = $this->getGradeByPercentage($percentageObtained, $gradeDetails);
1986
1987	$internalMarkPer = $externalMarkPer = 0;
1988	if ($student->isPG == 1) {
1989	$x = 1;
1990
1991	if ($examDetail->subject->isInternal) {
1992	$internalMarkPer = round($maxGradePercent * $studentSubject->internalMark / $examDetail->internalMaxMark, 2);
1993	}
1994	if ($examDetail->subject->isExternal) {
1995	$externalMarkPer = round($maxGradePercent * $studentSubject->externalMark / $examDetail->externalMaxMark, 2);
1996	}
1997
1998	if ($examDetail->subject->isInternal && $examDetail->subject->isExternal) {
1999	$gradePoint = round((($x * $internalMarkPer) + ( ($maxGradePercent-$x) * $externalMarkPer ) ) / $maxGradePercent, 2);
2000	}
2001	else {
2002	$gradePoint = $internalMarkPer + $externalMarkPer;
2003	}
2004	if ($isFailed) {
2005	$gradePoint = 0;
2006	}
2007	$grade = $this->getGradeByPercentage($gradePoint, $gradeDetails);
2008	$grade->gradePoint = $gradePoint ?? 0;
2009	}
2010
2011	if (!empty ($grade)) {
2012	$creditGradePoint = ($examDetail->subject->credit * $grade->gradePoint);
2013	if ($grade->failStatus == 1) {
2014	$isFailed = 1;
2015	}
2016	$studentSubject->grade = $grade->letterGrade;
2017	$studentSubject->class = $grade->className;
2018	$studentSubject->gradePoint = round ( $grade->gradePoint, 2 );
2019	$studentSubject->creditGradePoint = round ( $creditGradePoint, 2 );
2020	$studentSubject->creditxMark = round ( $examDetail->subject->credit * $studentExamTotal, 2 );
2021	}
2022	else {
2023	$studentSubject->grade = "";
2024	$studentSubject->class = "";
2025	$studentSubject->gradePoint = 0;
2026	$studentSubject->creditGradePoint = 0;
2027	}
2028	$studentSubject->totalMaxMark = $examTotal;
2029
2030	$studentSubject->isFailed = $isFailed;
2031	$studentSubject->internalGradePoint = $internalMarkPer;
2032	$studentSubject->externalGradePoint = $externalMarkPer;
2033	$studentSemMark->isFailed = $isFailed ? 1 : (empty($studentSemMark->isFailed) ? 0 : $studentSemMark->isFailed);
2034	$studentSemMark->regularExamRegId = $examDetail->regularExamRegId;
2035	$studentSemMark->supplyCredit += $studentSubject->credit;
2036	$student->isFailed = $isFailed ? 1 : (empty($student->isFailed) ? 0 : $student->isFailed);
2037
2038	$studentSemMark->subject[$academicPaperSubjectId] = $studentSubject;
2039	$student->semMarks[$academicTermId] = $studentSemMark;
2040	$students[$studentId] = $student;
2041	}
2042	}
2043
2044	$completedStatus = "COMPLETED";
2045	$incompleteStatus = "INCOMPLETE";
2046	$failStatus = "FAIL";
2047
2048	foreach ( $students as $student ) {
2049	$sgpa = null;
2050	$studentId = $student->id;
2051	$semId = $request->semId;
2052	$student->sgpa = '';
2053	$studentOverallMarkReport = $studentObj[$studentId];
2054
2055	/ Case when the student passed in all the written supply /
2056	if ( !$student->isFailed ) {
2057
2058	/**
2059	* Here we are considering the mark details of 1 semester
2060	* So, total arrears will be the no. of arrears in that sem
2061	*/
2062	if ( $studentObj[$studentId]->totalArrears > 0 \|\| $studentObj[$studentId]->isFailed ) {
2063	$student->status = $incompleteStatus;
2064	}
2065	else {
2066	$student->status = $completedStatus;
2067
2068	if ($examYear < $studentObj[$studentId]->lastExamYear) {
2069	$student->status = $incompleteStatus;
2070	}
2071	else if ($examYear == $studentObj[$studentId]->lastExamYear && $examMonth <
2072	$studentObj[$studentId]->lastExamMonth) {
2073	$student->status = $incompleteStatus;
2074	}
2075	else {
2076	$sgpa = round($studentObj[$studentId]->semMarks[$academicTermId]->sgpa, 2);
2077	$student->semMarks[$academicTermId]->sgpa = $sgpa;
2078	$student->sgpa = $sgpa;
2079	}
2080	}
2081	}
2082	else {
2083	$student->status = $failStatus;
2084	}
2085	$student->semMarks[$academicTermId]->grade = $studentOverallMarkReport->semMarks[$academicTermId]->grade;
2086	$student->semMarks[$academicTermId]->class = $studentOverallMarkReport->semMarks[$academicTermId]->class;
2087	$student->semMarks[$academicTermId]->credit = $studentOverallMarkReport->semMarks[$academicTermId]->credit;
2088	$student->semMarks[$academicTermId]->creditGradePoint = $studentOverallMarkReport->semMarks[$academicTermId]->creditGradePoint;
2089	$student->semMarks[$academicTermId]->gradePoint = $studentOverallMarkReport->semMarks[$academicTermId]->gradePoint;
2090
2091	$student->semMarks[$academicTermId]->supplyCreditGradePoint = array_sum(array_column($student->semMarks[$academicTermId]->subject, "creditGradePoint"));
2092	$student->semMarks[$academicTermId]->supplyGradePoint = array_sum(array_column($student->semMarks[$academicTermId]->subject, "gradePoint"));
2093	$student->semMarks[$academicTermId]->supplyTotalMarks = array_sum(array_column($student->semMarks[$academicTermId]->subject, "totalMark"));
2094	$student->semMarks[$academicTermId]->supplyTotalMaxMarks = array_sum(array_column($student->semMarks[$academicTermId]->subject, "totalMaxMark"));
2095	$student->semMarks[$academicTermId]->supplyCreditxMarks = array_sum(array_column($student->semMarks[$academicTermId]->subject, "creditxMark"));
2096
2097	$student->overAllMarkDetails = $studentOverallMarkReport;
2098
2099	$student->semMarks[$academicTermId]->supplyRegularTotalMarks = array_sum(array_column($studentOverallMarkReport->semMarks[$academicTermId]->subject, "totalMark"));
2100	$student->semMarks[$academicTermId]->supplyRegularGradePoint = array_sum(array_column($studentOverallMarkReport->semMarks[$academicTermId]->subject, "gradePoint"));
2101	}
2102
2103	usort($students, function ($a, $b) {
2104	return $a->regNo > $b->regNo;
2105	});
2106
2107	}
2108
2109	$details = new \stdClass();
2110	$details->students = $students;
2111
2112	return $details->students;
2113	}
2114
2115
2116
2117	}
2118
2119
2120