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 / 9
 CRAP
0.00% covered (danger)
0.00%
0 / 210
AcademicDegreeService
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 9
 1482.00
0.00% covered (danger)
0.00%
0 / 210
 searchDegreeService
0.00% covered (danger)
0.00%
0 / 1
 20.00
0.00% covered (danger)
0.00%
0 / 42
 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 / 44
 getAcademicTermDetails
0.00% covered (danger)
0.00%
0 / 1
 12.00
0.00% covered (danger)
0.00%
0 / 25
<?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\constant\academic\StatusConstants;
use com\linways\core\ams\professional\dto\api\AcademicTerm;
use com\linways\core\ams\professional\dto\api\Degree;
use com\linways\core\ams\professional\mapper\academic\AcademicTermServiceMapper;
use com\linways\core\ams\professional\request\academic\SearchAcademicTermRequest;
use stdClass;
class AcademicDegreeService extends BaseService
{
    use MakeSingletonTrait;
   
      /**
     * Search user
     * @param  User $user 
     * @param SortBy $sortBy
     * @param SortOrder $sortOrder
     * @throws TrainingException
     * @author Krishnajith
     * @return User $user
     */
    public function searchDegreeService($degree){
            try
            {
                $response = new stdClass;
                $user = $this->realEscapeObject($degree); // every parameter of each function should be real-escaped.
                $condition = NULL;
                
                if(!empty($degree->name))
                {
                    $condition .= " AND degree.name LIKE  '%$degree->name%'";
                }
                if(!empty($degree->discription))
                {
                    $condition .= " AND degree.discription LIKE  '%$degree->discription%'";
                }
                
                $sql = "SELECT 
                                degree.id,
                                degree.name,
                                degree.discription,
                                degree.created_by,
                                degree.created_date,
                                degree.updated_by,
                                degree.updated_date 
                            FROM
                                `degree` 
                            WHERE 
                                1=1
                                $condition ";
                $totalRecordSql = "SELECT 
                                COUNT(DISTINCT degree.id )as 
                            FROM
                                `degree` 
                            WHERE 
                                1=1
                                $condition ";
                        
                        
            
                $response->DegreeArray = $this->executeQueryForList($sql);
                $response->totalRecords = $this->executeQueryForObject($totalRecordSql);
               
            }
            catch(\Exception $e)
            {
            throw new ProfessionalException($e->getCode(), $e->getMessage());
            }
            
            
        return $response;
    }
    /**
     * 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);
        $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.$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;
    }
}