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 / 10
 CRAP
0.00% covered (danger)
0.00%
0 / 181
AcademicTermService
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 10
 1406.00
0.00% covered (danger)
0.00%
0 / 181
 __construct
0.00% covered (danger)
0.00%
0 / 1
 2.00
0.00% covered (danger)
0.00%
0 / 2
 saveAcademicTerm
0.00% covered (danger)
0.00%
0 / 1
 56.00
0.00% covered (danger)
0.00%
0 / 25
 validateSaveAcademicTermRequest
0.00% covered (danger)
0.00%
0 / 1
 12.00
0.00% covered (danger)
0.00%
0 / 6
 insertAcademicTerm
0.00% covered (danger)
0.00%
0 / 1
 12.00
0.00% covered (danger)
0.00%
0 / 14
 updateAcademicTerm
0.00% covered (danger)
0.00%
0 / 1
 12.00
0.00% covered (danger)
0.00%
0 / 18
 deleteAcademicTerm
0.00% covered (danger)
0.00%
0 / 1
 12.00
0.00% covered (danger)
0.00%
0 / 18
 restoreAcademicTerm
0.00% covered (danger)
0.00%
0 / 1
 12.00
0.00% covered (danger)
0.00%
0 / 18
 searchAcademicTerm
0.00% covered (danger)
0.00%
0 / 1
 90.00
0.00% covered (danger)
0.00%
0 / 45
 getAcademicTermDetails
0.00% covered (danger)
0.00%
0 / 1
 12.00
0.00% covered (danger)
0.00%
0 / 25
 getCurrentAcademicTerm
0.00% covered (danger)
0.00%
0 / 1
 6.00
0.00% covered (danger)
0.00%
0 / 10
<?php
namespace com\linways\core\ams\professional\service\academic;
use com\linways\base\util\SecurityUtils;
use com\linways\base\util\MakeSingletonTrait;
use com\linways\core\ams\professional\service\BaseService;
use com\linways\core\ams\professional\exception\ProfessionalException;
use com\linways\core\ams\professional\mapper\academic\AcademicTermServiceMapper;
use com\linways\core\ams\professional\request\academic\SearchAcademicTermRequest;
use com\linways\core\ams\professional\constant\academic\StatusConstants;
use com\linways\core\ams\professional\dto\api\AcademicTerm;
class AcademicTermService extends BaseService
{
    use MakeSingletonTrait;
    private function __construct() {
        $this->mapper = AcademicTermServiceMapper::getInstance()->getMapper();
    }
    /**
     * Save academic term
     * @param AcademicTerm $academicTerm
     * @return String $id
     */
    public function saveAcademicTerm (AcademicTerm $academicTerm)
    {
        $academicTerm = $this->realEscapeObject($academicTerm);
        $academicTerm->createdBy = $GLOBALS['userId'] ?? $academicTerm->createdBy;
        $academicTerm->updatedBy = $GLOBALS['userId'] ?? $academicTerm->updatedBy;
        try{
            $this->validateSaveAcademicTermRequest($academicTerm);
            
            if(!empty($academicTerm->id))
            {
                $academicTerm->id = $this->updateAcademicTerm($academicTerm);
            }
            else
            {
                $academicTerm->id = $this->insertAcademicTerm($academicTerm);
            }
        }catch(\Exception $e) {
            if($e->getCode() !== ProfessionalException::INVALID_PARAMETER && $e->getCode() !== ProfessionalException::EMPTY_PARAMETERS && $e->getCode() !== ProfessionalException::DUPLICATE_ENTRY) {
                throw new ProfessionalException($e->getCode(),"Failed to save academic term! Please try again");
            } else if ($e->getCode() === ProfessionalException::DUPLICATE_ENTRY) {
                throw new ProfessionalException (ProfessionalException::DUPLICATE_ENTRY,"Cannot create academic term.$academicTerm->name already exists!");
            } else {
                throw new ProfessionalException ($e->getCode(),$e->getMessage());
            }
        }
        
        return $academicTerm->id;
    }
    
    /**
     * Validate Academic term Request Before Saving
     * @param AcademicTerm $academicTerm
     * @return NULL
     */
    private function validateSaveAcademicTermRequest($academicTerm)
    {
        if(empty($academicTerm->name))
            throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Academic term name is empty! Please enter a name for academic term");
        if(empty($academicTerm->type))
            throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Academic term type is empty! Please choose a academic term type");
    }
    
    /**
     * Insert Academic term
     * @param AcademicTerm $academicTerm
     * @return String $id
     */
    private function insertAcademicTerm(AcademicTerm $academicTerm)
    {
        $properties = !empty($academicTerm->properties) ? "'" . json_encode($academicTerm->properties) . "'" : "NULL";
        $id = SecurityUtils::getRandomString();
        $query = "INSERT INTO `academic_term`
                  (`id`,`name`,`type`,`properties`,`created_by`,`updated_by`)
                  VALUES
                  ('$id','$academicTerm->name','$academicTerm->type',$properties,'$academicTerm->createdBy','$academicTerm->updatedBy')";
        
        try {
            $this->executeQuery($query);
            return $id;
        } catch (\Exception $e) {
            throw new ProfessionalException($e->getCode(),$e->getMessage());
        }
    }
    /**
     * Update Academic term
     * @param AcademicTerm $academicTerm
     * @return NULL
     */
    private function updateAcademicTerm(AcademicTerm $academicTerm)
    {
        $properties = !empty($academicTerm->properties) ? "'".json_encode($academicTerm->properties)."'" : "NULL";
        
        $query = "UPDATE
                    `academic_term`
                SET
                    `name` = '$academicTerm->name',
                    `type` = '$academicTerm->type',
                    `properties` = $properties,
                    `updated_by` = '$academicTerm->updatedBy'
                WHERE
                    `id` = '$academicTerm->id'";
        try {
            $this->executeQuery($query);
            return $academicTerm->id;
        } catch (\Exception $e) {
            throw new ProfessionalException($e->getCode(),$e->getMessage());
        }
    }
    /**
     * Delete Academic term (Soft Delete)
     * @param String $id
     * @return NULL
     */
    public function deleteAcademicTerm($id)
    {
        $id = $this->realEscapeString($id);
        $updatedBy = $GLOBALS['userId'];
        if(empty($id))
            throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Academic term is invalid! Please enter a valid academic term");
        $query = "UPDATE
                    `academic_term`
                SET
                    `trashed` = UTC_TIMESTAMP(),
                    `updated_by` = '$updatedBy'
                WHERE
                    `id` = '$id'";
        try {
            $this->executeQuery($query);
        } catch (\Exception $e) {
            throw new ProfessionalException(ProfessionalException::ERROR_DELETING,"Error deleting academic term! Please try again");
        }
    }
    /**
     * Restore Academic term
     * @param String $id
     * @return NULL
     */
    public function restoreAcademicTerm($id)
    {
        $id = $this->realEscapeString($id);
        $updatedBy = $GLOBALS['userId'];
        if(empty($id))
            throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Academic term is invalid! Please enter a valid academic term");
        $query = "UPDATE
                    `academic_term`
                SET
                    `trashed` = NULL,
                    `updated_by` = '$updatedBy'
                WHERE
                    `id` = '$id'";
        try {
            $this->executeQuery($query);
        } catch (\Exception $e) {
            throw new ProfessionalException(ProfessionalException::ERROR_RESTORING,"Error restoring academic term! Please try again");
        }
    }
    
    /**
     * Search Academic term Details
     * @param SearchAcademicTermRequest $request
     * @return AcademicTerm
     */
    public function searchAcademicTerm(SearchAcademicTermRequest $request)
    {
        $request = $this->realEscapeObject($request);
        $orderBy = " ORDER BY CAST(act.properties ->> '$.orderNo' AS UNSIGNED) ASC";
        $whereQuery = "";
        $limitQuery = "";
        if(!empty($request->id)) {
            $whereQuery .= " AND act.id='$request->id' ";
        }
        if($request->trashed === StatusConstants::ACTIVE) {
            $whereQuery .= " AND act.trashed IS NULL ";
        }
        if($request->trashed === StatusConstants::TRASHED) {
            $whereQuery .= " AND act.trashed IS NOT NULL ";
        }
        if(!empty($request->name)) {
            $whereQuery .= " AND act.name LIKE '%$request->name%' ";
        }
        if(!empty($request->type)) {
            $whereQuery .= " AND  act.`type` LIKE '%$request->type%' ";
        }
        if($request->startIndex !== "" && $request->endIndex !== "")
        {
            $limitQuery .= " LIMIT $request->startIndex,$request->endIndex";
        }
        $query = "SELECT
            act.`id`,
            act.`name`,
            act.`type`,
            act.`properties`,
            act.`trashed`,
            act.`created_by`,
            act.`created_date`,
            act.`updated_by`,
            act.`updated_date`
        FROM
            academic_term act
        WHERE
            1 = 1";
        try {
            $academicTerms = $this->executeQueryForList($query.$whereQuery.$orderBy.$limitQuery, $this->mapper[AcademicTermServiceMapper::SEARCH_ACADEMIC_TERMS]);
        } catch (\Exception $e) {
            throw new ProfessionalException(ProfessionalException::ERROR_FETCHING,"Cannot fetch academic term details! Please try again");
        }
        return $academicTerms;
    } 
    /**
     * get Academic term by id
     * @param String $id
     * @return AcademicTerm
     */
    public function getAcademicTermDetails($id)
    {
        $request = $this->realEscapeObject($id);
        if(empty($id)) 
            throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Academic term is invalid! Please enter a valid academic term");
        $query = "SELECT
            act.`id`,
            act.`name`,
            act.`type`,
            act.`properties`,
            act.`trashed`,
            act.`created_by`,
            act.`created_date`,
            act.`updated_by`,
            act.`updated_date`
        FROM
            `academic_term` act
        WHERE
            act.id='$id'";
        try {
            $academicTerm = $this->executeQueryForObject($query, $this->mapper[AcademicTermServiceMapper::SEARCH_ACADEMIC_TERMS]);
        } catch (\Exception $e) {
            throw new ProfessionalException(ProfessionalException::ERROR_FETCHING,"Cannot fetch academic term details! Please try again");
        }
        return $academicTerm;
    }
    public function getCurrentAcademicTerm ($studentId)
    {
        $studentId = $this->realEscapeString($studentId);
        $query = "SELECT current_term_id FROM student_program_account WHERE student_id='$studentId' AND academic_status='ACTIVE'";
        try{
            $academicTerm = $this->executeQueryForObject($query);
        }catch(\Exception $e) {
            throw new ProfessionalException($e->getCode(),$e->getMessage());
        }
        return $academicTerm->current_term_id;
    }
}