luos/workflow/engine/src/ProcessMaker/BusinessModel/Role.php

<?php

namespace ProcessMaker\BusinessModel;

use Configurations;
use Content;
use Criteria;
use DateTime;
use Exception;
use G;
use ProcessMaker\Util\Common;
use ResultSet;
use Roles as ModelRoles;
use RolesPeer;
use UsersRolesPeer;


require_once PATH_RBAC . 'model' . PATH_SEP . 'Roles.php';

class Role
{
    private $arrayFieldDefinition = [
        'ROL_UID' => ['type' => 'string', 'required' => false, 'empty' => false, 'defaultValues' => [], 'fieldNameAux' => 'roleUid'],

        'ROL_CODE' => ['type' => 'string', 'required' => true, 'empty' => false, 'defaultValues' => [], 'fieldNameAux' => 'roleCode'],
        'ROL_NAME' => ['type' => 'string', 'required' => true, 'empty' => false, 'defaultValues' => [], 'fieldNameAux' => 'roleName'],
        'ROL_STATUS' => ['type' => 'string', 'required' => false, 'empty' => false, 'defaultValues' => ['ACTIVE', 'INACTIVE'], 'fieldNameAux' => 'roleStatus']
    ];

    private $formatFieldNameInUppercase = true;

    private $arrayFieldNameForException = [
        'filter' => 'FILTER',
        'start' => 'START',
        'limit' => 'LIMIT'
    ];

    const SYSTEM_RBAC = '00000000000000000000000000000001';
    const SYSTEM_PROCESSMAKER = '00000000000000000000000000000002';

    /**
     * Role constructor.
     *
     * @throws Exception
     */
    public function __construct()
    {
        try {
            foreach ($this->arrayFieldDefinition as $key => $value) {
                $this->arrayFieldNameForException[$value["fieldNameAux"]] = $key;
            }
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Set the format of the fields name (uppercase, lowercase)
     *
     * @param bool $flag Value that set the format
     *
     * @return void
     * @throws Exception
     */
    public function setFormatFieldNameInUppercase($flag)
    {
        try {
            $this->formatFieldNameInUppercase = $flag;

            $this->setArrayFieldNameForException($this->arrayFieldNameForException);
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Set exception messages for fields
     *
     * @param array $arrayData Data with the fields
     *
     * @return void
     * @throws Exception
     */
    public function setArrayFieldNameForException(array $arrayData)
    {
        try {
            foreach ($arrayData as $key => $value) {
                $this->arrayFieldNameForException[$key] = $this->getFieldNameByFormatFieldName($value);
            }
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Get the name of the field according to the format
     *
     * @param string $fieldName Field name
     *
     * @return string Return the field name according the format
     * @throws Exception
     */
    public function getFieldNameByFormatFieldName($fieldName)
    {
        try {
            return ($this->formatFieldNameInUppercase) ? strtoupper($fieldName) : strtolower($fieldName);
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Verify if exists the code of a Role
     *
     * @param string $roleCode Code
     * @param string $roleSystemUid Unique id of System (00000000000000000000000000000001: RBAC,
     *     00000000000000000000000000000002: PROCESSMAKER)
     * @param string $roleUidExclude Unique id of Role to exclude
     *
     * @return bool Return true if exists the code of a Role, false otherwise
     * @throws Exception
     */
    public function existsCode($roleCode, $roleSystemUid, $roleUidExclude = "")
    {
        try {
            $criteria = new Criteria("rbac");

            $criteria->addSelectColumn(RolesPeer::ROL_UID);

            $criteria->add(RolesPeer::ROL_SYSTEM, $roleSystemUid, Criteria::EQUAL);

            if (!empty($roleUidExclude)) {
                $criteria->add(RolesPeer::ROL_UID, $roleUidExclude, Criteria::NOT_EQUAL);
            }

            $criteria->add(RolesPeer::ROL_CODE, $roleCode, Criteria::EQUAL);

            $rsCriteria = RolesPeer::doSelectRS($criteria);

            if ($rsCriteria->next()) {
                return true;
            } else {
                return false;
            }
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Verify if exists the name of a Role
     *
     * @param string $roleName Name
     * @param string $roleSystemUid Unique id of System (00000000000000000000000000000001: RBAC,
     *     00000000000000000000000000000002: PROCESSMAKER)
     * @param string $roleUidExclude Unique id of Role to exclude
     *
     * @return bool Return true if exists the name of a Role, false otherwise
     * @throws Exception
     */
    public function existsName($roleName, $roleSystemUid, $roleUidExclude = "")
    {
        try {
            //Set variables
            $content = new Content();
            $role = new ModelRoles();

            $arrayContentByRole = $content->getAllContentsByRole();

            //SQL
            $criteria = new Criteria("rbac");

            $criteria->addSelectColumn(RolesPeer::ROL_UID);

            $criteria->add(RolesPeer::ROL_SYSTEM, $roleSystemUid, Criteria::EQUAL);

            if ($roleUidExclude != "") {
                $criteria->add(RolesPeer::ROL_UID, $roleUidExclude, Criteria::NOT_EQUAL);
            }

            $rsCriteria = RolesPeer::doSelectRS($criteria);
            $rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);

            while ($rsCriteria->next()) {
                $row = $rsCriteria->getRow();

                $roleUid = $row["ROL_UID"];

                if (isset($arrayContentByRole[$roleUid])) {
                    $roleNameAux = $arrayContentByRole[$roleUid];
                } else {
                    $rowAux = $role->load($roleUid);
                    $roleNameAux = $rowAux["ROL_NAME"];
                }

                if ($roleNameAux == $roleName) {
                    return true;
                }
            }

            return false;
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Verify if does not exist the Role in table ROLES
     *
     * @param string $roleUid Unique id of Role
     * @param string $fieldNameForException Field name for the exception
     *
     * @return void Throw exception if does not exist the Role in table ROLES
     * @throws Exception
     */
    public function throwExceptionIfNotExistsRole($roleUid, $fieldNameForException)
    {
        try {
            $obj = RolesPeer::retrieveByPK($roleUid);

            if (is_null($obj)) {
                throw new Exception(G::LoadTranslation("ID_ROLE_DOES_NOT_EXIST", [$fieldNameForException, $roleUid]));
            }
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Verify if exists the code of a Role
     *
     * @param string $roleCode Code
     * @param string $roleSystemUid Unique id of System (00000000000000000000000000000001: RBAC,
     *     00000000000000000000000000000002: PROCESSMAKER)
     * @param string $fieldNameForException Field name for the exception
     * @param string $roleUidExclude Unique id of Role to exclude
     *
     * @return void Throw exception if exists the code of a Role
     * @throws Exception
     */
    public function throwExceptionIfExistsCode($roleCode, $roleSystemUid, $fieldNameForException, $roleUidExclude = "")
    {
        try {
            if ($this->existsCode($roleCode, $roleSystemUid, $roleUidExclude)) {
                throw new Exception(G::LoadTranslation("ID_ROLE_CODE_ALREADY_EXISTS", [$fieldNameForException, $roleCode]));
            }
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Verify if exists the name of a Role
     *
     * @param string $roleName Name
     * @param string $roleSystemUid Unique id of System (00000000000000000000000000000001: RBAC,
     *     00000000000000000000000000000002: PROCESSMAKER)
     * @param string $fieldNameForException Field name for the exception
     * @param string $roleUidExclude Unique id of Role to exclude
     *
     * @return void Throw exception if exists the name of a Role
     * @throws Exception
     */
    public function throwExceptionIfExistsName($roleName, $roleSystemUid, $fieldNameForException, $roleUidExclude = "")
    {
        try {
            if ($this->existsName($roleName, $roleSystemUid, $roleUidExclude)) {
                throw new Exception(G::LoadTranslation("ID_ROLE_NAME_ALREADY_EXISTS", [$fieldNameForException, $roleName]));
            }
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Validate the data if they are invalid (INSERT and UPDATE)
     *
     * @param string $roleUid Unique id of Role
     * @param array $arrayData Data
     *
     * @return void Throw exception if data has an invalid value
     * @throws Exception
     */
    public function throwExceptionIfDataIsInvalid($roleUid, array $arrayData)
    {
        try {
            //Set variables
            $arrayRoleData = ($roleUid == "") ? [] : $this->getRole($roleUid, true);
            $flagInsert = ($roleUid == "") ? true : false;

            $arrayDataMain = array_merge($arrayRoleData, $arrayData);

            //Verify data - Field definition
            $process = new Process();

            $process->throwExceptionIfDataNotMetFieldDefinition($arrayData, $this->arrayFieldDefinition, $this->arrayFieldNameForException, $flagInsert);

            //Verify data
            if (isset($arrayData["ROL_CODE"]) && !preg_match("/^\w+$/", $arrayData["ROL_CODE"])) {
                throw new Exception(G::LoadTranslation("ID_ROLE_FIELD_CANNOT_CONTAIN_SPECIAL_CHARACTERS", [$this->arrayFieldNameForException["roleCode"]]));
            }

            if (isset($arrayData["ROL_CODE"])) {
                $this->throwExceptionIfExistsCode($arrayData["ROL_CODE"], $arrayDataMain["ROL_SYSTEM"], $this->arrayFieldNameForException["roleCode"], $roleUid);
            }

            if (isset($arrayData["ROL_NAME"])) {
                $this->throwExceptionIfExistsName($arrayData["ROL_NAME"], $arrayDataMain["ROL_SYSTEM"], $this->arrayFieldNameForException["roleName"], $roleUid);
            }
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Create Role
     *
     * @param array $arrayData Data
     *
     * @return array Return data of the new Role created
     * @throws Exception
     */
    public function create(array $arrayData)
    {
        try {
            //Verify data
            $validator = new Validator();

            $validator->throwExceptionIfDataIsEmpty($arrayData, "\$arrayData");

            //Set data
            $arrayData = array_change_key_case($arrayData, CASE_UPPER);

            unset($arrayData['ROL_UID']);

            $arrayData['ROL_SYSTEM'] = self::SYSTEM_PROCESSMAKER;

            //Verify data
            $this->throwExceptionIfDataIsInvalid('', $arrayData);

            //Create
            $role = new ModelRoles();

            $roleUid = Common::generateUID();

            $arrayData['ROL_UID'] = $roleUid;
            $arrayData['ROL_STATUS'] = isset($arrayData['ROL_STATUS']) ? $arrayData['ROL_STATUS'] === 'ACTIVE' ? 1 : 0 : 1;
            $arrayData['ROL_CREATE_DATE'] = date('Y-M-d H:i:s');
            $arrayData['ROL_UPDATE_DATE'] = date('Y-M-d H:i:s');

            $role->createRole($arrayData);

            //Return
            return $this->getRole($roleUid);
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Update Role
     *
     * @param string $roleUid Unique id of Role
     * @param array $arrayData Data
     *
     * @return array Return data of the Role updated
     * @throws Exception
     */
    public function update($roleUid, array $arrayData)
    {
        try {
            //Verify data
            $validator = new Validator();

            $validator->throwExceptionIfDataIsEmpty($arrayData, "\$arrayData");

            //Set data
            $arrayData = array_change_key_case($arrayData, CASE_UPPER);
            $arrayDataBackup = $arrayData;

            $arrayRoleData = $this->getRole($roleUid);

            //Verify data
            $this->throwExceptionIfNotExistsRole($roleUid, $this->arrayFieldNameForException['roleUid']);

            if ($roleUid === self::SYSTEM_PROCESSMAKER) {
                throw new Exception(G::LoadTranslation('ID_ROLES_MSG'));
            }

            $this->throwExceptionIfDataIsInvalid($roleUid, $arrayData);

            //Update
            $role = new ModelRoles();

            $arrayData['ROL_UID'] = $roleUid;
            $arrayData['ROL_UPDATE_DATE'] = date('Y-M-d H:i:s');

            if (!isset($arrayData['ROL_NAME'])) {
                $arrayData['ROL_NAME'] = $arrayRoleData[$this->getFieldNameByFormatFieldName('ROL_NAME')];
            }

            if (isset($arrayData['ROL_STATUS'])) {
                $arrayData['ROL_STATUS'] = $arrayData['ROL_STATUS'] === 'ACTIVE' ? 1 : 0;
            }

            $role->updateRole($arrayData);

            $arrayData = $arrayDataBackup;

            //Return
            if (!$this->formatFieldNameInUppercase) {
                $arrayData = array_change_key_case($arrayData, CASE_LOWER);
            }

            return $arrayData;
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Delete Role
     *
     * @param string $roleUid Unique id of Role
     *
     * @return void
     * @throws Exception
     */
    public function delete($roleUid)
    {
        try {
            $role = new ModelRoles();

            //Verify data
            $this->throwExceptionIfNotExistsRole($roleUid, $this->arrayFieldNameForException["roleUid"]);

            if ($role->numUsersWithRole($roleUid) > 0) {
                throw new Exception(G::LoadTranslation("ID_ROLES_CAN_NOT_DELETE"));
            }

            //Delete
            $result = $role->removeRole($roleUid);
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Get criteria for Role
     *
     * @return object
     * @throws Exception
     */
    public function getRoleCriteria()
    {
        try {
            $criteria = new Criteria("rbac");

            $criteria->addSelectColumn(RolesPeer::ROL_UID);
            $criteria->addSelectColumn(RolesPeer::ROL_PARENT);
            $criteria->addSelectColumn(RolesPeer::ROL_CODE);
            $criteria->addSelectColumn(RolesPeer::ROL_STATUS);
            $criteria->addSelectColumn(RolesPeer::ROL_SYSTEM);
            $criteria->addSelectColumn(RolesPeer::ROL_CREATE_DATE);
            $criteria->addSelectColumn(RolesPeer::ROL_UPDATE_DATE);

            $criteria->add(RolesPeer::ROL_SYSTEM, self::SYSTEM_PROCESSMAKER, Criteria::EQUAL); //PROCESSMAKER

            return $criteria;
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Get data of a Role from a record
     *
     * @param array $record Record
     *
     * @return array Return an array with data Role
     * @throws Exception
     */
    public function getRoleDataFromRecord(array $record)
    {
        try {
            $conf = new Configurations();
            $confEnvSetting = $conf->getFormats();

            $dateTime = new DateTime($record['ROL_CREATE_DATE']);
            $roleCreateDate = $dateTime->format($confEnvSetting['dateFormat']);

            $roleUpdateDate = '';

            if (!empty($record['ROL_UPDATE_DATE'])) {
                $dateTime = new DateTime($record['ROL_UPDATE_DATE']);
                $roleUpdateDate = $dateTime->format($confEnvSetting['dateFormat']);
            }

            return [
                $this->getFieldNameByFormatFieldName('ROL_UID') => $record['ROL_UID'],
                $this->getFieldNameByFormatFieldName('ROL_CODE') => $record['ROL_CODE'],
                $this->getFieldNameByFormatFieldName('ROL_NAME') => $record['ROL_NAME'],
                $this->getFieldNameByFormatFieldName('ROL_STATUS') => $record['ROL_STATUS'] . '' === '1' ? 'ACTIVE' : 'INACTIVE',
                $this->getFieldNameByFormatFieldName('ROL_SYSTEM') => $record['ROL_SYSTEM'],
                $this->getFieldNameByFormatFieldName('ROL_CREATE_DATE') => $roleCreateDate,
                $this->getFieldNameByFormatFieldName('ROL_UPDATE_DATE') => $roleUpdateDate,
                $this->getFieldNameByFormatFieldName('ROL_TOTAL_USERS') => (int)$record['ROL_TOTAL_USERS']
            ];
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Get all Roles
     *
     * @param array $arrayFilterData Data of the filters
     * @param string $sortField Field name to sort
     * @param string $sortDir Direction of sorting (ASC, DESC)
     * @param int $start Start
     * @param int $limit Limit
     *
     * @return array Return an array with all Roles
     * @throws Exception
     */
    public function getRoles(array $arrayFilterData = null, $sortField = null, $sortDir = null, $start = null, $limit = null)
    {
        try {
            $arrayRole = [];

            //Verify data
            $process = new Process();

            $process->throwExceptionIfDataNotMetPagerVarDefinition(["start" => $start, "limit" => $limit], $this->arrayFieldNameForException);

            //Get data
            if (!is_null($limit) && $limit . "" == "0") {
                return $arrayRole;
            }

            //Set variables
            $content = new Content();
            $role = new ModelRoles();

            $arrayContentByRole = $content->getAllContentsByRole();

            //SQL
            $criteria = $this->getRoleCriteria();

            $criteria->addAsColumn("ROL_TOTAL_USERS", "(SELECT COUNT(" . UsersRolesPeer::ROL_UID . ") FROM " . UsersRolesPeer::TABLE_NAME . " WHERE " . UsersRolesPeer::ROL_UID . " = " . RolesPeer::ROL_UID . ")");

            if (!is_null($arrayFilterData) && is_array($arrayFilterData) && isset($arrayFilterData["filter"]) && trim($arrayFilterData["filter"]) != "") {
                $criteria->add(RolesPeer::ROL_CODE, "%" . $arrayFilterData["filter"] . "%", Criteria::LIKE);
            }

            //SQL
            if (!is_null($sortField) && trim($sortField) != "") {
                $sortField = strtoupper($sortField);

                if (in_array($sortField, ["ROL_UID", "ROL_PARENT", "ROL_STATUS", "ROL_SYSTEM", "ROL_CREATE_DATE", "ROL_UPDATE_DATE"])) {
                    $sortField = RolesPeer::TABLE_NAME . "." . $sortField;
                } else {
                    $sortField = RolesPeer::ROL_CODE;
                }
            } else {
                $sortField = RolesPeer::ROL_CODE;
            }

            if (!is_null($sortDir) && trim($sortDir) != "" && strtoupper($sortDir) == "DESC") {
                $criteria->addDescendingOrderByColumn($sortField);
            } else {
                $criteria->addAscendingOrderByColumn($sortField);
            }

            if (!is_null($start)) {
                $criteria->setOffset((int)($start));
            }

            if (!is_null($limit)) {
                $criteria->setLimit((int)($limit));
            }

            $rsCriteria = RolesPeer::doSelectRS($criteria);
            $rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);

            while ($rsCriteria->next()) {
                $row = $rsCriteria->getRow();

                $roleUid = $row["ROL_UID"];

                if (isset($arrayContentByRole[$roleUid])) {
                    $roleName = $arrayContentByRole[$roleUid];
                } else {
                    $rowAux = $role->load($roleUid);
                    $roleName = $rowAux["ROL_NAME"];
                }

                $row["ROL_NAME"] = $roleName;

                $arrayRole[] = $this->getRoleDataFromRecord($row);
            }

            //Return
            return $arrayRole;
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Get data of a Role
     *
     * @param string $roleUid Unique id of Role
     * @param bool $flagGetRecord Value that set the getting
     *
     * @return array Return an array with data of a Role
     * @throws Exception
     */
    public function getRole($roleUid, $flagGetRecord = false)
    {
        try {
            //Verify data
            $this->throwExceptionIfNotExistsRole($roleUid, $this->arrayFieldNameForException["roleUid"]);

            //Set variables
            if (!$flagGetRecord) {
                $content = new Content();
                $role = new ModelRoles();

                $arrayContentByRole = $content->getAllContentsByRole();
            }

            //Get data
            //SQL
            $criteria = $this->getRoleCriteria();

            if (!$flagGetRecord) {
                $criteria->addAsColumn("ROL_TOTAL_USERS", "(SELECT COUNT(" . UsersRolesPeer::ROL_UID . ") FROM " . UsersRolesPeer::TABLE_NAME . " WHERE " . UsersRolesPeer::ROL_UID . " = " . RolesPeer::ROL_UID . ")");
            }

            $criteria->add(RolesPeer::ROL_UID, $roleUid, Criteria::EQUAL);

            $rsCriteria = RolesPeer::doSelectRS($criteria);
            $rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);

            $rsCriteria->next();

            $row = $rsCriteria->getRow();

            if (!$flagGetRecord) {
                if (isset($arrayContentByRole[$roleUid])) {
                    $roleName = $arrayContentByRole[$roleUid];
                } else {
                    $rowAux = $role->load($roleUid);
                    $roleName = $rowAux["ROL_NAME"];
                }

                $row["ROL_NAME"] = $roleName;
            }

            //Return
            return (!$flagGetRecord) ? $this->getRoleDataFromRecord($row) : $row;
        } catch (Exception $e) {
            throw $e;
        }
    }
}