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 / 12
 CRAP
0.00% covered (danger)
0.00%
0 / 187
DegreeService
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 12
 1260.00
0.00% covered (danger)
0.00%
0 / 187
 __construct
0.00% covered (danger)
0.00%
0 / 1
 2.00
0.00% covered (danger)
0.00%
0 / 2
 saveDegree
0.00% covered (danger)
0.00%
0 / 1
 56.00
0.00% covered (danger)
0.00%
0 / 25
 validateSaveDegreeRequest
0.00% covered (danger)
0.00%
0 / 1
 6.00
0.00% covered (danger)
0.00%
0 / 4
 insertDegree
0.00% covered (danger)
0.00%
0 / 1
 6.00
0.00% covered (danger)
0.00%
0 / 13
 updateDegree
0.00% covered (danger)
0.00%
0 / 1
 6.00
0.00% covered (danger)
0.00%
0 / 16
 deleteDegree
0.00% covered (danger)
0.00%
0 / 1
 6.00
0.00% covered (danger)
0.00%
0 / 17
 restoreDegree
0.00% covered (danger)
0.00%
0 / 1
 6.00
0.00% covered (danger)
0.00%
0 / 17
 searchDegree
0.00% covered (danger)
0.00%
0 / 1
 90.00
0.00% covered (danger)
0.00%
0 / 44
 getDegreeDetails
0.00% covered (danger)
0.00%
0 / 1
 6.00
0.00% covered (danger)
0.00%
0 / 25
 deleteDegreePermanently
0.00% covered (danger)
0.00%
0 / 1
 6.00
0.00% covered (danger)
0.00%
0 / 14
 validateBeforeDelete
0.00% covered (danger)
0.00%
0 / 1
 6.00
0.00% covered (danger)
0.00%
0 / 7
 haveId
0.00% covered (danger)
0.00%
0 / 1
 6.00
0.00% covered (danger)
0.00%
0 / 3
<?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\DegreeServiceMapper;
use com\linways\core\ams\professional\request\academic\SearchDegreeRequest;
use com\linways\core\ams\professional\constant\academic\StatusConstants;
use com\linways\core\ams\professional\dto\api\Degree;
use com\linways\core\ams\professional\request\academic\SearchProgramRequest;
use com\linways\core\ams\professional\service\CourseTypeService;
use stdClass;
class DegreeService extends BaseService
{
    use MakeSingletonTrait;
    public function __construct() {
        $this->mapper = DegreeServiceMapper::getInstance()->getMapper();
    }
    /**
     * Save degree
     * @param Degree $degree
     * @return String $id
     */
    public function saveDegree (Degree $degree)
    {
        $degree = $this->realEscapeObject($degree);
        $degree->createdBy = $GLOBALS['userId'] ?? $degree->createdBy;
        $degree->updatedBy = $GLOBALS['userId'] ?? $degree->updatedBy;
        try{
            $this->validateSaveDegreeRequest($degree);
            
            if(!empty($degree->id))
            {
                $degree->id = $this->updateDegree($degree);
            }
            else
            {
                $degree->id = $this->insertDegree($degree);
            }
        }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 Degree! Please try again");
            } else if ($e->getCode() === ProfessionalException::DUPLICATE_ENTRY) {
                throw new ProfessionalException (ProfessionalException::DUPLICATE_ENTRY,"Cannot create degree.$degree->name already exists!");
            } else {
                throw new ProfessionalException ($e->getCode(),$e->getMessage());
            }
        }
        
        return $degree->id;
    }
    
    /**
     * Validate Degree Request Before Saving
     * @param Degree $degree
     * @return NULL
     */
    private function validateSaveDegreeRequest(Degree $degree)
    {
        if(empty($degree->name))
            throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Degree name is empty! Please enter a name for degree");
    }
    
    /**
     * Insert Degree
     * @param Degree $degree
     * @return String $id
     */
    private function insertDegree(Degree $degree)
    {
        /**TODO: After implimenting properties to degree table */
        // $properties = !empty($degree->properties) ? "'" . json_encode($degree->properties) . "'" : "NULL";
        $id = SecurityUtils::getRandomString();
        $query = "INSERT INTO `degree`
                  (`id`,`name`,`description`,`created_by`,`updated_by`)
                  VALUES
                  ('$id','$degree->name','$degree->description','$degree->createdBy','$degree->updatedBy')";
        
        try {
            $this->executeQuery($query);
            return $id;
        } catch (\Exception $e) {
            throw new ProfessionalException($e->getCode(),$e->getMessage());
        }
    }
    /**
     * Update Degree
     * @param Degree $degree
     * @return NULL
     */
    private function updateDegree(Degree $degree)
    {
        // $properties = !empty($degree->properties) ? "'".json_encode($degree->properties)."'" : "NULL";
        
        $query = "UPDATE
                    `degree`
                SET
                    `name` = '$degree->name',
                    `description` = '$degree->description',
                    `updated_by` = '$degree->updatedBy'
                WHERE
                    `id` = '$degree->id'";
        try {
            $this->executeQuery($query);
            return $degree->id;
        } catch (\Exception $e) {
            throw new ProfessionalException($e->getCode(),$e->getMessage());
        }
    }
    /**
     * Delete Degree (Soft Delete)
     * @param String $id
     * @return NULL
     */
    public function deleteDegree($id)
    {
        $id = $this->realEscapeString($id);
        $updatedBy = $GLOBALS['adminId'];
        $this->haveId($id);
        $query = "UPDATE
                    `degree`
                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 degree! Please try again");
        }
    }
    /**
     * Restore Degree
     * @param String $id
     * @return NULL
     */
    public function restoreDegree($id)
    {
        $id = $this->realEscapeString($id);
        $updatedBy = $GLOBALS['userId'];
        $this->haveId($id);
        $query = "UPDATE
                    `degree`
                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 SearchDegreeRequest $request
     * @return Degree
     */
    public function searchDegree(SearchDegreeRequest $request)
    {
        $request = $this->realEscapeObject($request);
        $whereQuery = "";
        $limitQuery = "";
        if(!empty($request->id)) {
            $whereQuery .= " AND d.id='$request->id' ";
        }
        if($request->trashed === StatusConstants::ACTIVE) {
            $whereQuery .= " AND d.trashed IS NULL ";
        }
        if($request->trashed === StatusConstants::TRASHED) {
            $whereQuery .= " AND d.trashed IS NOT NULL ";
        }
        if(!empty($request->name)) {
            $whereQuery .= " AND  d.name LIKE '%$request->name%' ";
        } 
        if(!empty($request->description)) {
            $whereQuery .= " AND  d.description LIKE '%$request->description%' ";
        }
        if($request->startIndex !== "" && $request->endIndex !== "")
        {
            $limitQuery .= " LIMIT $request->startIndex,$request->endIndex";
        }
        $orderBy = " ORDER BY d.created_date DESC ";
        $query = "SELECT
            d.id,
            d.name,
            d.description,
            d.trashed,
            d.created_by,
            d.created_date,
            d.updated_by,
            d.updated_date
        FROM
            degree d
        WHERE
            1 = 1";
        try {
            $degrees = $this->executeQueryForList($query.$whereQuery.$orderBy.$limitQuery, $this->mapper[DegreeServiceMapper::SEARCH_DEGREES]);
        } catch (\Exception $e) {
            throw new ProfessionalException(ProfessionalException::ERROR_FETCHING,"Cannot fetch degree details! Please try again.");
        }
        return $degrees;
    } 
    /**
     * get Academic term by id
     * @param String $id
     * @return Degree
     */
    public function getDegreeDetails($id)
    {
        $id = $this->realEscapeObject($id);
        $whereQuery = "";
        $limitQuery = "";
        $this->haveId($id);
            $query = "SELECT
            d.id,
            d.name,
            d.description,
            d.trashed,
            d.created_by,
            d.created_date,
            d.updated_by,
            d.updated_date
        FROM
            `degree` d
        WHERE
            d.id = '$id'";
        try {
            $degree = $this->executeQueryForObject($query,$isReturnKey = false,$this->mapper[DegreeServiceMapper::SEARCH_DEGREES]);
        } catch (\Exception $e) {
            throw new ProfessionalException(ProfessionalException::ERROR_FETCHING,"Cannot fetch degree details! Please try again");
        }
        return $degree;
    }
    
    /**
     * Delete Degree (Soft Delete)
     * @param String $id
     * @return NULL
     */
    public function deleteDegreePermanently($id)
    {
        $id = $this->realEscapeString($id);
        $this->haveId($id);
        
        $this->validateBeforeDelete($id);
        $request = new stdClass;
        $request->degreeId = $id;
        CourseTypeService::getInstance()->deleteCoursePattern($request);
        $query = "DELETE FROM degree WHERE id = '$id'";
        
        try {
            $this->executeQuery($query);
        } catch (\Exception $e) {
            throw new ProfessionalException(ProfessionalException::ERROR_DELETING,"Error deleting degree! Please try again");
        }
    }
    /**
     * validate degree before deleting 
     * @param CourseTypeId 
     * @throw AcademicException
     */
    public function validateBeforeDelete($id){
        $request = new SearchProgramRequest();
        $request->degreeIds [] = $id;
        $programs = ProgramService::getInstance()->searchProgram($request);
        if(count($programs)){
            throw new ProfessionalException(ProfessionalException::HAVE_RELATIONS,"Cannot delete course type! Please try again.");
        }
    }
    public function haveId($id){
        if(empty($id))
            throw new ProfessionalException(ProfessionalException::EMPTY_PARAMETERS,"Degree is invalid! Please enter a valid degree");
    }
}