4324 lines
174 KiB
PHP
4324 lines
174 KiB
PHP
<?php
|
|
|
|
namespace ProcessMaker\BusinessModel;
|
|
|
|
use AppCacheView;
|
|
use AppCacheViewPeer;
|
|
use AppDelay;
|
|
use AppDelayPeer;
|
|
use AppDelegation;
|
|
use AppDelegationPeer;
|
|
use AppDocument;
|
|
use AppDocumentPeer;
|
|
use AppHistoryPeer;
|
|
use Application;
|
|
use ApplicationPeer;
|
|
use Applications;
|
|
use AppNotes;
|
|
use AppNotesPeer;
|
|
use AppSolr;
|
|
use AppTimeoutActionExecuted;
|
|
use BasePeer;
|
|
use Bootstrap;
|
|
use BpmnEngineServicesSearchIndex;
|
|
use Cases as ClassesCases;
|
|
use CasesPeer;
|
|
use Configurations;
|
|
use CreoleTypes;
|
|
use Criteria;
|
|
use DateTime;
|
|
use DBAdapter;
|
|
use EntitySolrRequestData;
|
|
use Exception;
|
|
use G;
|
|
use Groups;
|
|
use GroupUserPeer;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Facades\Log;
|
|
use InputDocument;
|
|
use InvalidIndexSearchTextException;
|
|
use Luracast\Restler\RestException;
|
|
use PmDynaform;
|
|
use PmTable;
|
|
use ProcessMaker\BusinessModel\Cases as BmCases;
|
|
use ProcessMaker\BusinessModel\ProcessSupervisor as BmProcessSupervisor;
|
|
use ProcessMaker\BusinessModel\Task as BmTask;
|
|
use ProcessMaker\BusinessModel\User as BmUser;
|
|
use ProcessMaker\Core\System;
|
|
use ProcessMaker\Exception\UploadException;
|
|
use ProcessMaker\Exception\CaseNoteUploadFile;
|
|
use ProcessMaker\Model\AppDelay as Delay;
|
|
use ProcessMaker\Model\Application as ModelApplication;
|
|
use ProcessMaker\Model\AppNotes as Notes;
|
|
use ProcessMaker\Model\AppTimeoutAction;
|
|
use ProcessMaker\Model\Delegation;
|
|
use ProcessMaker\Model\Documents;
|
|
use ProcessMaker\Model\ListUnassigned;
|
|
use ProcessMaker\Model\Triggers;
|
|
use ProcessMaker\Model\ProcessUser;
|
|
use ProcessMaker\Model\User;
|
|
use ProcessMaker\Plugins\PluginRegistry;
|
|
use ProcessMaker\Services\Api;
|
|
use ProcessMaker\Services\OAuth2\Server;
|
|
use ProcessMaker\Util\DateTime as UtilDateTime;
|
|
use ProcessMaker\Validation\ExceptionRestApi;
|
|
use ProcessMaker\Validation\ValidationUploadedFiles;
|
|
use ProcessMaker\Validation\Validator as FileValidator;
|
|
use ProcessPeer;
|
|
use ProcessUserPeer;
|
|
use RBAC;
|
|
use ResultSet;
|
|
use SubApplication;
|
|
use Task as ModelTask;
|
|
use TaskPeer;
|
|
use Tasks as ClassesTasks;
|
|
use TaskUserPeer;
|
|
use Users as ModelUsers;
|
|
use UsersPeer;
|
|
use WsBase;
|
|
|
|
class Cases
|
|
{
|
|
private $formatFieldNameInUppercase = true;
|
|
private $messageResponse = [];
|
|
private $solr = null;
|
|
private $solrEnv = null;
|
|
const MB_IN_KB = 1024;
|
|
const UNIT_MB = 'MB';
|
|
|
|
/**
|
|
* 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;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the name of the field according to the format
|
|
*
|
|
* @param string $fieldName Field name
|
|
*
|
|
* @return string, 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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Throw the exception "The Case doesn't exist"
|
|
*
|
|
* @param string $applicationUid Unique id of Case
|
|
* @param string $fieldNameForException Field name for the exception
|
|
*
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
private function throwExceptionCaseDoesNotExist($applicationUid, $fieldNameForException)
|
|
{
|
|
throw new Exception(G::LoadTranslation(
|
|
'ID_CASE_DOES_NOT_EXIST2', [$fieldNameForException, $applicationUid]
|
|
));
|
|
}
|
|
|
|
/**
|
|
* Verify if does not exist the Case in table APPLICATION
|
|
*
|
|
* @param string $applicationUid Unique id of Case
|
|
* @param string $delIndex Delegation index
|
|
* @param string $fieldNameForException Field name for the exception
|
|
*
|
|
* @return void
|
|
* @throws Exception, Throw exception if does not exist the Case in table APPLICATION
|
|
*/
|
|
public function throwExceptionIfNotExistsCase($applicationUid, $delIndex, $fieldNameForException)
|
|
{
|
|
try {
|
|
$obj = ApplicationPeer::retrieveByPK($applicationUid);
|
|
|
|
$flag = is_null($obj);
|
|
|
|
if (!$flag && $delIndex > 0) {
|
|
$obj = AppDelegationPeer::retrieveByPK($applicationUid, $delIndex);
|
|
|
|
$flag = is_null($obj);
|
|
}
|
|
|
|
if ($flag) {
|
|
$this->throwExceptionCaseDoesNotExist($applicationUid, $fieldNameForException);
|
|
}
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get Application record
|
|
*
|
|
* @param string $applicationUid Unique id of Case
|
|
* @param array $arrayVariableNameForException Variable name for exception
|
|
* @param bool $throwException Flag to throw the exception if the main parameters are invalid or do not exist
|
|
* (TRUE: throw the exception; FALSE: returns FALSE)
|
|
*
|
|
* @return array, an array with Application record
|
|
* @throws Exception, ThrowTheException/FALSE otherwise
|
|
*/
|
|
public function getApplicationRecordByPk(
|
|
$applicationUid,
|
|
array $arrayVariableNameForException,
|
|
$throwException = true
|
|
) {
|
|
try {
|
|
$obj = ApplicationPeer::retrieveByPK($applicationUid);
|
|
|
|
if (is_null($obj)) {
|
|
if ($throwException) {
|
|
$this->throwExceptionCaseDoesNotExist(
|
|
$applicationUid, $arrayVariableNameForException['$applicationUid']
|
|
);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//Return
|
|
return $obj->toArray(BasePeer::TYPE_FIELDNAME);
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get AppDelegation record
|
|
*
|
|
* @param string $applicationUid Unique id of Case
|
|
* @param int $delIndex Delegation index
|
|
* @param array $arrayVariableNameForException Variable name for exception
|
|
* @param bool $throwException Flag to throw the exception if the main parameters are invalid or do not exist
|
|
* (TRUE: throw the exception; FALSE: returns FALSE)
|
|
*
|
|
* @return array, an array with AppDelegation record
|
|
* @throws Exception, ThrowTheException/FALSE otherwise
|
|
*/
|
|
public function getAppDelegationRecordByPk(
|
|
$applicationUid,
|
|
$delIndex,
|
|
array $arrayVariableNameForException,
|
|
$throwException = true
|
|
) {
|
|
try {
|
|
$obj = AppDelegationPeer::retrieveByPK($applicationUid, $delIndex);
|
|
|
|
if (is_null($obj)) {
|
|
if ($throwException) {
|
|
throw new Exception(G::LoadTranslation(
|
|
'ID_CASE_DEL_INDEX_DOES_NOT_EXIST',
|
|
[
|
|
$arrayVariableNameForException['$applicationUid'],
|
|
$applicationUid,
|
|
$arrayVariableNameForException['$delIndex'],
|
|
$delIndex
|
|
]
|
|
));
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//Return
|
|
return $obj->toArray(BasePeer::TYPE_FIELDNAME);
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get list counters
|
|
*
|
|
* @param string $userUid Unique id of User
|
|
* @param array $arrayType Type lists
|
|
*
|
|
* @return array, the list counters
|
|
* @throws Exception
|
|
*/
|
|
public function getListCounters($userUid, array $arrayType)
|
|
{
|
|
try {
|
|
$appCacheView = new AppCacheView();
|
|
|
|
if ($this->isSolrEnabled()) {
|
|
$arrayListCounter = array_merge(
|
|
$this->solr->getCasesCount($userUid),
|
|
$appCacheView->getAllCounters(['completed', 'cancelled'], $userUid)
|
|
);
|
|
} else {
|
|
$arrayListCounter = $appCacheView->getAllCounters($arrayType, $userUid);
|
|
}
|
|
|
|
//Return
|
|
return $arrayListCounter;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get list of cases from: todo, draft, unassigned
|
|
* Get list of cases for the following REST endpoints:
|
|
* /light/todo
|
|
* /light/draft
|
|
* /light/participated
|
|
* /light/paused
|
|
* /light/unassigned
|
|
*
|
|
* @access public
|
|
* @param array $dataList , Data for list
|
|
* @return array $response
|
|
*/
|
|
public function getList($dataList = array())
|
|
{
|
|
Validator::isArray($dataList, '$dataList');
|
|
if (!isset($dataList["userId"])) {
|
|
$dataList["userId"] = null;
|
|
}
|
|
|
|
//We need to use the USR_UID for the cases in the list
|
|
$userUid = isset($dataList["userUid"]) ? $dataList["userUid"] : $dataList["userId"];
|
|
$callback = isset($dataList["callback"]) ? $dataList["callback"] : "stcCallback1001";
|
|
$dir = isset($dataList["dir"]) ? $dataList["dir"] : "DESC";
|
|
$sort = isset($dataList["sort"]) ? $dataList["sort"] : "APPLICATION.APP_NUMBER";
|
|
if ($sort === 'APP_CACHE_VIEW.APP_NUMBER') {
|
|
$sort = "APPLICATION.APP_NUMBER";
|
|
}
|
|
$start = isset($dataList["start"]) ? $dataList["start"] : "0";
|
|
$limit = isset($dataList["limit"]) ? $dataList["limit"] : "";
|
|
$filter = isset($dataList["filter"]) ? $dataList["filter"] : "";
|
|
$process = isset($dataList["process"]) ? $dataList["process"] : "";
|
|
$category = isset($dataList["category"]) ? $dataList["category"] : "";
|
|
$status = isset($dataList["status"]) ? strtoupper($dataList["status"]) : "";
|
|
$search = isset($dataList["search"]) ? $dataList["search"] : "";
|
|
$action = isset($dataList["action"]) ? $dataList["action"] : "todo";
|
|
$paged = isset($dataList["paged"]) ? $dataList["paged"] : true;
|
|
$type = "extjs";
|
|
$dateFrom = (!empty($dataList["dateFrom"])) ? substr($dataList["dateFrom"], 0, 10) : "";
|
|
$dateTo = (!empty($dataList["dateTo"])) ? substr($dataList["dateTo"], 0, 10) : "";
|
|
$newerThan = (!empty($dataList['newerThan'])) ? $dataList['newerThan'] : '';
|
|
$oldestThan = (!empty($dataList['oldestthan'])) ? $dataList['oldestthan'] : '';
|
|
|
|
$apps = new Applications();
|
|
$response = $apps->getAll(
|
|
$userUid,
|
|
$start,
|
|
$limit,
|
|
$action,
|
|
$filter,
|
|
$search,
|
|
$process,
|
|
$status,
|
|
$type,
|
|
$dateFrom,
|
|
$dateTo,
|
|
$callback,
|
|
$dir,
|
|
(strpos($sort, ".") !== false) ? $sort : "APP_CACHE_VIEW." . $sort,
|
|
$category,
|
|
true,
|
|
$paged,
|
|
$newerThan,
|
|
$oldestThan
|
|
);
|
|
if (!empty($response['data'])) {
|
|
foreach ($response['data'] as &$value) {
|
|
$value = array_change_key_case($value, CASE_LOWER);
|
|
}
|
|
}
|
|
|
|
if ($paged) {
|
|
$response['total'] = $response['totalCount'];
|
|
$response['start'] = $start + 1;
|
|
$response['limit'] = $limit;
|
|
$response['sort'] = G::toLower($sort);
|
|
$response['dir'] = G::toLower($dir);
|
|
$response['cat_uid'] = $category;
|
|
$response['pro_uid'] = $process;
|
|
$response['search'] = $search;
|
|
} else {
|
|
$response = $response['data'];
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* Search cases and get list of cases
|
|
*
|
|
* @access public
|
|
*
|
|
* @param array $dataList, Data for list
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getCasesSearch($dataList = array())
|
|
{
|
|
Validator::isArray($dataList, '$dataList');
|
|
if (!isset($dataList["userId"])) {
|
|
$dataList["userId"] = null;
|
|
}
|
|
|
|
//We need to user the USR_ID for performance
|
|
$userId = $dataList["userId"];
|
|
$dir = isset($dataList["dir"]) ? $dataList["dir"] : "DESC";
|
|
$sort = isset($dataList["sort"]) ? $dataList["sort"] : "APPLICATION.APP_NUMBER";
|
|
if ($sort === 'APP_CACHE_VIEW.APP_NUMBER') {
|
|
$sort = "APPLICATION.APP_NUMBER";
|
|
}
|
|
$start = !empty($dataList["start"]) ? $dataList["start"] : 0;
|
|
$limit = !empty($dataList["limit"]) ? $dataList["limit"] : 15;
|
|
$process = isset($dataList["process"]) ? $dataList["process"] : "";
|
|
$category = isset($dataList["category"]) ? $dataList["category"] : "";
|
|
$status = isset($dataList["status"]) ? strtoupper($dataList["status"]) : "";
|
|
$user = isset($dataList["user"]) ? $dataList["user"] : "";
|
|
$search = isset($dataList["search"]) ? $dataList["search"] : "";
|
|
$dateFrom = (!empty($dataList["dateFrom"])) ? substr($dataList["dateFrom"], 0, 10) : "";
|
|
$dateTo = (!empty($dataList["dateTo"])) ? substr($dataList["dateTo"], 0, 10) : "";
|
|
$filterStatus = isset($dataList["filterStatus"]) ? strtoupper($dataList["filterStatus"]) : "";
|
|
|
|
$apps = new Applications();
|
|
$response = $apps->searchAll(
|
|
$userId,
|
|
$start,
|
|
$limit,
|
|
$search,
|
|
$process,
|
|
$filterStatus,
|
|
$dir,
|
|
$sort,
|
|
$category,
|
|
$dateFrom,
|
|
$dateTo
|
|
);
|
|
|
|
$response['total'] = 0;
|
|
$response['start'] = $start + 1;
|
|
$response['limit'] = $limit;
|
|
$response['sort'] = G::toLower($sort);
|
|
$response['dir'] = G::toLower($dir);
|
|
$response['cat_uid'] = $category;
|
|
$response['pro_uid'] = $process;
|
|
$response['search'] = $search;
|
|
$response['app_status'] = G::toLower($status);
|
|
$response['usr_uid'] = $user;
|
|
$response['date_from'] = $dateFrom;
|
|
$response['date_to'] = $dateTo;
|
|
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* Verify if Solr is Enabled
|
|
*
|
|
* @return bool
|
|
*/
|
|
private function isSolrEnabled()
|
|
{
|
|
$solrEnabled = false;
|
|
$this->solrEnv = !empty($this->solrEnv) ? $this->solrEnv : System::solrEnv();
|
|
if ($this->solrEnv !== false) {
|
|
$this->solr = !empty($this->solr) ? $this->solr : new AppSolr(
|
|
$this->solrEnv['solr_enabled'],
|
|
$this->solrEnv['solr_host'],
|
|
$this->solrEnv['solr_instance']
|
|
);
|
|
if ($this->solr->isSolrEnabled() && $this->solrEnv["solr_enabled"] == true) {
|
|
$solrEnabled = true;
|
|
}
|
|
}
|
|
return $solrEnabled;
|
|
}
|
|
|
|
/**
|
|
* Get data of a Case
|
|
*
|
|
* @param string $applicationUid Unique id of Case
|
|
* @param string $userUid Unique id of User
|
|
*
|
|
* @return object
|
|
* @throws Exception
|
|
*/
|
|
public function getCaseInfo($applicationUid, $userUid)
|
|
{
|
|
try {
|
|
if ($this->isSolrEnabled()) {
|
|
try {
|
|
//Check if there are missing records to reindex and reindex them
|
|
$this->solr->synchronizePendingApplications();
|
|
|
|
$arrayData = array();
|
|
$delegationIndexes = array();
|
|
$columsToInclude = array("APP_UID");
|
|
$solrSearchText = null;
|
|
//Todo
|
|
$solrSearchText = $solrSearchText . (($solrSearchText != null) ? " OR " : null) . "(APP_STATUS:TO_DO AND APP_ASSIGNED_USERS:" . $userUid . ")";
|
|
$delegationIndexes[] = "APP_ASSIGNED_USER_DEL_INDEX_" . $userUid . "_txt";
|
|
//Draft
|
|
$solrSearchText = $solrSearchText . (($solrSearchText != null) ? " OR " : null) . "(APP_STATUS:DRAFT AND APP_DRAFT_USER:" . $userUid . ")";
|
|
//Index is allways 1
|
|
$solrSearchText = "($solrSearchText)";
|
|
//Add del_index dynamic fields to list of resulting columns
|
|
$columsToIncludeFinal = array_merge($columsToInclude, $delegationIndexes);
|
|
$solrRequestData = EntitySolrRequestData::createForRequestPagination(
|
|
array(
|
|
"workspace" => $this->solrEnv["solr_instance"],
|
|
"startAfter" => 0,
|
|
"pageSize" => 1000,
|
|
"searchText" => $solrSearchText,
|
|
"numSortingCols" => 1,
|
|
"sortCols" => array("APP_NUMBER"),
|
|
"sortDir" => array(strtolower("DESC")),
|
|
"includeCols" => $columsToIncludeFinal,
|
|
"resultFormat" => "json"
|
|
)
|
|
);
|
|
//Use search index to return list of cases
|
|
$searchIndex = new BpmnEngineServicesSearchIndex($this->solr->isSolrEnabled(), $this->solrEnv["solr_host"]);
|
|
//Execute query
|
|
$solrQueryResult = $searchIndex->getDataTablePaginatedList($solrRequestData);
|
|
//Get the missing data from database
|
|
$arrayApplicationUid = array();
|
|
foreach ($solrQueryResult->aaData as $i => $data) {
|
|
$arrayApplicationUid[] = $data["APP_UID"];
|
|
}
|
|
$aaappsDBData = $this->solr->getListApplicationDelegationData($arrayApplicationUid);
|
|
foreach ($solrQueryResult->aaData as $i => $data) {
|
|
//Initialize array
|
|
$delIndexes = array(); //Store all the delegation indexes
|
|
//Complete empty values
|
|
$applicationUid = $data["APP_UID"]; //APP_UID
|
|
//Get all the indexes returned by Solr as columns
|
|
for ($i = count($columsToInclude); $i <= count($data) - 1; $i++) {
|
|
if (is_array($data[$columsToIncludeFinal[$i]])) {
|
|
foreach ($data[$columsToIncludeFinal[$i]] as $delIndex) {
|
|
$delIndexes[] = $delIndex;
|
|
}
|
|
}
|
|
}
|
|
//Verify if the delindex is an array
|
|
//if is not check different types of repositories
|
|
//the delegation index must always be defined.
|
|
if (count($delIndexes) == 0) {
|
|
$delIndexes[] = 1; // the first default index
|
|
}
|
|
//Remove duplicated
|
|
$delIndexes = array_unique($delIndexes);
|
|
//Get records
|
|
foreach ($delIndexes as $delIndex) {
|
|
$aRow = array();
|
|
//Copy result values to new row from Solr server
|
|
$aRow["APP_UID"] = $data["APP_UID"];
|
|
//Get delegation data from DB
|
|
//Filter data from db
|
|
$indexes = $this->solr->aaSearchRecords($aaappsDBData, array(
|
|
"APP_UID" => $applicationUid,
|
|
"DEL_INDEX" => $delIndex
|
|
));
|
|
foreach ($indexes as $index) {
|
|
$row = $aaappsDBData[$index];
|
|
}
|
|
if (!isset($row)) {
|
|
continue;
|
|
}
|
|
$ws = new WsBase();
|
|
$fields = $ws->getCaseInfo($applicationUid, $row["DEL_INDEX"]);
|
|
$array = json_decode(json_encode($fields), true);
|
|
if ($array ["status_code"] != 0) {
|
|
throw (new Exception($array ["message"]));
|
|
} else {
|
|
$array['app_uid'] = $array['caseId'];
|
|
$array['app_number'] = $array['caseNumber'];
|
|
$array['app_name'] = $array['caseName'];
|
|
$array['app_status'] = $array['caseStatus'];
|
|
$array['app_init_usr_uid'] = $array['caseCreatorUser'];
|
|
$array['app_init_usr_username'] = trim($array['caseCreatorUserName']);
|
|
$array['pro_uid'] = $array['processId'];
|
|
$array['pro_name'] = $array['processName'];
|
|
$array['app_create_date'] = $array['createDate'];
|
|
$array['app_update_date'] = $array['updateDate'];
|
|
$array['current_task'] = $array['currentUsers'];
|
|
for ($i = 0; $i <= count($array['current_task']) - 1; $i++) {
|
|
$current_task = $array['current_task'][$i];
|
|
$current_task['usr_uid'] = $current_task['userId'];
|
|
$current_task['usr_name'] = trim($current_task['userName']);
|
|
$current_task['tas_uid'] = $current_task['taskId'];
|
|
$current_task['tas_title'] = $current_task['taskName'];
|
|
$current_task['del_index'] = $current_task['delIndex'];
|
|
$current_task['del_thread'] = $current_task['delThread'];
|
|
$current_task['del_thread_status'] = $current_task['delThreadStatus'];
|
|
unset($current_task['userId']);
|
|
unset($current_task['userName']);
|
|
unset($current_task['taskId']);
|
|
unset($current_task['taskName']);
|
|
unset($current_task['delIndex']);
|
|
unset($current_task['delThread']);
|
|
unset($current_task['delThreadStatus']);
|
|
$aCurrent_task[] = $current_task;
|
|
}
|
|
unset($array['status_code']);
|
|
unset($array['message']);
|
|
unset($array['timestamp']);
|
|
unset($array['caseParalell']);
|
|
unset($array['caseId']);
|
|
unset($array['caseNumber']);
|
|
unset($array['caseName']);
|
|
unset($array['caseStatus']);
|
|
unset($array['caseCreatorUser']);
|
|
unset($array['caseCreatorUserName']);
|
|
unset($array['processId']);
|
|
unset($array['processName']);
|
|
unset($array['createDate']);
|
|
unset($array['updateDate']);
|
|
unset($array['currentUsers']);
|
|
$current_task = json_decode(json_encode($aCurrent_task), false);
|
|
$oResponse = json_decode(json_encode($array), false);
|
|
$oResponse->current_task = $current_task;
|
|
}
|
|
|
|
//Return
|
|
return $oResponse;
|
|
}
|
|
}
|
|
} catch (InvalidIndexSearchTextException $e) {
|
|
$arrayData = array();
|
|
$arrayData[] = array(
|
|
"app_uid" => $e->getMessage(),
|
|
"app_name" => $e->getMessage(),
|
|
"del_index" => $e->getMessage(),
|
|
"pro_uid" => $e->getMessage()
|
|
);
|
|
throw (new Exception($arrayData));
|
|
}
|
|
} else {
|
|
$ws = new WsBase();
|
|
$fields = $ws->getCaseInfo($applicationUid, 0);
|
|
$array = json_decode(json_encode($fields), true);
|
|
|
|
if ($array ["status_code"] != 0) {
|
|
throw (new Exception($array ["message"]));
|
|
} else {
|
|
$array['app_uid'] = $array['caseId'];
|
|
$array['app_number'] = $array['caseNumber'];
|
|
$array['app_name'] = $array['caseName'];
|
|
$array["app_status"] = $array["caseStatus"];
|
|
$array['app_init_usr_uid'] = $array['caseCreatorUser'];
|
|
$array['app_init_usr_username'] = trim($array['caseCreatorUserName']);
|
|
$array['pro_uid'] = $array['processId'];
|
|
$array['pro_name'] = $array['processName'];
|
|
$array['app_create_date'] = $array['createDate'];
|
|
$array['app_update_date'] = $array['updateDate'];
|
|
$array['current_task'] = $array['currentUsers'];
|
|
|
|
$aCurrent_task = array();
|
|
|
|
for ($i = 0; $i <= count($array['current_task']) - 1; $i++) {
|
|
$current_task = $array['current_task'][$i];
|
|
$current_task['usr_uid'] = $current_task['userId'];
|
|
$current_task['usr_name'] = trim($current_task['userName']);
|
|
$current_task['tas_uid'] = $current_task['taskId'];
|
|
$current_task['tas_title'] = $current_task['taskName'];
|
|
$current_task['del_index'] = $current_task['delIndex'];
|
|
$current_task['del_thread'] = $current_task['delThread'];
|
|
$current_task['del_thread_status'] = $current_task['delThreadStatus'];
|
|
$current_task["del_init_date"] = $current_task["delInitDate"] . "";
|
|
$current_task["del_task_due_date"] = $current_task["delTaskDueDate"];
|
|
unset($current_task['userId']);
|
|
unset($current_task['userName']);
|
|
unset($current_task['taskId']);
|
|
unset($current_task['taskName']);
|
|
unset($current_task['delIndex']);
|
|
unset($current_task['delThread']);
|
|
unset($current_task['delThreadStatus']);
|
|
$aCurrent_task[] = $current_task;
|
|
}
|
|
unset($array['status_code']);
|
|
unset($array['message']);
|
|
unset($array['timestamp']);
|
|
unset($array['caseParalell']);
|
|
unset($array['caseId']);
|
|
unset($array['caseNumber']);
|
|
unset($array['caseName']);
|
|
unset($array['caseStatus']);
|
|
unset($array['caseCreatorUser']);
|
|
unset($array['caseCreatorUserName']);
|
|
unset($array['processId']);
|
|
unset($array['processName']);
|
|
unset($array['createDate']);
|
|
unset($array['updateDate']);
|
|
unset($array['currentUsers']);
|
|
}
|
|
$current_task = json_decode(json_encode($aCurrent_task), false);
|
|
$oResponse = json_decode(json_encode($array), false);
|
|
$oResponse->current_task = $current_task;
|
|
|
|
//Return
|
|
return $oResponse;
|
|
}
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get data of a sub-process case
|
|
*
|
|
* @param string $applicationUid Unique Case Id
|
|
* @param string $userUid Unique User Id
|
|
*
|
|
* @return array Return an array with information of Cases
|
|
* @throws Exception
|
|
*/
|
|
public function getCaseInfoSubProcess($applicationUid, $userUid)
|
|
{
|
|
|
|
try {
|
|
$response = [];
|
|
$subApplication = new SubApplication();
|
|
$data = $subApplication->loadByAppUidParent($applicationUid);
|
|
if (!empty($data)) {
|
|
foreach ($data as $item) {
|
|
$response[] = $this->getCaseInfo($item['APP_UID'], $userUid);
|
|
}
|
|
} else {
|
|
throw new Exception(G::LoadTranslation("ID_CASE_DOES_NOT_EXIST", [$applicationUid]));
|
|
}
|
|
|
|
return $response;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get data Task Case
|
|
*
|
|
* @param string $applicationUid Unique id of Case
|
|
* @param string $userUid Unique id of User
|
|
*
|
|
* @return array, an array with Task Case
|
|
* @throws Exception
|
|
*/
|
|
public function getTaskCase($applicationUid, $userUid)
|
|
{
|
|
try {
|
|
//Verify data
|
|
$this->throwExceptionIfNotExistsCase($applicationUid, 0, $this->getFieldNameByFormatFieldName("APP_UID"));
|
|
|
|
$criteria = new Criteria("workflow");
|
|
|
|
$criteria->addSelectColumn(ApplicationPeer::APP_UID);
|
|
|
|
$criteria->add(ApplicationPeer::APP_UID, $applicationUid, Criteria::EQUAL);
|
|
$criteria->add(ApplicationPeer::APP_STATUS, "COMPLETED", Criteria::EQUAL);
|
|
|
|
$rsCriteria = ApplicationPeer::doSelectRS($criteria);
|
|
|
|
if ($rsCriteria->next()) {
|
|
throw new Exception(G::LoadTranslation("ID_CASE_NO_CURRENT_TASKS_BECAUSE_CASE_ITS_COMPLETED",
|
|
array($this->getFieldNameByFormatFieldName("APP_UID"), $applicationUid)));
|
|
}
|
|
|
|
//Get data
|
|
$result = array();
|
|
|
|
$oCriteria = new Criteria('workflow');
|
|
$del = DBAdapter::getStringDelimiter();
|
|
$oCriteria->addSelectColumn(AppDelegationPeer::DEL_INDEX);
|
|
$oCriteria->addSelectColumn(AppDelegationPeer::TAS_UID);
|
|
$oCriteria->addSelectColumn(AppDelegationPeer::DEL_INIT_DATE);
|
|
$oCriteria->addSelectColumn(AppDelegationPeer::DEL_TASK_DUE_DATE);
|
|
$oCriteria->addSelectColumn(TaskPeer::TAS_TITLE);
|
|
$oCriteria->addJoin(AppDelegationPeer::TAS_UID, TaskPeer::TAS_UID);
|
|
$oCriteria->add(AppDelegationPeer::APP_UID, $applicationUid);
|
|
$oCriteria->add(AppDelegationPeer::USR_UID, $userUid);
|
|
$oCriteria->add(AppDelegationPeer::DEL_THREAD_STATUS, 'OPEN');
|
|
$oCriteria->add(AppDelegationPeer::DEL_FINISH_DATE, null, Criteria::ISNULL);
|
|
$oDataset = AppDelegationPeer::doSelectRS($oCriteria);
|
|
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$oDataset->next();
|
|
while ($aRow = $oDataset->getRow()) {
|
|
$result = array(
|
|
'tas_uid' => $aRow['TAS_UID'],
|
|
'tas_title' => $aRow['TAS_TITLE'],
|
|
'del_index' => $aRow['DEL_INDEX'],
|
|
"del_init_date" => $aRow["DEL_INIT_DATE"] . "",
|
|
"del_task_due_date" => $aRow["DEL_TASK_DUE_DATE"]
|
|
);
|
|
$oDataset->next();
|
|
}
|
|
//Return
|
|
if (empty($result)) {
|
|
throw new Exception(G::LoadTranslation("ID_CASES_INCORRECT_INFORMATION", array($applicationUid)));
|
|
} else {
|
|
return $result;
|
|
}
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add New Case
|
|
*
|
|
* @param string $processUid Unique id of Project
|
|
* @param string $taskUid Unique id of Activity (task)
|
|
* @param string $userUid Unique id of Case
|
|
* @param array $variables
|
|
*
|
|
* @return object
|
|
* @throws Exception
|
|
*/
|
|
public function addCase($processUid, $taskUid, $userUid, $variables)
|
|
{
|
|
try {
|
|
|
|
$ws = new WsBase();
|
|
if ($variables) {
|
|
$variables = array_shift($variables);
|
|
}
|
|
Validator::proUid($processUid, '$pro_uid');
|
|
$oTask = new ModelTask();
|
|
if (!$oTask->taskExists($taskUid)) {
|
|
throw new Exception(G::LoadTranslation("ID_INVALID_VALUE_FOR", array('tas_uid')));
|
|
}
|
|
$fields = $ws->newCase($processUid, $userUid, $taskUid, $variables);
|
|
$array = json_decode(json_encode($fields), true);
|
|
if ($array ["status_code"] != 0) {
|
|
throw (new Exception($array ["message"]));
|
|
} else {
|
|
$array['app_uid'] = $array['caseId'];
|
|
$array['app_number'] = $array['caseNumber'];
|
|
unset($array['status_code']);
|
|
unset($array['message']);
|
|
unset($array['timestamp']);
|
|
unset($array['caseId']);
|
|
unset($array['caseNumber']);
|
|
}
|
|
$oResponse = json_decode(json_encode($array), false);
|
|
|
|
//Return
|
|
return $oResponse;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add New Case Impersonate
|
|
*
|
|
* @param string $processUid Unique id of Project
|
|
* @param string $userUid Unique id of User
|
|
* @param string $taskUid Unique id of Case
|
|
* @param array $variables
|
|
*
|
|
* @return object
|
|
* @throws Exception
|
|
*/
|
|
public function addCaseImpersonate($processUid, $userUid, $taskUid, $variables)
|
|
{
|
|
try {
|
|
|
|
$ws = new WsBase();
|
|
if ($variables) {
|
|
$variables = array_shift($variables);
|
|
} elseif ($variables == null) {
|
|
$variables = array(array());
|
|
}
|
|
Validator::proUid($processUid, '$pro_uid');
|
|
$user = new ModelUsers();
|
|
if (!$user->userExists($userUid)) {
|
|
throw new Exception(G::LoadTranslation("ID_INVALID_VALUE_FOR", array('usr_uid')));
|
|
}
|
|
$fields = $ws->newCaseImpersonate($processUid, $userUid, $variables, $taskUid);
|
|
$array = json_decode(json_encode($fields), true);
|
|
if ($array ["status_code"] != 0) {
|
|
if ($array ["status_code"] == 12) {
|
|
throw (new Exception(G::loadTranslation('ID_NO_STARTING_TASK') . '. tas_uid.'));
|
|
} elseif ($array ["status_code"] == 13) {
|
|
throw (new Exception(G::loadTranslation('ID_MULTIPLE_STARTING_TASKS') . '. tas_uid.'));
|
|
}
|
|
throw (new Exception($array ["message"]));
|
|
} else {
|
|
$array['app_uid'] = $array['caseId'];
|
|
$array['app_number'] = $array['caseNumber'];
|
|
unset($array['status_code']);
|
|
unset($array['message']);
|
|
unset($array['timestamp']);
|
|
unset($array['caseId']);
|
|
unset($array['caseNumber']);
|
|
}
|
|
$oResponse = json_decode(json_encode($array), false);
|
|
|
|
//Return
|
|
return $oResponse;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
/**
|
|
* This function check if some user has participation over the case
|
|
*
|
|
* @param string $usrUid
|
|
* @param int $caseNumber
|
|
* @param int $index
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function participation($usrUid, $caseNumber, $index)
|
|
{
|
|
$userId = User::getId($usrUid);
|
|
$query = Delegation::query()->select(['APP_NUMBER'])->case($caseNumber)->index($index)->openAndPause();
|
|
$query1 = clone $query;
|
|
$result = $query->userId($userId)->limit(1)->get()->values()->toArray();
|
|
$permission = empty($result) ? false : true;
|
|
// Review if the user is supervisor
|
|
if (empty($result)) {
|
|
$processes = ProcessUser::getProcessesOfSupervisor($usrUid);
|
|
$query1->processInList($processes);
|
|
$result = $query1->get()->values()->toArray();
|
|
$permission = empty($result) ? false : true;
|
|
}
|
|
|
|
return $permission;
|
|
}
|
|
|
|
/**
|
|
* Review if the user is supervisor
|
|
*
|
|
* @param string $usrUid
|
|
* @param int $caseNumber
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isSupervisor(string $usrUid, int $caseNumber)
|
|
{
|
|
$result = [];
|
|
$user = new BmUser();
|
|
if ($user->checkPermission($usrUid, 'PM_SUPERVISOR')) {
|
|
$processes = ProcessUser::getProcessesOfSupervisor($usrUid);
|
|
$query = Delegation::query()->select(['APP_NUMBER'])->case($caseNumber)->processInList($processes);
|
|
$result = $query->get()->values()->toArray();
|
|
}
|
|
return !empty($result);
|
|
}
|
|
|
|
/**
|
|
* Reassign Case
|
|
*
|
|
* @param string $appUid Unique id of Case
|
|
* @param string $usrUid Unique id of User
|
|
* @param int $delIndex
|
|
* @param string $userSource Unique id of User Source
|
|
* @param string $userTarget $userUidTarget id of User Target
|
|
* @param string $reason
|
|
* @param boolean $sendMail
|
|
*
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
public function updateReassignCase($appUid, $usrUid, $delIndex, $userSource, $userTarget, $reason = '', $sendMail = false)
|
|
{
|
|
try {
|
|
if (!$delIndex) {
|
|
$delIndex = AppDelegation::getCurrentIndex($appUid);
|
|
}
|
|
|
|
/** Reassign case */
|
|
$ws = new WsBase();
|
|
$result = $ws->reassignCase($usrUid, $appUid, $delIndex, $userSource, $userTarget);
|
|
$result = (object)$result;
|
|
if (isset($result->status_code)) {
|
|
if ($result->status_code !== 0) {
|
|
throw new Exception($result->message);
|
|
}
|
|
} else {
|
|
throw new Exception(G::LoadTranslation("ID_CASES_INCORRECT_INFORMATION", [$appUid]));
|
|
}
|
|
|
|
/** Add the note */
|
|
if (!empty($reason)) {
|
|
$noteContent = $reason;
|
|
// Define the Case for register a case note
|
|
$cases = new BmCases();
|
|
$response = $cases->addNote($appUid, $usrUid, $noteContent, $sendMail);
|
|
}
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Put cancel case
|
|
*
|
|
* @access public
|
|
* @param string $appUid, Uid for case
|
|
* @param string $usrUid, Uid for user
|
|
* @param interger $delIndex
|
|
*
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
public function putCancelCase($appUid, $usrUid, $delIndex = null, $reason = '', $sendMail = false)
|
|
{
|
|
Validator::isString($appUid, '$app_uid');
|
|
Validator::appUid($appUid, '$app_uid');
|
|
Validator::isString($usrUid, '$usr_uid');
|
|
Validator::usrUid($usrUid, '$usr_uid');
|
|
|
|
$case = new ClassesCases();
|
|
$fields = $case->loadCase($appUid);
|
|
$supervisor = new BmProcessSupervisor();
|
|
$isSupervisor = $supervisor->isUserProcessSupervisor($fields['PRO_UID'], $usrUid);
|
|
|
|
if (is_null($delIndex)) {
|
|
$u = new ModelUsers();
|
|
$usrId = $u->load($usrUid)['USR_ID'];
|
|
|
|
if ($isSupervisor) {
|
|
//Get the last index open
|
|
$delIndex = AppDelegation::getLastIndexByStatus($fields['APP_NUMBER']);
|
|
} else {
|
|
//Get the last index open related to the user
|
|
$delIndex = AppDelegation::getLastIndexByUserAndStatus($fields['APP_NUMBER'], $usrId);
|
|
}
|
|
|
|
//We will to validate when the case is TO_DO and the user does not have a index OPEN
|
|
//The scenarios with COMPLETED, CANCELLED and DRAFT is considered in the WsBase::cancelCase
|
|
if ($fields['APP_STATUS'] === 'TO_DO' && $delIndex === 0) {
|
|
throw (new Exception(G::LoadTranslation("ID_CASE_USER_INVALID_CANCEL_CASE", [$usrUid])));
|
|
}
|
|
}
|
|
Validator::isInteger($delIndex, '$del_index');
|
|
|
|
/** Cancel case */
|
|
$ws = new WsBase();
|
|
$result = $ws->cancelCase($appUid, $delIndex, $usrUid);
|
|
$result = (object)$result;
|
|
if ($result->status_code !== 0) {
|
|
throw new Exception($result->message);
|
|
}
|
|
/** Add the note */
|
|
if (!empty($reason)) {
|
|
$noteContent = $reason;
|
|
// Define the Case for register a case note
|
|
$cases = new BmCases();
|
|
$response = $cases->addNote($appUid, $usrUid, $noteContent, $sendMail);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Put pause case
|
|
*
|
|
* @access public
|
|
* @param string $appUid , Uid for case
|
|
* @param string $usrUid , Uid for user
|
|
* @param bool|string $index
|
|
* @param null|string $date , Date for unpaused
|
|
* @param string $time , Time for unpaused
|
|
* @param string $reason
|
|
* @param bool $sendMail
|
|
*
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
public function putPauseCase($appUid, $usrUid, $index = 0, $date = null, $time = '00:00', $reason = '', $sendMail = false)
|
|
{
|
|
Validator::isString($appUid, '$app_uid');
|
|
Validator::isString($usrUid, '$usr_uid');
|
|
Validator::appUid($appUid, '$app_uid');
|
|
Validator::usrUid($usrUid, '$usr_uid');
|
|
Validator::isInteger($index, '$del_index');
|
|
// Get the last index
|
|
if ($index === 0) {
|
|
$index = AppDelegation::getCurrentIndex($appUid);
|
|
}
|
|
// Get the case status
|
|
$case = new ClassesCases();
|
|
$fields = $case->loadCase($appUid);
|
|
$caseNumber = $fields['APP_NUMBER'];
|
|
if ($fields['APP_STATUS'] == 'CANCELLED') {
|
|
throw new Exception(G::LoadTranslation("ID_CASE_IS_CANCELED", [$appUid]));
|
|
}
|
|
// Check if the case was not paused
|
|
$delay = new AppDelay();
|
|
if ($delay->isPaused($appUid, $index)) {
|
|
throw new Exception(G::LoadTranslation("ID_CASE_PAUSED", [$appUid]));
|
|
}
|
|
// Review if the user has participation or is supervisor
|
|
$permission = $this->participation($usrUid, $caseNumber, $index);
|
|
if (!$permission) {
|
|
throw new Exception(G::LoadTranslation("ID_CASE_USER_INVALID_PAUSED_CASE", [$usrUid]));
|
|
}
|
|
|
|
if ($date != null) {
|
|
Validator::isDate($date, 'Y-m-d', '$unpaused_date');
|
|
}
|
|
|
|
// Check if the case is unassigned
|
|
$classCases = new ClassesCases();
|
|
if ($classCases->isUnassignedPauseCase($appUid, $index)) {
|
|
throw new Exception(G::LoadTranslation("ID_CASE_NOT_PAUSED", [G::LoadTranslation("ID_UNASSIGNED_STATUS")]));
|
|
}
|
|
|
|
/** Pause case */
|
|
$case->pauseCase($appUid, $index, $usrUid, $date . ' ' . $time);
|
|
|
|
/** Add the note */
|
|
if (!empty($reason)) {
|
|
$noteContent = $reason;
|
|
// Define the Case for register a case note
|
|
$cases = new BmCases();
|
|
$response = $cases->addNote($appUid, $usrUid, $noteContent, $sendMail);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Put unpause case
|
|
*
|
|
* @access public
|
|
* @param string $app_uid , Uid for case
|
|
* @param string $usr_uid , Uid for user
|
|
* @param int $del_index
|
|
*
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
public function putUnpauseCase($appUid, $usrUid, $index = 0)
|
|
{
|
|
Validator::isString($appUid, '$app_uid');
|
|
Validator::isString($usrUid, '$usr_uid');
|
|
Validator::appUid($appUid, '$app_uid');
|
|
Validator::usrUid($usrUid, '$usr_uid');
|
|
|
|
if ($index === 0) {
|
|
$index = AppDelegation::getCurrentIndex($appUid);
|
|
}
|
|
Validator::isInteger($index, '$del_index');
|
|
|
|
$delay = new AppDelay();
|
|
if (!$delay->isPaused($appUid, $index)) {
|
|
throw new Exception(G::LoadTranslation("ID_CASE_NOT_PAUSED", [$appUid]));
|
|
}
|
|
|
|
// Review if the user has participation or is supervisor
|
|
$caseNumber = ModelApplication::getCaseNumber($appUid);
|
|
$permission = $this->participation($usrUid, $caseNumber, $index);
|
|
if (!$permission) {
|
|
throw new Exception(G::LoadTranslation("ID_CASE_USER_INVALID_UNPAUSE_CASE", [$usrUid]));
|
|
}
|
|
|
|
/** Unpause case */
|
|
$case = new ClassesCases();
|
|
$case->unpauseCase($appUid, $index, $usrUid);
|
|
}
|
|
|
|
/**
|
|
* Put claim case
|
|
*
|
|
* @param string $appUid
|
|
* @param integer $index
|
|
* @param string $userUid
|
|
*
|
|
* @return void
|
|
* @throws Exception
|
|
*
|
|
* @access public
|
|
*/
|
|
public function putClaimCase($appUid, $index, $userUid)
|
|
{
|
|
// Validate the parameters
|
|
Validator::isString($appUid, '$appUid');
|
|
Validator::isString($userUid, '$userUid');
|
|
Validator::isInteger($index, '$index');
|
|
Validator::appUid($appUid, '$appUid');
|
|
Validator::usrUid($userUid, '$userUid');
|
|
|
|
// Review if the user can claim the case
|
|
$appDelegation = new AppDelegation();
|
|
$delegation = $appDelegation->load($appUid, $index);
|
|
if (empty($delegation['USR_UID'])) {
|
|
$case = new ClassesCases();
|
|
$case->loadCase($appUid);
|
|
|
|
//Review if the user can be claim the case
|
|
if (!$case->isSelfService($userUid, $delegation['TAS_UID'], $appUid)) {
|
|
$message = preg_replace("#<br\s*/?>#i", "", G::LoadTranslation("ID_NO_PERMISSION_NO_PARTICIPATED"));
|
|
throw new Exception($message);
|
|
}
|
|
|
|
$case->setCatchUser($appUid, $index, $userUid);
|
|
} else {
|
|
throw new Exception(G::LoadTranslation("ID_CASE_USER_INVALID_CLAIM_CASE", [$userUid]));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Put execute trigger case
|
|
*
|
|
* @access public
|
|
* @param string $appUid , Uid for case
|
|
* @param string $triUid , Uid for trigger
|
|
* @param string $userUid , Uid for user
|
|
* @param bool|string $delIndex
|
|
*
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
public function putExecuteTriggerCase($appUid, $triUid, $userUid, $delIndex = false)
|
|
{
|
|
Validator::isString($appUid, '$appUid');
|
|
Validator::isString($triUid, '$triUid');
|
|
Validator::isString($userUid, '$userUid');
|
|
|
|
Validator::appUid($appUid, '$appUid');
|
|
Validator::triUid($triUid, '$triUid');
|
|
Validator::usrUid($userUid, '$userUid');
|
|
|
|
if ($delIndex === false) {
|
|
//We need to find the last delIndex open related to the user $usr_uid
|
|
$delIndex = (integer)$this->getLastParticipatedByUser($appUid, $userUid, 'OPEN');
|
|
//If the is assigned another user the function will be return 0
|
|
if ($delIndex === 0) {
|
|
throw new Exception(G::loadTranslation('ID_CASE_ASSIGNED_ANOTHER_USER'));
|
|
}
|
|
}
|
|
Validator::isInteger($delIndex, '$del_index');
|
|
|
|
global $RBAC;
|
|
if (!method_exists($RBAC, 'initRBAC')) {
|
|
$RBAC = RBAC::getSingleton(PATH_DATA, session_id());
|
|
$RBAC->sSystem = 'PROCESSMAKER';
|
|
}
|
|
|
|
$case = new WsBase();
|
|
$result = $case->executeTrigger($userUid, $appUid, $triUid, $delIndex);
|
|
|
|
if ($result->status_code != 0) {
|
|
throw new Exception($result->message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete case
|
|
*
|
|
* @access public
|
|
* @param string $appUid, Uid for case
|
|
* @param string $usrUid, Uid user
|
|
*
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
public function deleteCase($appUid, $usrUid)
|
|
{
|
|
Validator::isString($appUid, '$app_uid');
|
|
Validator::appUid($appUid, '$app_uid');
|
|
|
|
// Review the status and owner
|
|
$caseInfo = ModelApplication::getCase($appUid);
|
|
if (!empty($caseInfo)) {
|
|
// Check if the requester is the owner
|
|
if ($caseInfo['APP_INIT_USER'] !== $usrUid) {
|
|
global $RBAC;
|
|
// If no we need to review if have the permission
|
|
if ($RBAC->userCanAccess('PM_DELETECASE') != 1) {
|
|
throw new Exception(G::LoadTranslation('ID_NOT_ABLE_DELETE_CASES'));
|
|
}
|
|
}
|
|
|
|
// Review the status
|
|
if ($caseInfo['APP_STATUS'] != 'DRAFT') {
|
|
throw new Exception(G::LoadTranslation("ID_DELETE_CASE_NO_STATUS"));
|
|
}
|
|
|
|
$case = new ClassesCases();
|
|
$case->removeCase($appUid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Route Case
|
|
*
|
|
* @param string $applicationUid Unique id of Case
|
|
* @param string $userUid Unique id of User
|
|
* @param string $delIndex
|
|
* @param boolean $executeTriggersBeforeAssignment
|
|
*
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
public function updateRouteCase($applicationUid, $userUid, $delIndex, $executeTriggersBeforeAssignment)
|
|
{
|
|
try {
|
|
if (!$delIndex) {
|
|
$delIndex = AppDelegation::getCurrentIndex($applicationUid);
|
|
//Check if the next task is a subprocess SYNCHRONOUS with a thread Open
|
|
$subAppData = new SubApplication();
|
|
$caseSubprocessPending = $subAppData->isSubProcessWithCasePending($applicationUid, $delIndex);
|
|
if ($caseSubprocessPending) {
|
|
throw (new Exception(G::LoadTranslation("ID_CASE_ALREADY_DERIVATED")));
|
|
}
|
|
}
|
|
|
|
$ws = new WsBase();
|
|
$fields = $ws->derivateCase($userUid, $applicationUid, $delIndex, $executeTriggersBeforeAssignment);
|
|
$array = json_decode(json_encode($fields), true);
|
|
if ($array ["status_code"] != 0) {
|
|
throw (new Exception($array ["message"]));
|
|
} else {
|
|
unset($array['status_code']);
|
|
unset($array['message']);
|
|
unset($array['timestamp']);
|
|
}
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get all upload document that they have send it
|
|
*
|
|
* @param string $sProcessUID Unique id of Process
|
|
* @param string $sApplicationUID Unique id of Case
|
|
* @param string $sTasKUID Unique id of Activity
|
|
* @param string $sUserUID Unique id of User
|
|
*
|
|
* @return object
|
|
* @throws Exception
|
|
*/
|
|
public function getAllUploadedDocumentsCriteria($sProcessUID, $sApplicationUID, $sTasKUID, $sUserUID)
|
|
{
|
|
|
|
$conf = new Configurations();
|
|
$confEnvSetting = $conf->getFormats();
|
|
|
|
$cases = new ClassesCases();
|
|
|
|
$listing = false;
|
|
$oPluginRegistry = PluginRegistry::loadSingleton();
|
|
if ($oPluginRegistry->existsTrigger(PM_CASE_DOCUMENT_LIST)) {
|
|
$folderData = new \folderData(null, null, $sApplicationUID, null, $sUserUID);
|
|
$folderData->PMType = "INPUT";
|
|
$folderData->returnList = true;
|
|
$listing = $oPluginRegistry->executeTriggers(PM_CASE_DOCUMENT_LIST, $folderData);
|
|
}
|
|
$aObjectPermissions = $cases->getAllObjects($sProcessUID, $sApplicationUID, $sTasKUID, $sUserUID);
|
|
if (!is_array($aObjectPermissions)) {
|
|
$aObjectPermissions = array(
|
|
'DYNAFORMS' => array(-1),
|
|
'INPUT_DOCUMENTS' => array(-1),
|
|
'OUTPUT_DOCUMENTS' => array(-1)
|
|
);
|
|
}
|
|
if (!isset($aObjectPermissions['DYNAFORMS'])) {
|
|
$aObjectPermissions['DYNAFORMS'] = array(-1);
|
|
} else {
|
|
if (!is_array($aObjectPermissions['DYNAFORMS'])) {
|
|
$aObjectPermissions['DYNAFORMS'] = array(-1);
|
|
}
|
|
}
|
|
if (!isset($aObjectPermissions['INPUT_DOCUMENTS'])) {
|
|
$aObjectPermissions['INPUT_DOCUMENTS'] = array(-1);
|
|
} else {
|
|
if (!is_array($aObjectPermissions['INPUT_DOCUMENTS'])) {
|
|
$aObjectPermissions['INPUT_DOCUMENTS'] = array(-1);
|
|
}
|
|
}
|
|
if (!isset($aObjectPermissions['OUTPUT_DOCUMENTS'])) {
|
|
$aObjectPermissions['OUTPUT_DOCUMENTS'] = array(-1);
|
|
} else {
|
|
if (!is_array($aObjectPermissions['OUTPUT_DOCUMENTS'])) {
|
|
$aObjectPermissions['OUTPUT_DOCUMENTS'] = array(-1);
|
|
}
|
|
}
|
|
$aDelete = $cases->getAllObjectsFrom($sProcessUID, $sApplicationUID, $sTasKUID, $sUserUID, 'DELETE');
|
|
$oAppDocument = new AppDocument();
|
|
$oCriteria = new Criteria('workflow');
|
|
$oCriteria->add(AppDocumentPeer::APP_UID, $sApplicationUID);
|
|
$oCriteria->add(AppDocumentPeer::APP_DOC_TYPE, array('INPUT'), Criteria::IN);
|
|
$oCriteria->add(AppDocumentPeer::APP_DOC_STATUS, array('ACTIVE'), Criteria::IN);
|
|
//$oCriteria->add(AppDocumentPeer::APP_DOC_UID, $aObjectPermissions['INPUT_DOCUMENTS'], Criteria::IN);
|
|
$oCriteria->add(
|
|
$oCriteria->getNewCriterion(
|
|
AppDocumentPeer::APP_DOC_UID, $aObjectPermissions['INPUT_DOCUMENTS'], Criteria::IN)->
|
|
addOr($oCriteria->getNewCriterion(AppDocumentPeer::USR_UID, array($sUserUID, '-1'), Criteria::IN))
|
|
);
|
|
$aConditions = array();
|
|
$aConditions[] = array(AppDocumentPeer::APP_UID, AppDelegationPeer::APP_UID);
|
|
$aConditions[] = array(AppDocumentPeer::DEL_INDEX, AppDelegationPeer::DEL_INDEX);
|
|
$oCriteria->addJoinMC($aConditions, Criteria::LEFT_JOIN);
|
|
$oCriteria->add(AppDelegationPeer::PRO_UID, $sProcessUID);
|
|
$oCriteria->addAscendingOrderByColumn(AppDocumentPeer::APP_DOC_INDEX);
|
|
$oDataset = AppDocumentPeer::doSelectRS($oCriteria);
|
|
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$oDataset->next();
|
|
$aInputDocuments = array();
|
|
$aInputDocuments[] = array(
|
|
'APP_DOC_UID' => 'char',
|
|
'DOC_UID' => 'char',
|
|
'APP_DOC_COMMENT' => 'char',
|
|
'APP_DOC_FILENAME' => 'char',
|
|
'APP_DOC_INDEX' => 'integer'
|
|
);
|
|
$oUser = new ModelUsers();
|
|
while ($aRow = $oDataset->getRow()) {
|
|
$oCriteria2 = new Criteria('workflow');
|
|
$oCriteria2->add(AppDelegationPeer::APP_UID, $sApplicationUID);
|
|
$oCriteria2->add(AppDelegationPeer::DEL_INDEX, $aRow['DEL_INDEX']);
|
|
$oDataset2 = AppDelegationPeer::doSelectRS($oCriteria2);
|
|
$oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$oDataset2->next();
|
|
$aRow2 = $oDataset2->getRow();
|
|
$oTask = new ModelTask();
|
|
if ($oTask->taskExists($aRow2['TAS_UID'])) {
|
|
$aTask = $oTask->load($aRow2['TAS_UID']);
|
|
} else {
|
|
$aTask = array('TAS_TITLE' => '(TASK DELETED)');
|
|
}
|
|
$aAux = $oAppDocument->load($aRow['APP_DOC_UID'], $aRow['DOC_VERSION']);
|
|
$lastVersion = $oAppDocument->getLastAppDocVersion($aRow['APP_DOC_UID'], $sApplicationUID);
|
|
|
|
if ($aAux['USR_UID'] !== "-1") {
|
|
try {
|
|
$aAux1 = $oUser->load($aAux['USR_UID']);
|
|
|
|
$sUser = $conf->usersNameFormatBySetParameters($confEnvSetting["format"], $aAux1["USR_USERNAME"],
|
|
$aAux1["USR_FIRSTNAME"], $aAux1["USR_LASTNAME"]);
|
|
} catch (Exception $oException) {
|
|
$sUser = '***';
|
|
}
|
|
} else {
|
|
$sUser = '***';
|
|
}
|
|
$aFields = array(
|
|
'APP_DOC_UID' => $aAux['APP_DOC_UID'],
|
|
'DOC_UID' => $aAux['DOC_UID'],
|
|
'APP_DOC_COMMENT' => $aAux['APP_DOC_COMMENT'],
|
|
'APP_DOC_FILENAME' => $aAux['APP_DOC_FILENAME'],
|
|
'APP_DOC_INDEX' => $aAux['APP_DOC_INDEX'],
|
|
'TYPE' => $aAux['APP_DOC_TYPE'],
|
|
'ORIGIN' => $aTask['TAS_TITLE'],
|
|
'CREATE_DATE' => $aAux['APP_DOC_CREATE_DATE'],
|
|
'CREATED_BY' => $sUser
|
|
);
|
|
if ($aFields['APP_DOC_FILENAME'] != '') {
|
|
$aFields['TITLE'] = $aFields['APP_DOC_FILENAME'];
|
|
} else {
|
|
$aFields['TITLE'] = $aFields['APP_DOC_COMMENT'];
|
|
}
|
|
//$aFields['POSITION'] = $_SESSION['STEP_POSITION'];
|
|
$aFields['CONFIRM'] = G::LoadTranslation('ID_CONFIRM_DELETE_ELEMENT');
|
|
if (in_array($aRow['APP_DOC_UID'], $aDelete['INPUT_DOCUMENTS'])) {
|
|
$aFields['ID_DELETE'] = G::LoadTranslation('ID_DELETE');
|
|
}
|
|
$aFields['DOWNLOAD_LABEL'] = G::LoadTranslation('ID_DOWNLOAD');
|
|
$aFields['DOWNLOAD_LINK'] = "cases/cases_ShowDocument?a=" . $aRow['APP_DOC_UID'] . "&v=" . $aRow['DOC_VERSION'];
|
|
$aFields['DOC_VERSION'] = $aRow['DOC_VERSION'];
|
|
if (is_array($listing)) {
|
|
foreach ($listing as $folderitem) {
|
|
if ($folderitem->filename == $aRow['APP_DOC_UID']) {
|
|
$aFields['DOWNLOAD_LABEL'] = G::LoadTranslation('ID_GET_EXTERNAL_FILE');
|
|
$aFields['DOWNLOAD_LINK'] = $folderitem->downloadScript;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
if ($lastVersion == $aRow['DOC_VERSION']) {
|
|
//Show only last version
|
|
$aInputDocuments[] = $aFields;
|
|
}
|
|
$oDataset->next();
|
|
}
|
|
$oAppDocument = new AppDocument();
|
|
$oCriteria = new Criteria('workflow');
|
|
$oCriteria->add(AppDocumentPeer::APP_UID, $sApplicationUID);
|
|
$oCriteria->add(AppDocumentPeer::APP_DOC_TYPE, array('ATTACHED'), Criteria::IN);
|
|
$oCriteria->add(AppDocumentPeer::APP_DOC_STATUS, array('ACTIVE'), Criteria::IN);
|
|
$oCriteria->add(
|
|
$oCriteria->getNewCriterion(
|
|
AppDocumentPeer::APP_DOC_UID, $aObjectPermissions['INPUT_DOCUMENTS'], Criteria::IN
|
|
)->
|
|
addOr($oCriteria->getNewCriterion(AppDocumentPeer::USR_UID, array($sUserUID, '-1'), Criteria::IN)));
|
|
$aConditions = array();
|
|
$aConditions[] = array(AppDocumentPeer::APP_UID, AppDelegationPeer::APP_UID);
|
|
$aConditions[] = array(AppDocumentPeer::DEL_INDEX, AppDelegationPeer::DEL_INDEX);
|
|
$oCriteria->addJoinMC($aConditions, Criteria::LEFT_JOIN);
|
|
$oCriteria->add(AppDelegationPeer::PRO_UID, $sProcessUID);
|
|
$oCriteria->addAscendingOrderByColumn(AppDocumentPeer::APP_DOC_INDEX);
|
|
$oDataset = AppDocumentPeer::doSelectRS($oCriteria);
|
|
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$oDataset->next();
|
|
while ($aRow = $oDataset->getRow()) {
|
|
$oCriteria2 = new Criteria('workflow');
|
|
$oCriteria2->add(AppDelegationPeer::APP_UID, $sApplicationUID);
|
|
$oCriteria2->add(AppDelegationPeer::DEL_INDEX, $aRow['DEL_INDEX']);
|
|
$oDataset2 = AppDelegationPeer::doSelectRS($oCriteria2);
|
|
$oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$oDataset2->next();
|
|
$aRow2 = $oDataset2->getRow();
|
|
$oTask = new ModelTask();
|
|
if ($oTask->taskExists($aRow2['TAS_UID'])) {
|
|
$aTask = $oTask->load($aRow2['TAS_UID']);
|
|
} else {
|
|
$aTask = array('TAS_TITLE' => '(TASK DELETED)');
|
|
}
|
|
$aAux = $oAppDocument->load($aRow['APP_DOC_UID'], $aRow['DOC_VERSION']);
|
|
$lastVersion = $oAppDocument->getLastAppDocVersion($aRow['APP_DOC_UID'], $sApplicationUID);
|
|
try {
|
|
$aAux1 = $oUser->load($aAux['USR_UID']);
|
|
|
|
$sUser = $conf->usersNameFormatBySetParameters($confEnvSetting["format"], $aAux1["USR_USERNAME"],
|
|
$aAux1["USR_FIRSTNAME"], $aAux1["USR_LASTNAME"]);
|
|
} catch (Exception $oException) {
|
|
$sUser = '***';
|
|
}
|
|
$aFields = array(
|
|
'APP_DOC_UID' => $aAux['APP_DOC_UID'],
|
|
'DOC_UID' => $aAux['DOC_UID'],
|
|
'APP_DOC_COMMENT' => $aAux['APP_DOC_COMMENT'],
|
|
'APP_DOC_FILENAME' => $aAux['APP_DOC_FILENAME'],
|
|
'APP_DOC_INDEX' => $aAux['APP_DOC_INDEX'],
|
|
'TYPE' => $aAux['APP_DOC_TYPE'],
|
|
'ORIGIN' => $aTask['TAS_TITLE'],
|
|
'CREATE_DATE' => $aAux['APP_DOC_CREATE_DATE'],
|
|
'CREATED_BY' => $sUser
|
|
);
|
|
if ($aFields['APP_DOC_FILENAME'] != '') {
|
|
$aFields['TITLE'] = $aFields['APP_DOC_FILENAME'];
|
|
} else {
|
|
$aFields['TITLE'] = $aFields['APP_DOC_COMMENT'];
|
|
}
|
|
//$aFields['POSITION'] = $_SESSION['STEP_POSITION'];
|
|
$aFields['CONFIRM'] = G::LoadTranslation('ID_CONFIRM_DELETE_ELEMENT');
|
|
if (in_array($aRow['APP_DOC_UID'], $aDelete['INPUT_DOCUMENTS'])) {
|
|
$aFields['ID_DELETE'] = G::LoadTranslation('ID_DELETE');
|
|
}
|
|
$aFields['DOWNLOAD_LABEL'] = G::LoadTranslation('ID_DOWNLOAD');
|
|
$aFields['DOWNLOAD_LINK'] = "cases/cases_ShowDocument?a=" . $aRow['APP_DOC_UID'];
|
|
|
|
if ($lastVersion == $aRow['DOC_VERSION']) {
|
|
//Show only last version
|
|
$aInputDocuments[] = $aFields;
|
|
}
|
|
$oDataset->next();
|
|
}
|
|
// Get input documents added/modified by a supervisor - Begin
|
|
$oAppDocument = new AppDocument();
|
|
$oCriteria = new Criteria('workflow');
|
|
$oCriteria->add(AppDocumentPeer::APP_UID, $sApplicationUID);
|
|
$oCriteria->add(AppDocumentPeer::APP_DOC_TYPE, array('INPUT'), Criteria::IN);
|
|
$oCriteria->add(AppDocumentPeer::APP_DOC_STATUS, array('ACTIVE'), Criteria::IN);
|
|
$oCriteria->add(AppDocumentPeer::DEL_INDEX, 100000);
|
|
$oCriteria->addJoin(AppDocumentPeer::APP_UID, ApplicationPeer::APP_UID, Criteria::LEFT_JOIN);
|
|
$oCriteria->add(ApplicationPeer::PRO_UID, $sProcessUID);
|
|
$oCriteria->addAscendingOrderByColumn(AppDocumentPeer::APP_DOC_INDEX);
|
|
$oDataset = AppDocumentPeer::doSelectRS($oCriteria);
|
|
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$oDataset->next();
|
|
$oUser = new ModelUsers();
|
|
while ($aRow = $oDataset->getRow()) {
|
|
$aTask = array('TAS_TITLE' => '[ ' . G::LoadTranslation('ID_SUPERVISOR') . ' ]');
|
|
$aAux = $oAppDocument->load($aRow['APP_DOC_UID'], $aRow['DOC_VERSION']);
|
|
$lastVersion = $oAppDocument->getLastAppDocVersion($aRow['APP_DOC_UID'], $sApplicationUID);
|
|
try {
|
|
$aAux1 = $oUser->load($aAux['USR_UID']);
|
|
$sUser = $conf->usersNameFormatBySetParameters($confEnvSetting["format"], $aAux1["USR_USERNAME"],
|
|
$aAux1["USR_FIRSTNAME"], $aAux1["USR_LASTNAME"]);
|
|
} catch (Exception $oException) {
|
|
$sUser = '***';
|
|
}
|
|
$aFields = array(
|
|
'APP_DOC_UID' => $aAux['APP_DOC_UID'],
|
|
'DOC_UID' => $aAux['DOC_UID'],
|
|
'APP_DOC_COMMENT' => $aAux['APP_DOC_COMMENT'],
|
|
'APP_DOC_FILENAME' => $aAux['APP_DOC_FILENAME'],
|
|
'APP_DOC_INDEX' => $aAux['APP_DOC_INDEX'],
|
|
'TYPE' => $aAux['APP_DOC_TYPE'],
|
|
'ORIGIN' => $aTask['TAS_TITLE'],
|
|
'CREATE_DATE' => $aAux['APP_DOC_CREATE_DATE'],
|
|
'CREATED_BY' => $sUser
|
|
);
|
|
if ($aFields['APP_DOC_FILENAME'] != '') {
|
|
$aFields['TITLE'] = $aFields['APP_DOC_FILENAME'];
|
|
} else {
|
|
$aFields['TITLE'] = $aFields['APP_DOC_COMMENT'];
|
|
}
|
|
//$aFields['POSITION'] = $_SESSION['STEP_POSITION'];
|
|
$aFields['CONFIRM'] = G::LoadTranslation('ID_CONFIRM_DELETE_ELEMENT');
|
|
if (in_array($aRow['APP_DOC_UID'], $aDelete['INPUT_DOCUMENTS'])) {
|
|
$aFields['ID_DELETE'] = G::LoadTranslation('ID_DELETE');
|
|
}
|
|
$aFields['DOWNLOAD_LABEL'] = G::LoadTranslation('ID_DOWNLOAD');
|
|
$aFields['DOWNLOAD_LINK'] = "cases_ShowDocument?a=" . $aRow['APP_DOC_UID'] . "&v=" . $aRow['DOC_VERSION'];
|
|
$aFields['DOC_VERSION'] = $aRow['DOC_VERSION'];
|
|
if (is_array($listing)) {
|
|
foreach ($listing as $folderitem) {
|
|
if ($folderitem->filename == $aRow['APP_DOC_UID']) {
|
|
$aFields['DOWNLOAD_LABEL'] = G::LoadTranslation('ID_GET_EXTERNAL_FILE');
|
|
$aFields['DOWNLOAD_LINK'] = $folderitem->downloadScript;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($lastVersion == $aRow['DOC_VERSION']) {
|
|
//Show only last version
|
|
$aInputDocuments[] = $aFields;
|
|
}
|
|
$oDataset->next();
|
|
}
|
|
// Get input documents added/modified by a supervisor - End
|
|
global $_DBArray;
|
|
$_DBArray['inputDocuments'] = $aInputDocuments;
|
|
|
|
$oCriteria = new Criteria('dbarray');
|
|
$oCriteria->setDBArrayTable('inputDocuments');
|
|
$oCriteria->addDescendingOrderByColumn('CREATE_DATE');
|
|
|
|
return $oCriteria;
|
|
}
|
|
|
|
/**
|
|
* get all generate document
|
|
*
|
|
* @name getAllGeneratedDocumentsCriteria
|
|
* @param string $sProcessUID
|
|
* @param string $sApplicationUID
|
|
* @param string $sTasKUID
|
|
* @param string $sUserUID
|
|
*
|
|
* @return object
|
|
* @throws Exception
|
|
*/
|
|
public function getAllGeneratedDocumentsCriteria($sProcessUID, $sApplicationUID, $sTasKUID, $sUserUID)
|
|
{
|
|
|
|
$conf = new Configurations();
|
|
$confEnvSetting = $conf->getFormats();
|
|
|
|
$cases = new ClassesCases();
|
|
|
|
$listing = false;
|
|
$oPluginRegistry = PluginRegistry::loadSingleton();
|
|
if ($oPluginRegistry->existsTrigger(PM_CASE_DOCUMENT_LIST)) {
|
|
$folderData = new \folderData(null, null, $sApplicationUID, null, $sUserUID);
|
|
$folderData->PMType = "OUTPUT";
|
|
$folderData->returnList = true;
|
|
$listing = $oPluginRegistry->executeTriggers(PM_CASE_DOCUMENT_LIST, $folderData);
|
|
}
|
|
$aObjectPermissions = $cases->getAllObjects($sProcessUID, $sApplicationUID, $sTasKUID, $sUserUID);
|
|
if (!is_array($aObjectPermissions)) {
|
|
$aObjectPermissions = array(
|
|
'DYNAFORMS' => array(-1),
|
|
'INPUT_DOCUMENTS' => array(-1),
|
|
'OUTPUT_DOCUMENTS' => array(-1)
|
|
);
|
|
}
|
|
if (!isset($aObjectPermissions['DYNAFORMS'])) {
|
|
$aObjectPermissions['DYNAFORMS'] = array(-1);
|
|
} else {
|
|
if (!is_array($aObjectPermissions['DYNAFORMS'])) {
|
|
$aObjectPermissions['DYNAFORMS'] = array(-1);
|
|
}
|
|
}
|
|
if (!isset($aObjectPermissions['INPUT_DOCUMENTS'])) {
|
|
$aObjectPermissions['INPUT_DOCUMENTS'] = array(-1);
|
|
} else {
|
|
if (!is_array($aObjectPermissions['INPUT_DOCUMENTS'])) {
|
|
$aObjectPermissions['INPUT_DOCUMENTS'] = array(-1);
|
|
}
|
|
}
|
|
if (!isset($aObjectPermissions['OUTPUT_DOCUMENTS'])) {
|
|
$aObjectPermissions['OUTPUT_DOCUMENTS'] = array(-1);
|
|
} else {
|
|
if (!is_array($aObjectPermissions['OUTPUT_DOCUMENTS'])) {
|
|
$aObjectPermissions['OUTPUT_DOCUMENTS'] = array(-1);
|
|
}
|
|
}
|
|
$aDelete = $cases->getAllObjectsFrom($sProcessUID, $sApplicationUID, $sTasKUID, $sUserUID, 'DELETE');
|
|
$oAppDocument = new AppDocument();
|
|
$oCriteria = new Criteria('workflow');
|
|
$oCriteria->add(AppDocumentPeer::APP_UID, $sApplicationUID);
|
|
$oCriteria->add(AppDocumentPeer::APP_DOC_TYPE, 'OUTPUT');
|
|
$oCriteria->add(AppDocumentPeer::APP_DOC_STATUS, array('ACTIVE'), Criteria::IN);
|
|
//$oCriteria->add(AppDocumentPeer::APP_DOC_UID, $aObjectPermissions['OUTPUT_DOCUMENTS'], Criteria::IN);
|
|
$oCriteria->add(
|
|
$oCriteria->getNewCriterion(
|
|
AppDocumentPeer::APP_DOC_UID, $aObjectPermissions['OUTPUT_DOCUMENTS'],
|
|
Criteria::IN)->addOr($oCriteria->getNewCriterion(AppDocumentPeer::USR_UID, $sUserUID, Criteria::EQUAL))
|
|
);
|
|
$aConditions = array();
|
|
$aConditions[] = array(AppDocumentPeer::APP_UID, AppDelegationPeer::APP_UID);
|
|
$aConditions[] = array(AppDocumentPeer::DEL_INDEX, AppDelegationPeer::DEL_INDEX);
|
|
$oCriteria->addJoinMC($aConditions, Criteria::LEFT_JOIN);
|
|
$oCriteria->add(AppDelegationPeer::PRO_UID, $sProcessUID);
|
|
$oCriteria->addAscendingOrderByColumn(AppDocumentPeer::APP_DOC_INDEX);
|
|
$oDataset = AppDocumentPeer::doSelectRS($oCriteria);
|
|
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$oDataset->next();
|
|
$aOutputDocuments = array();
|
|
$aOutputDocuments[] = array(
|
|
'APP_DOC_UID' => 'char',
|
|
'DOC_UID' => 'char',
|
|
'APP_DOC_COMMENT' => 'char',
|
|
'APP_DOC_FILENAME' => 'char',
|
|
'APP_DOC_INDEX' => 'integer'
|
|
);
|
|
$oUser = new ModelUsers();
|
|
while ($aRow = $oDataset->getRow()) {
|
|
$oCriteria2 = new Criteria('workflow');
|
|
$oCriteria2->add(AppDelegationPeer::APP_UID, $sApplicationUID);
|
|
$oCriteria2->add(AppDelegationPeer::DEL_INDEX, $aRow['DEL_INDEX']);
|
|
$oDataset2 = AppDelegationPeer::doSelectRS($oCriteria2);
|
|
$oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$oDataset2->next();
|
|
$aRow2 = $oDataset2->getRow();
|
|
$oTask = new ModelTask();
|
|
if ($oTask->taskExists($aRow2['TAS_UID'])) {
|
|
$aTask = $oTask->load($aRow2['TAS_UID']);
|
|
} else {
|
|
$aTask = array('TAS_TITLE' => '(TASK DELETED)');
|
|
}
|
|
$lastVersion = $oAppDocument->getLastDocVersion($aRow['DOC_UID'], $sApplicationUID);
|
|
if ($lastVersion == $aRow['DOC_VERSION']) {
|
|
//Only show last document Version
|
|
$aAux = $oAppDocument->load($aRow['APP_DOC_UID'], $aRow['DOC_VERSION']);
|
|
//Get output Document information
|
|
$oOutputDocument = new \OutputDocument();
|
|
$aGields = $oOutputDocument->load($aRow['DOC_UID']);
|
|
//OUTPUTDOCUMENT
|
|
$outDocTitle = $aGields['OUT_DOC_TITLE'];
|
|
switch ($aGields['OUT_DOC_GENERATE']) {
|
|
//G::LoadTranslation(ID_DOWNLOAD)
|
|
case "PDF":
|
|
$fileDoc = 'javascript:alert("NO DOC")';
|
|
$fileDocLabel = " ";
|
|
$filePdf = 'cases/cases_ShowOutputDocument?a=' .
|
|
$aRow['APP_DOC_UID'] . '&v=' . $aRow['DOC_VERSION'] . '&ext=pdf&random=' . rand();
|
|
$filePdfLabel = ".pdf";
|
|
if (is_array($listing)) {
|
|
foreach ($listing as $folderitem) {
|
|
if (($folderitem->filename == $aRow['APP_DOC_UID']) && ($folderitem->type == "PDF")) {
|
|
$filePdfLabel = G::LoadTranslation('ID_GET_EXTERNAL_FILE') . " .pdf";
|
|
$filePdf = $folderitem->downloadScript;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case "DOC":
|
|
$fileDoc = 'cases/cases_ShowOutputDocument?a=' .
|
|
$aRow['APP_DOC_UID'] . '&v=' . $aRow['DOC_VERSION'] . '&ext=doc&random=' . rand();
|
|
$fileDocLabel = ".doc";
|
|
$filePdf = 'javascript:alert("NO PDF")';
|
|
$filePdfLabel = " ";
|
|
if (is_array($listing)) {
|
|
foreach ($listing as $folderitem) {
|
|
if (($folderitem->filename == $aRow['APP_DOC_UID']) && ($folderitem->type == "DOC")) {
|
|
$fileDocLabel = G::LoadTranslation('ID_GET_EXTERNAL_FILE') . " .doc";
|
|
$fileDoc = $folderitem->downloadScript;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case "BOTH":
|
|
$fileDoc = 'cases/cases_ShowOutputDocument?a=' .
|
|
$aRow['APP_DOC_UID'] . '&v=' . $aRow['DOC_VERSION'] . '&ext=doc&random=' . rand();
|
|
$fileDocLabel = ".doc";
|
|
if (is_array($listing)) {
|
|
foreach ($listing as $folderitem) {
|
|
if (($folderitem->filename == $aRow['APP_DOC_UID']) && ($folderitem->type == "DOC")) {
|
|
$fileDocLabel = G::LoadTranslation('ID_GET_EXTERNAL_FILE') . " .doc";
|
|
$fileDoc = $folderitem->downloadScript;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
$filePdf = 'cases/cases_ShowOutputDocument?a=' .
|
|
$aRow['APP_DOC_UID'] . '&v=' . $aRow['DOC_VERSION'] . '&ext=pdf&random=' . rand();
|
|
$filePdfLabel = ".pdf";
|
|
|
|
if (is_array($listing)) {
|
|
foreach ($listing as $folderitem) {
|
|
if (($folderitem->filename == $aRow['APP_DOC_UID']) && ($folderitem->type == "PDF")) {
|
|
$filePdfLabel = G::LoadTranslation('ID_GET_EXTERNAL_FILE') . " .pdf";
|
|
$filePdf = $folderitem->downloadScript;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
try {
|
|
$aAux1 = $oUser->load($aAux['USR_UID']);
|
|
$sUser = $conf->usersNameFormatBySetParameters($confEnvSetting["format"], $aAux1["USR_USERNAME"],
|
|
$aAux1["USR_FIRSTNAME"], $aAux1["USR_LASTNAME"]);
|
|
} catch (Exception $oException) {
|
|
$sUser = '(USER DELETED)';
|
|
}
|
|
//if both documents were generated, we choose the pdf one, only if doc was
|
|
//generate then choose the doc file.
|
|
$firstDocLink = $filePdf;
|
|
$firstDocLabel = $filePdfLabel;
|
|
if ($aGields['OUT_DOC_GENERATE'] == 'DOC') {
|
|
$firstDocLink = $fileDoc;
|
|
$firstDocLabel = $fileDocLabel;
|
|
}
|
|
$aFields = array(
|
|
'APP_DOC_UID' => $aAux['APP_DOC_UID'],
|
|
'DOC_UID' => $aAux['DOC_UID'],
|
|
'APP_DOC_COMMENT' => $aAux['APP_DOC_COMMENT'],
|
|
'APP_DOC_FILENAME' => $aAux['APP_DOC_FILENAME'],
|
|
'APP_DOC_INDEX' => $aAux['APP_DOC_INDEX'],
|
|
'ORIGIN' => $aTask['TAS_TITLE'],
|
|
'CREATE_DATE' => $aAux['APP_DOC_CREATE_DATE'],
|
|
'CREATED_BY' => $sUser,
|
|
'FILEDOC' => $fileDoc,
|
|
'FILEPDF' => $filePdf,
|
|
'OUTDOCTITLE' => $outDocTitle,
|
|
'DOC_VERSION' => $aAux['DOC_VERSION'],
|
|
'TYPE' => $aAux['APP_DOC_TYPE'] . ' ' . $aGields['OUT_DOC_GENERATE'],
|
|
'DOWNLOAD_LINK' => $firstDocLink,
|
|
'DOWNLOAD_FILE' => $aAux['APP_DOC_FILENAME'] . $firstDocLabel
|
|
);
|
|
if (trim($fileDocLabel) != '') {
|
|
$aFields['FILEDOCLABEL'] = $fileDocLabel;
|
|
}
|
|
if (trim($filePdfLabel) != '') {
|
|
$aFields['FILEPDFLABEL'] = $filePdfLabel;
|
|
}
|
|
if ($aFields['APP_DOC_FILENAME'] != '') {
|
|
$aFields['TITLE'] = $aFields['APP_DOC_FILENAME'];
|
|
} else {
|
|
$aFields['TITLE'] = $aFields['APP_DOC_COMMENT'];
|
|
}
|
|
//$aFields['POSITION'] = $_SESSION['STEP_POSITION'];
|
|
$aFields['CONFIRM'] = G::LoadTranslation('ID_CONFIRM_DELETE_ELEMENT');
|
|
if (in_array($aRow['APP_DOC_UID'], $aObjectPermissions['OUTPUT_DOCUMENTS'])) {
|
|
if (in_array($aRow['APP_DOC_UID'], $aDelete['OUTPUT_DOCUMENTS'])) {
|
|
$aFields['ID_DELETE'] = G::LoadTranslation('ID_DELETE');
|
|
}
|
|
}
|
|
$aOutputDocuments[] = $aFields;
|
|
}
|
|
$oDataset->next();
|
|
}
|
|
global $_DBArray;
|
|
$_DBArray['outputDocuments'] = $aOutputDocuments;
|
|
|
|
$oCriteria = new Criteria('dbarray');
|
|
$oCriteria->setDBArrayTable('outputDocuments');
|
|
$oCriteria->addDescendingOrderByColumn('CREATE_DATE');
|
|
|
|
return $oCriteria;
|
|
}
|
|
|
|
/**
|
|
* Get fields and values by DynaForm
|
|
*
|
|
* @param array $form
|
|
* @param array $appData
|
|
* @param array $caseVariable
|
|
*
|
|
* @return array
|
|
* @throws Exception
|
|
*/
|
|
private function getFieldsAndValuesByDynaFormAndAppData(array $form, array $appData, array $caseVariable)
|
|
{
|
|
try {
|
|
foreach ($form['items'] as $value) {
|
|
foreach ($value as $field) {
|
|
if (isset($field['type'])) {
|
|
if ($field['type'] != 'form') {
|
|
foreach ($field as $key => $val) {
|
|
if (is_string($val) && in_array(substr($val, 0, 2), PmDynaform::$prefixs)) {
|
|
$field[$key] = substr($val, 2);
|
|
}
|
|
}
|
|
foreach ($appData as $key => $val) {
|
|
if (in_array($key, $field, true) != false) {
|
|
$caseVariable[$key] = $this->getFieldValue($field, $appData[$key]);
|
|
if (isset($appData[$key . '_label'])) {
|
|
$caseVariable[$key . '_label'] = $appData[$key . '_label'];
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
$caseVariableAux = $this->getFieldsAndValuesByDynaFormAndAppData($field, $appData,
|
|
$caseVariable);
|
|
$caseVariable = array_merge($caseVariable, $caseVariableAux);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return $caseVariable;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the field value to be used in the front-end client.
|
|
*
|
|
* @param type $field
|
|
* @param type $value
|
|
*
|
|
* @return string
|
|
*/
|
|
private function getFieldValue($field, $value)
|
|
{
|
|
switch ($field['type']) {
|
|
case 'file':
|
|
return $field['data']['app_doc_uid'];
|
|
default:
|
|
return $value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get Case Variables
|
|
*
|
|
* @access public
|
|
* @param string $app_uid , Uid for case
|
|
* @param string $usr_uid , Uid for user
|
|
* @param string $dynaFormUid , Uid for dynaform
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getCaseVariables(
|
|
$app_uid,
|
|
$usr_uid,
|
|
$dynaFormUid = null,
|
|
$pro_uid = null,
|
|
$act_uid = null,
|
|
$app_index = null
|
|
) {
|
|
Validator::isString($app_uid, '$app_uid');
|
|
Validator::appUid($app_uid, '$app_uid');
|
|
Validator::isString($usr_uid, '$usr_uid');
|
|
Validator::usrUid($usr_uid, '$usr_uid');
|
|
|
|
$case = new ClassesCases();
|
|
$fields = $case->loadCase($app_uid);
|
|
|
|
$arrayCaseVariable = [];
|
|
|
|
if (!is_null($dynaFormUid)) {
|
|
$data = [];
|
|
$data["APP_DATA"] = $fields['APP_DATA'];
|
|
$data["CURRENT_DYNAFORM"] = $dynaFormUid;
|
|
$pmDynaForm = new PmDynaform($data);
|
|
$arrayDynaFormData = $pmDynaForm->getDynaform();
|
|
$arrayDynContent = G::json_decode($arrayDynaFormData['DYN_CONTENT']);
|
|
$pmDynaForm->jsonr($arrayDynContent);
|
|
|
|
$arrayDynContent = G::json_decode(G::json_encode($arrayDynContent), true);
|
|
|
|
$arrayAppData = $fields['APP_DATA'];
|
|
|
|
$arrayCaseVariable = $this->getFieldsAndValuesByDynaFormAndAppData(
|
|
$arrayDynContent['items'][0], $arrayAppData, $arrayCaseVariable
|
|
);
|
|
} else {
|
|
$arrayCaseVariable = $fields['APP_DATA'];
|
|
}
|
|
|
|
//Get historyDate for Dynaform
|
|
if (!is_null($pro_uid) && !is_null($act_uid) && !is_null($app_index)) {
|
|
$oCriteriaAppHistory = new Criteria("workflow");
|
|
$oCriteriaAppHistory->addSelectColumn(AppHistoryPeer::HISTORY_DATE);
|
|
$oCriteriaAppHistory->add(AppHistoryPeer::APP_UID, $app_uid, Criteria::EQUAL);
|
|
$oCriteriaAppHistory->add(AppHistoryPeer::DEL_INDEX, $app_index, Criteria::EQUAL);
|
|
$oCriteriaAppHistory->add(AppHistoryPeer::PRO_UID, $pro_uid, Criteria::EQUAL);
|
|
$oCriteriaAppHistory->add(AppHistoryPeer::TAS_UID, $act_uid, Criteria::EQUAL);
|
|
$oCriteriaAppHistory->add(AppHistoryPeer::USR_UID, $usr_uid, Criteria::EQUAL);
|
|
if (!is_null($dynaFormUid)) {
|
|
$oCriteriaAppHistory->add(AppHistoryPeer::DYN_UID, $dynaFormUid, Criteria::EQUAL);
|
|
}
|
|
$oCriteriaAppHistory->addDescendingOrderByColumn('HISTORY_DATE');
|
|
$oCriteriaAppHistory->setLimit(1);
|
|
$oDataset = AppDocumentPeer::doSelectRS($oCriteriaAppHistory);
|
|
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$oDataset->next();
|
|
if ($aRow = $oDataset->getRow()) {
|
|
$dateHistory['SYS_VAR_UPDATE_DATE'] = $aRow['HISTORY_DATE'];
|
|
} else {
|
|
$dateHistory['SYS_VAR_UPDATE_DATE'] = null;
|
|
}
|
|
$arrayCaseVariable = array_merge($arrayCaseVariable, $dateHistory);
|
|
}
|
|
|
|
// Get the SYS_LANG defined, it can be updated
|
|
if (defined('SYS_LANG')) {
|
|
$arrayCaseVariable['SYS_LANG'] = SYS_LANG;
|
|
}
|
|
|
|
return $arrayCaseVariable;
|
|
}
|
|
|
|
/**
|
|
* Put Set Case Variables
|
|
*
|
|
* @access public
|
|
* @param string $app_uid , Uid for case
|
|
* @param array $app_data , Data for case variables
|
|
* @param string $dyn_uid , Uid for dynaform
|
|
* @param string $del_index , Index for case
|
|
* @param string $usr_uid , Uid for user
|
|
*
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
public function setCaseVariables($app_uid, $app_data, $dyn_uid = null, $usr_uid = '', $del_index = 0)
|
|
{
|
|
Validator::isString($app_uid, '$app_uid');
|
|
Validator::appUid($app_uid, '$app_uid');
|
|
Validator::isArray($app_data, '$app_data');
|
|
Validator::isString($usr_uid, '$usr_uid');
|
|
Validator::usrUid($usr_uid, '$usr_uid');
|
|
// Validate the system variables
|
|
$systemVars = G::getSystemConstants();
|
|
foreach ($systemVars as $key => $var) {
|
|
if (array_key_exists($key, $app_data)) {
|
|
throw new Exception(G::LoadTranslation("ID_CAN_NOT_CHANGE"));
|
|
}
|
|
}
|
|
|
|
$arrayResult = $this->getStatusInfo($app_uid);
|
|
|
|
if ($arrayResult["APP_STATUS"] == "CANCELLED") {
|
|
throw new Exception(G::LoadTranslation("ID_CASE_CANCELLED", [$app_uid]));
|
|
}
|
|
|
|
if ($arrayResult["APP_STATUS"] == "COMPLETED") {
|
|
throw new Exception(G::LoadTranslation("ID_CASE_IS_COMPLETED", [$app_uid]));
|
|
}
|
|
|
|
// Review if the user has participation or is supervisor
|
|
$caseNumber = ModelApplication::getCaseNumber($app_uid);
|
|
$permission = $this->participation($usr_uid, $caseNumber, $del_index);
|
|
if (!$permission) {
|
|
throw new Exception(G::LoadTranslation("ID_NO_PERMISSION_NO_PARTICIPATED", [$usr_uid]));
|
|
}
|
|
|
|
$_SESSION['APPLICATION'] = $app_uid;
|
|
$_SESSION['USER_LOGGED'] = $usr_uid;
|
|
|
|
$arrayVariableDocumentToDelete = [];
|
|
|
|
if (array_key_exists('__VARIABLE_DOCUMENT_DELETE__', $app_data)) {
|
|
if (is_array($app_data['__VARIABLE_DOCUMENT_DELETE__']) && !empty($app_data['__VARIABLE_DOCUMENT_DELETE__'])) {
|
|
$arrayVariableDocumentToDelete = $app_data['__VARIABLE_DOCUMENT_DELETE__'];
|
|
}
|
|
|
|
unset($app_data['__VARIABLE_DOCUMENT_DELETE__']);
|
|
}
|
|
|
|
$case = new ClassesCases();
|
|
$fields = $case->loadCase($app_uid, $del_index);
|
|
$_POST['form'] = $app_data;
|
|
|
|
if (!is_null($dyn_uid) && $dyn_uid != '') {
|
|
$oDynaform = \DynaformPeer::retrieveByPK($dyn_uid);
|
|
|
|
if ($oDynaform->getDynVersion() < 2) {
|
|
$oForm = new \Form ($fields['PRO_UID'] . "/" . $dyn_uid, PATH_DYNAFORM);
|
|
$oForm->validatePost();
|
|
}
|
|
}
|
|
|
|
if (!is_null($dyn_uid) && $del_index > 0) {
|
|
//save data
|
|
$data = array();
|
|
$data['APP_NUMBER'] = $fields['APP_NUMBER'];
|
|
$data['APP_DATA'] = $fields['APP_DATA'];
|
|
$data['DEL_INDEX'] = $del_index;
|
|
$data['TAS_UID'] = $fields['TAS_UID'];;
|
|
$data['CURRENT_DYNAFORM'] = $dyn_uid;
|
|
$data['USER_UID'] = $usr_uid;
|
|
$data['PRO_UID'] = $fields['PRO_UID'];
|
|
}
|
|
$data['APP_DATA'] = array_merge($fields['APP_DATA'], $_POST['form']);
|
|
$case->updateCase($app_uid, $data);
|
|
|
|
//Delete MultipleFile
|
|
if (!empty($arrayVariableDocumentToDelete)) {
|
|
$this->deleteMultipleFile($app_uid, $arrayVariableDocumentToDelete);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get Case Notes
|
|
*
|
|
* @param string $appUid
|
|
* @param string $usrUid
|
|
* @param array $parameters
|
|
*
|
|
* @return array
|
|
* @throws \PropelException
|
|
* @access public
|
|
*/
|
|
public function getCaseNotes($appUid, $usrUid, $parameters = [])
|
|
{
|
|
// Validate parameters
|
|
Validator::isString($appUid, '$app_uid');
|
|
Validator::appUid($appUid, '$app_uid');
|
|
Validator::isString($usrUid, '$usr_uid');
|
|
Validator::usrUid($usrUid, '$usr_uid');
|
|
Validator::isArray($parameters, '$parameters');
|
|
Validator::isArray($parameters, '$parameters');
|
|
$start = isset($parameters["start"]) ? $parameters["start"] : "0";
|
|
$limit = isset($parameters["limit"]) ? $parameters["limit"] : "";
|
|
$sort = isset($parameters["sort"]) ? $parameters["sort"] : "NOTE_DATE";
|
|
$dir = isset($parameters["dir"]) ? $parameters["dir"] : "DESC";
|
|
$user = isset($parameters["user"]) ? $parameters["user"] : "";
|
|
$dateFrom = (!empty($parameters["dateFrom"])) ? substr($parameters["dateFrom"], 0, 10) : "";
|
|
$dateTo = (!empty($parameters["dateTo"])) ? substr($parameters["dateTo"], 0, 10) : "";
|
|
$search = isset($parameters["search"]) ? $parameters["search"] : "";
|
|
$paged = isset($parameters["paged"]) ? $parameters["paged"] : true;
|
|
$files = isset($parameters["files"]) ? $parameters["files"] : false;
|
|
if (!empty($user)) {
|
|
Validator::usrUid($user, '$usr_uid');
|
|
}
|
|
if (!empty($dateFrom)) {
|
|
Validator::isDate($dateFrom, 'Y-m-d', '$date_from');
|
|
}
|
|
if (!empty($dateTo)) {
|
|
Validator::isDate($dateTo, 'Y-m-d', '$date_to');
|
|
}
|
|
// Review the process permissions
|
|
$case = new ClassesCases();
|
|
$caseLoad = $case->loadCase($appUid);
|
|
$proUid = $caseLoad['PRO_UID'];
|
|
$tasUid = AppDelegation::getCurrentTask($appUid);
|
|
$respView = $case->getAllObjectsFrom($proUid, $appUid, $tasUid, $usrUid, 'VIEW');
|
|
$respBlock = $case->getAllObjectsFrom($proUid, $appUid, $tasUid, $usrUid, 'BLOCK');
|
|
if ($respView['CASES_NOTES'] == 0 && $respBlock['CASES_NOTES'] == 0) {
|
|
throw new Exception(G::LoadTranslation("ID_THIS_USER_DOESNT_HAVE_PERMISSIONS_TO_SEE_CASE_NOTES"));
|
|
}
|
|
// Get the notes
|
|
$appNote = new Notes();
|
|
$notes = $appNote->getNotes($appUid, $start, $limit, $dir);
|
|
$notes = AppNotes::applyHtmlentitiesInNotes($notes);
|
|
// Add a the notes the files related
|
|
$documents = new Documents();
|
|
$iterator = 0;
|
|
$data = [];
|
|
foreach ($notes['notes'] as $value) {
|
|
$data[$iterator] = array_change_key_case($value, CASE_LOWER);
|
|
$data[$iterator]['note_date'] = UtilDateTime::convertUtcToTimeZone($value['NOTE_DATE']);
|
|
if ($files) {
|
|
$data[$iterator]['attachments'] = $documents->getFiles($value['NOTE_ID']);
|
|
}
|
|
$iterator++;
|
|
}
|
|
// If is paged will add the filters used
|
|
$filters = [];
|
|
if ($paged) {
|
|
$total = $appNote->getTotal($appUid);
|
|
$filters['total'] = $total;
|
|
$filters['start'] = $start;
|
|
$filters['limit'] = $limit;
|
|
$filters['sort'] = $sort;
|
|
$filters['dir'] = $dir;
|
|
$filters['usr_uid'] = $user;
|
|
$filters['date_to'] = $dateTo;
|
|
$filters['date_from'] = $dateFrom;
|
|
$filters['search'] = $search;
|
|
}
|
|
// Prepare the response
|
|
$response = [];
|
|
if ($paged) {
|
|
$response = $filters;
|
|
$response['data'] = $data;
|
|
} else {
|
|
$response = $data;
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* Save new case note
|
|
*
|
|
* @access public
|
|
* @param string $appUid, Uid for case
|
|
* @param string $usrUid, Uid for user
|
|
* @param string $noteContent
|
|
* @param boolean $sendMail
|
|
*
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
public function saveCaseNote($appUid, $usrUid, $noteContent, $sendMail = false)
|
|
{
|
|
Validator::isString($appUid, '$app_uid');
|
|
Validator::appUid($appUid, '$app_uid');
|
|
Validator::isString($usrUid, '$usr_uid');
|
|
Validator::usrUid($usrUid, '$usr_uid');
|
|
Validator::isString($noteContent, '$note_content');
|
|
if (strlen($noteContent) > 500) {
|
|
throw (new Exception(G::LoadTranslation("ID_INVALID_MAX_PERMITTED", [$noteContent, '500'])));
|
|
}
|
|
Validator::isBoolean($sendMail, '$send_mail');
|
|
// Review the process permissions
|
|
$case = new ClassesCases();
|
|
$caseLoad = $case->loadCase($appUid);
|
|
$proUid = $caseLoad['PRO_UID'];
|
|
$tasUid = AppDelegation::getCurrentTask($appUid);
|
|
$respView = $case->getAllObjectsFrom($proUid, $appUid, $tasUid, $usrUid, 'VIEW');
|
|
$respBlock = $case->getAllObjectsFrom($proUid, $appUid, $tasUid, $usrUid, 'BLOCK');
|
|
if ($respView['CASES_NOTES'] == 0 && $respBlock['CASES_NOTES'] == 0) {
|
|
throw (new Exception(G::LoadTranslation("ID_CASES_NOTES_NO_PERMISSIONS")));
|
|
}
|
|
// Save the notes
|
|
$response = $this->addNote($appUid, $usrUid, $noteContent, intval($sendMail));
|
|
}
|
|
|
|
/**
|
|
* Get data of a Task from a record
|
|
*
|
|
* @param array $record Record
|
|
*
|
|
* @return array Return an array with data Task
|
|
* @throws Exception
|
|
*/
|
|
public function getTaskDataFromRecord(array $record)
|
|
{
|
|
try {
|
|
return array(
|
|
$this->getFieldNameByFormatFieldName("TAS_UID") => $record["TAS_UID"],
|
|
$this->getFieldNameByFormatFieldName("TAS_TITLE") => $record["TAS_TITLE"] . "",
|
|
$this->getFieldNameByFormatFieldName("TAS_DESCRIPTION") => $record["TAS_DESCRIPTION"] . "",
|
|
$this->getFieldNameByFormatFieldName("TAS_START") => ($record["TAS_START"] == "TRUE") ? 1 : 0,
|
|
$this->getFieldNameByFormatFieldName("TAS_TYPE") => $record["TAS_TYPE"],
|
|
$this->getFieldNameByFormatFieldName("TAS_DERIVATION") => $record["TAS_DERIVATION"],
|
|
$this->getFieldNameByFormatFieldName("TAS_ASSIGN_TYPE") => $record["TAS_ASSIGN_TYPE"],
|
|
$this->getFieldNameByFormatFieldName("USR_UID") => $record["USR_UID"] . "",
|
|
$this->getFieldNameByFormatFieldName("USR_USERNAME") => $record["USR_USERNAME"] . "",
|
|
$this->getFieldNameByFormatFieldName("USR_FIRSTNAME") => $record["USR_FIRSTNAME"] . "",
|
|
$this->getFieldNameByFormatFieldName("USR_LASTNAME") => $record["USR_LASTNAME"] . ""
|
|
);
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all Tasks of Case
|
|
* Based in: processmaker/workflow/engine/classes/class.processMap.php
|
|
* Method: processMap::load()
|
|
*
|
|
* @param string $applicationUid Unique id of Case
|
|
*
|
|
* @see workflow/engine/src/ProcessMaker/Services/Api/Cases.php
|
|
* @see workflow/engine/src/ProcessMaker/Services/Api/Light.php
|
|
*
|
|
* @link https://wiki.processmaker.com/3.3/REST_API_Cases/Cases#Get_Case.27s_Tasks:_GET_.2Fcases.2F.7Bapp_uid.7D.2Ftasks
|
|
*
|
|
* @return array Return an array with all Tasks of Case
|
|
* @throws Exception
|
|
*/
|
|
public function getTasks($applicationUid)
|
|
{
|
|
try {
|
|
$arrayTask = array();
|
|
|
|
//Verify data
|
|
$this->throwExceptionIfNotExistsCase($applicationUid, 0, $this->getFieldNameByFormatFieldName("APP_UID"));
|
|
|
|
//Set variables
|
|
$process = new \Process();
|
|
$application = new \Application();
|
|
$conf = new Configurations();
|
|
|
|
$arrayApplicationData = $application->Load($applicationUid);
|
|
$processUid = $arrayApplicationData["PRO_UID"];
|
|
|
|
$confEnvSetting = $conf->getFormats();
|
|
|
|
$taskUid = "";
|
|
|
|
//Obtain the list of tasks and their respectives users assigned to each one for an specific case
|
|
$case = new ClassesCases();
|
|
$rsTasks = $case->getTasksInfoForACase($applicationUid, $processUid);
|
|
|
|
while ($rsTasks->next()) {
|
|
$row = $rsTasks->getRow();
|
|
|
|
//If the task is a multiple task
|
|
if ($row["TAS_ASSIGN_TYPE"] == 'MULTIPLE_INSTANCE' || $row["TAS_ASSIGN_TYPE"] == 'MULTIPLE_INSTANCE_VALUE_BASED') {
|
|
$row["USR_UID"] = "";
|
|
$row["USR_USERNAME"] = "";
|
|
$row["USR_FIRSTNAME"] = "";
|
|
$row["USR_LASTNAME"] = "";
|
|
}
|
|
|
|
//Task
|
|
if ($row["TAS_TYPE"] == "NORMAL") {
|
|
if (($row["TAS_TITLE"] . "" == "")) {
|
|
//There is no Label in Current SYS_LANG language so try to find in English - by default
|
|
$task = new ModelTask();
|
|
$task->setTasUid($row["TAS_UID"]);
|
|
|
|
$row["TAS_TITLE"] = $task->getTasTitle();
|
|
}
|
|
} else {
|
|
|
|
//Get the task information when the task type is different from normal
|
|
$rsCriteria2 = $case->getTaskInfoForSubProcess($processUid, $row["TAS_UID"]);
|
|
|
|
$rsCriteria2->next();
|
|
|
|
$row2 = $rsCriteria2->getRow();
|
|
$proUid = isset($row2["PRO_UID"]) ? $row2["PRO_UID"] : '';
|
|
if (!empty($proUid) && $process->exists($proUid)) {
|
|
$row["TAS_TITLE"] = $row2["TAS_TITLE"];
|
|
$row["TAS_DESCRIPTION"] = $row2["TAS_DESCRIPTION"];
|
|
}
|
|
}
|
|
|
|
//Routes
|
|
$routeType = "";
|
|
$arrayRoute = array();
|
|
|
|
//Get the routes of a task
|
|
$rsCriteria2 = $case->getTaskRoutes($processUid, $row["TAS_UID"]);
|
|
|
|
while ($rsCriteria2->next()) {
|
|
$row2 = $rsCriteria2->getRow();
|
|
|
|
$routeType = $row2["ROU_TYPE"];
|
|
|
|
$arrayRoute[] = array(
|
|
$this->getFieldNameByFormatFieldName("ROU_NUMBER") => (int)($row2["ROU_NUMBER"]),
|
|
$this->getFieldNameByFormatFieldName("ROU_CONDITION") => $row2["ROU_CONDITION"] . "",
|
|
$this->getFieldNameByFormatFieldName("TAS_UID") => $row2["TAS_UID"]
|
|
);
|
|
}
|
|
|
|
//Delegations
|
|
$arrayAppDelegation = array();
|
|
|
|
$rsCriteria2 = $case->getCaseDelegations($applicationUid, $row["TAS_UID"]);
|
|
|
|
while ($rsCriteria2->next()) {
|
|
$row2 = $rsCriteria2->getRow();
|
|
|
|
$arrayAppDelegationDate = array(
|
|
"DEL_INIT_DATE" => array(
|
|
"date" => $row2["DEL_INIT_DATE"],
|
|
"dateFormated" => G::LoadTranslation("ID_CASE_NOT_YET_STARTED")
|
|
),
|
|
"DEL_TASK_DUE_DATE" => array(
|
|
"date" => $row2["DEL_TASK_DUE_DATE"],
|
|
"dateFormated" => G::LoadTranslation("ID_CASE_NOT_YET_STARTED")
|
|
),
|
|
"DEL_FINISH_DATE" => array(
|
|
"date" => $row2["DEL_FINISH_DATE"],
|
|
"dateFormated" => G::LoadTranslation("ID_NOT_FINISHED")
|
|
)
|
|
);
|
|
|
|
foreach ($arrayAppDelegationDate as $key => $value) {
|
|
$d = $value;
|
|
|
|
if (!empty($d["date"])) {
|
|
$dateTime = new \DateTime($d["date"]);
|
|
$arrayAppDelegationDate[$key]["dateFormated"] = $dateTime->format($confEnvSetting["dateFormat"]);
|
|
}
|
|
}
|
|
|
|
$appDelegationDuration = G::LoadTranslation("ID_NOT_FINISHED");
|
|
|
|
$date = empty($row2["DEL_INIT_DATE"]) ? $row2["DEL_DELEGATE_DATE"] : $row2["DEL_INIT_DATE"];
|
|
|
|
if (!empty($row2["DEL_FINISH_DATE"]) && !empty($date)) {
|
|
$t = strtotime($row2["DEL_FINISH_DATE"]) - strtotime($date);
|
|
|
|
$h = $t * (1 / 60) * (1 / 60);
|
|
$m = ($h - (int)($h)) * (60 / 1);
|
|
$s = ($m - (int)($m)) * (60 / 1);
|
|
|
|
$h = (int)($h);
|
|
$m = (int)($m);
|
|
|
|
$appDelegationDuration = $h . " " . (($h == 1) ? G::LoadTranslation("ID_HOUR") : G::LoadTranslation("ID_HOURS"));
|
|
$appDelegationDuration = $appDelegationDuration . " " . $m . " " . (($m == 1) ? G::LoadTranslation("ID_MINUTE") : G::LoadTranslation("ID_MINUTES"));
|
|
$appDelegationDuration = $appDelegationDuration . " " . $s . " " . (($s == 1) ? G::LoadTranslation("ID_SECOND") : G::LoadTranslation("ID_SECONDS"));
|
|
}
|
|
|
|
$arrayAppDelegation[] = array(
|
|
$this->getFieldNameByFormatFieldName("DEL_INDEX") => (int)($row2["DEL_INDEX"]),
|
|
$this->getFieldNameByFormatFieldName("DEL_INIT_DATE") => $arrayAppDelegationDate["DEL_INIT_DATE"]["dateFormated"],
|
|
$this->getFieldNameByFormatFieldName("DEL_TASK_DUE_DATE") => $arrayAppDelegationDate["DEL_TASK_DUE_DATE"]["dateFormated"],
|
|
$this->getFieldNameByFormatFieldName("DEL_FINISH_DATE") => $arrayAppDelegationDate["DEL_FINISH_DATE"]["dateFormated"],
|
|
$this->getFieldNameByFormatFieldName("DEL_DURATION") => $appDelegationDuration,
|
|
$this->getFieldNameByFormatFieldName("USR_UID") => $row2["USR_UID"],
|
|
$this->getFieldNameByFormatFieldName("USR_USERNAME") => $row2["USR_USERNAME"],
|
|
$this->getFieldNameByFormatFieldName("USR_FIRSTNAME") => $row2["USR_FIRSTNAME"],
|
|
$this->getFieldNameByFormatFieldName("USR_LASTNAME") => $row2["USR_LASTNAME"]
|
|
);
|
|
}
|
|
|
|
//Status
|
|
$status = "";
|
|
|
|
$rsCriteria2 = $case->getTotalAndMinDateForACase($applicationUid, $row["TAS_UID"]);
|
|
|
|
$rsCriteria2->next();
|
|
|
|
$row2 = $rsCriteria2->getRow();
|
|
|
|
$rsCriteria3 = $case->getDelegationFinishDate($applicationUid, $row["TAS_UID"]);
|
|
|
|
$rsCriteria3->next();
|
|
|
|
$row3 = $rsCriteria3->getRow();
|
|
|
|
if ($row3) {
|
|
$row2["FINISH"] = "";
|
|
}
|
|
|
|
//Status
|
|
if (empty($row2["FINISH"]) && !is_null($taskUid) && $row["TAS_UID"] == $taskUid) {
|
|
$status = "TASK_IN_PROGRESS"; //Red
|
|
} else {
|
|
if (!empty($row2["FINISH"])) {
|
|
$status = "TASK_COMPLETED"; //Green
|
|
} else {
|
|
if ($routeType != "SEC-JOIN") {
|
|
if ($row2["CANT"] != 0) {
|
|
$status = "TASK_IN_PROGRESS"; //Red
|
|
} else {
|
|
$status = "TASK_PENDING_NOT_EXECUTED"; //Gray
|
|
}
|
|
} else {
|
|
//$status = "TASK_PARALLEL"; //Yellow
|
|
|
|
if ($row3) {
|
|
$status = "TASK_IN_PROGRESS"; //Red
|
|
} else {
|
|
$status = "TASK_PENDING_NOT_EXECUTED"; //Gray
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Set data
|
|
$arrayAux = $this->getTaskDataFromRecord($row);
|
|
$arrayAux[$this->getFieldNameByFormatFieldName("ROUTE")][$this->getFieldNameByFormatFieldName("TYPE")] = $routeType;
|
|
$arrayAux[$this->getFieldNameByFormatFieldName("ROUTE")][$this->getFieldNameByFormatFieldName("TO")] = $arrayRoute;
|
|
$arrayAux[$this->getFieldNameByFormatFieldName("DELEGATIONS")] = $arrayAppDelegation;
|
|
$arrayAux[$this->getFieldNameByFormatFieldName("STATUS")] = $status;
|
|
|
|
$arrayTask[] = $arrayAux;
|
|
}
|
|
|
|
//Return
|
|
return $arrayTask;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Put execute triggers
|
|
*
|
|
* @access public
|
|
* @param string $app_uid , Uid for case
|
|
* @param int $del_index , Index for case
|
|
* @param string $obj_type , Index for case
|
|
* @param string $obj_uid , Index for case
|
|
*
|
|
* @return void
|
|
*/
|
|
public function putExecuteTriggers($app_uid, $del_index, $obj_type, $obj_uid)
|
|
{
|
|
Validator::isString($app_uid, '$app_uid');
|
|
Validator::appUid($app_uid, '$app_uid');
|
|
Validator::isInteger($del_index, '$del_index');
|
|
|
|
$oCase = new ClassesCases();
|
|
$aField = $oCase->loadCase($app_uid, $del_index);
|
|
$tas_uid = $aField["TAS_UID"];
|
|
|
|
$aField["APP_DATA"] = $oCase->executeTriggers($tas_uid, $obj_type, $obj_uid, "AFTER", $aField["APP_DATA"]);
|
|
$aField = $oCase->updateCase($app_uid, $aField);
|
|
}
|
|
|
|
/**
|
|
* Get Steps evaluate
|
|
*
|
|
* @access public
|
|
* @param string $app_uid , Uid for case
|
|
* @param int $del_index , Index for case
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getSteps($app_uid, $del_index)
|
|
{
|
|
Validator::isString($app_uid, '$app_uid');
|
|
Validator::appUid($app_uid, '$app_uid');
|
|
Validator::isInteger($del_index, '$del_index');
|
|
|
|
$oCase = new ClassesCases();
|
|
$aCaseField = $oCase->loadCase($app_uid, $del_index);
|
|
$tas_uid = $aCaseField["TAS_UID"];
|
|
$pro_uid = $aCaseField["PRO_UID"];
|
|
|
|
$oApplication = new Applications();
|
|
$aField = $oApplication->getSteps($app_uid, $del_index, $tas_uid, $pro_uid);
|
|
|
|
return $aField;
|
|
}
|
|
|
|
/**
|
|
* This function get the status information
|
|
*
|
|
* @param array $result
|
|
* @param string $status
|
|
*
|
|
* @return array
|
|
* @throws Exception
|
|
*/
|
|
private function getStatusInfoFormatted(array $result, string $status = '')
|
|
{
|
|
try {
|
|
$record = head($result);
|
|
$arrayData = [
|
|
'APP_STATUS' => empty($status) ? $record['APP_STATUS'] : $status,
|
|
'DEL_INDEX' => [],
|
|
'PRO_UID' => $record['PRO_UID']
|
|
];
|
|
foreach ($result as $record) {
|
|
$arrayData['DEL_INDEX'][] = $record['DEL_INDEX'];
|
|
}
|
|
//Return
|
|
return $arrayData;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get status info Case
|
|
*
|
|
* @param string $appUid Unique id of Case
|
|
* @param int $index Delegation index
|
|
* @param string $userUid Unique id of User
|
|
*
|
|
* @return array Return an array with status info Case, array empty otherwise
|
|
* @throws Exception
|
|
*
|
|
* @see workflow/engine/methods/cases/main_init.php
|
|
* @see workflow/engine/methods/cases/opencase.php
|
|
* @see \ProcessMaker\BusinessModel\Cases::setCaseVariables()
|
|
* @see \ProcessMaker\BusinessModel\Cases\InputDocument::getCasesInputDocuments()
|
|
* @see \ProcessMaker\BusinessModel\Cases\InputDocument::throwExceptionIfHaventPermissionToDelete()
|
|
* @see \ProcessMaker\BusinessModel\Cases\OutputDocument::throwExceptionIfCaseNotIsInInbox()
|
|
* @see \ProcessMaker\BusinessModel\Cases\OutputDocument::throwExceptionIfHaventPermissionToDelete()
|
|
*/
|
|
public function getStatusInfo(string $appUid, int $index = 0, string $userUid = "")
|
|
{
|
|
try {
|
|
$arrayData = [];
|
|
// Verify data
|
|
$this->throwExceptionIfNotExistsCase($appUid, $index, $this->getFieldNameByFormatFieldName("APP_UID"));
|
|
// Get the case number
|
|
$caseNumber = ModelApplication::getCaseNumber($appUid);
|
|
// Status is PAUSED
|
|
$result = Delay::getPaused($caseNumber, $index, $userUid);
|
|
if (!empty($result)) {
|
|
$arrayData = $this->getStatusInfoFormatted($result, 'PAUSED');
|
|
return $arrayData;
|
|
}
|
|
|
|
// Status is UNASSIGNED
|
|
$query = Delegation::query()->select([
|
|
'APP_DELEGATION.APP_NUMBER',
|
|
'APP_DELEGATION.DEL_INDEX',
|
|
'APP_DELEGATION.PRO_UID'
|
|
]);
|
|
$query->taskAssignType('SELF_SERVICE');
|
|
$query->threadOpen()->withoutUserId();
|
|
// Filter specific user
|
|
if (!empty($userUid)) {
|
|
$delegation = new Delegation();
|
|
$delegation->casesUnassigned($query, $userUid);
|
|
}
|
|
// Filter specific case
|
|
$query->case($caseNumber);
|
|
// Filter specific index
|
|
if ($index > 0) {
|
|
$query->index($index);
|
|
}
|
|
$results = $query->get();
|
|
$arrayData = $results->values()->toArray();
|
|
if (!empty($arrayData)) {
|
|
$arrayData = $this->getStatusInfoFormatted($arrayData, 'UNASSIGNED');
|
|
return $arrayData;
|
|
}
|
|
|
|
// Status is TO_DO, DRAFT
|
|
$query = Delegation::query()->select([
|
|
'APPLICATION.APP_STATUS',
|
|
'APP_DELEGATION.APP_NUMBER',
|
|
'APP_DELEGATION.DEL_INDEX',
|
|
'APP_DELEGATION.PRO_UID'
|
|
]);
|
|
$query->joinApplication();
|
|
// Filter the status TO_DO and DRAFT
|
|
$query->casesInProgress([1, 2]);
|
|
// Filter the OPEN thread
|
|
$query->threadOpen();
|
|
// Filter specific case
|
|
$query->case($caseNumber);
|
|
// Filter specific index
|
|
if ($index > 0) {
|
|
$query->index($index);
|
|
}
|
|
// Filter specific user
|
|
if (!empty($userUid)) {
|
|
$userId = !empty($userUid) ? User::getId($userUid) : 0;
|
|
$query->userId($userId);
|
|
}
|
|
$results = $query->get();
|
|
$arrayData = $results->values()->toArray();
|
|
|
|
if (!empty($arrayData)) {
|
|
$arrayData = $this->getStatusInfoFormatted($arrayData);
|
|
return $arrayData;
|
|
}
|
|
|
|
// Status is CANCELLED, COMPLETED
|
|
$query = Delegation::query()->select([
|
|
'APPLICATION.APP_STATUS',
|
|
'APP_DELEGATION.APP_NUMBER',
|
|
'APP_DELEGATION.DEL_INDEX',
|
|
'APP_DELEGATION.PRO_UID'
|
|
]);
|
|
$query->joinApplication();
|
|
// Filter the status COMPLETED and CANCELLED
|
|
$query->casesDone([3, 4]);
|
|
// Filter specific case
|
|
$query->case($caseNumber);
|
|
// Filter specific index
|
|
if ($index > 0) {
|
|
$query->index($index);
|
|
}
|
|
// Filter specific user
|
|
if (!empty($userUid)) {
|
|
$userId = !empty($userUid) ? User::getId($userUid) : 0;
|
|
$query->userId($userId);
|
|
}
|
|
$query->lastThread();
|
|
$results = $query->get();
|
|
$arrayData = $results->values()->toArray();
|
|
if (!empty($arrayData)) {
|
|
$arrayData = $this->getStatusInfoFormatted($arrayData);
|
|
return $arrayData;
|
|
}
|
|
|
|
// Status is PARTICIPATED
|
|
$arrayData = Delegation::getParticipatedInfo($appUid);
|
|
if (!empty($arrayData)) {
|
|
return $arrayData;
|
|
}
|
|
|
|
return $arrayData;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get process list for start case
|
|
*
|
|
* @param string $usrUid id of user
|
|
* @param string $typeView type of view
|
|
*
|
|
* @return array Return an array with process list that the user can start.
|
|
* @throws RestException
|
|
*/
|
|
public function getCasesListStarCase($usrUid, $typeView)
|
|
{
|
|
try {
|
|
Validator::usrUid($usrUid, '$usr_uid');
|
|
|
|
$case = new ClassesCases();
|
|
$response = $case->getProcessListStartCase($usrUid, $typeView);
|
|
|
|
return $response;
|
|
} catch (Exception $e) {
|
|
throw (new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage()));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get process list bookmark for start case
|
|
*
|
|
* @param string $usrUid id of user
|
|
* @param string $typeView type of view
|
|
*
|
|
* @return array Return an array with process list that the user can start.
|
|
* @throws Exception
|
|
*/
|
|
public function getCasesListBookmarkStarCase($usrUid, $typeView)
|
|
{
|
|
try {
|
|
Validator::usrUid($usrUid, '$usr_uid');
|
|
|
|
$user = new ModelUsers();
|
|
$fields = $user->load($usrUid);
|
|
$bookmark = empty($fields['USR_BOOKMARK_START_CASES']) ? array() : unserialize($fields['USR_BOOKMARK_START_CASES']);
|
|
|
|
//Getting group id and adding the user id
|
|
$group = new Groups();
|
|
$groups = $group->getActiveGroupsForAnUser($usrUid);
|
|
$groups[] = $usrUid;
|
|
|
|
$c = new Criteria();
|
|
$c->clearSelectColumns();
|
|
$c->addSelectColumn(TaskPeer::TAS_UID);
|
|
$c->addSelectColumn(TaskPeer::TAS_TITLE);
|
|
$c->addSelectColumn(TaskPeer::PRO_UID);
|
|
$c->addSelectColumn(ProcessPeer::PRO_TITLE);
|
|
$c->addJoin(TaskPeer::PRO_UID, ProcessPeer::PRO_UID, Criteria::LEFT_JOIN);
|
|
$c->addJoin(TaskPeer::TAS_UID, TaskUserPeer::TAS_UID, Criteria::LEFT_JOIN);
|
|
$c->add(ProcessPeer::PRO_STATUS, 'ACTIVE');
|
|
$c->add(TaskPeer::TAS_START, 'TRUE');
|
|
$c->add(TaskUserPeer::USR_UID, $groups, Criteria::IN);
|
|
$c->add(TaskPeer::TAS_UID, $bookmark, Criteria::IN);
|
|
|
|
if ($typeView == 'category') {
|
|
$c->addAsColumn('PRO_CATEGORY', 'PCS.PRO_CATEGORY');
|
|
$c->addAsColumn('CATEGORY_NAME', 'PCSCAT.CATEGORY_NAME');
|
|
$c->addAlias('PCS', 'PROCESS');
|
|
$c->addAlias('PCSCAT', 'PROCESS_CATEGORY');
|
|
$aConditions = array();
|
|
$aConditions[] = array(TaskPeer::PRO_UID, 'PCS.PRO_UID');
|
|
$c->addJoinMC($aConditions, Criteria::LEFT_JOIN);
|
|
$aConditions = array();
|
|
$aConditions[] = array('PCS.PRO_CATEGORY', 'PCSCAT.CATEGORY_UID');
|
|
$c->addJoinMC($aConditions, Criteria::LEFT_JOIN);
|
|
}
|
|
$c->setDistinct();
|
|
$rs = TaskPeer::doSelectRS($c);
|
|
|
|
$rs->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$processList = array();
|
|
while ($rs->next()) {
|
|
$row = $rs->getRow();
|
|
if ($typeView == 'category') {
|
|
$processList[] = array(
|
|
'tas_uid' => $row['TAS_UID'],
|
|
'pro_title' => $row['PRO_TITLE'] . '(' . $row['TAS_TITLE'] . ')',
|
|
'pro_uid' => $row['PRO_UID'],
|
|
'pro_category' => $row['PRO_CATEGORY'],
|
|
'category_name' => $row['CATEGORY_NAME']
|
|
);
|
|
} else {
|
|
$processList[] = array(
|
|
'tas_uid' => $row['TAS_UID'],
|
|
'pro_title' => $row['PRO_TITLE'] . '(' . $row['TAS_TITLE'] . ')',
|
|
'pro_uid' => $row['PRO_UID']
|
|
);
|
|
}
|
|
|
|
}
|
|
if (count($processList) == 0) {
|
|
$processList['success'] = 'failure';
|
|
$processList['message'] = G::LoadTranslation('ID_NOT_HAVE_BOOKMARKED_PROCESSES');
|
|
}
|
|
|
|
return $processList;
|
|
} catch (Exception $e) {
|
|
throw (new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage()));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get Users to reassign
|
|
*
|
|
* @param string $userUid Unique id of User (User logged)
|
|
* @param string $taskUid Unique id of Task
|
|
* @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 Users to reassign
|
|
* @throws Exception
|
|
*/
|
|
public function getUsersToReassign(
|
|
$userUid,
|
|
$taskUid,
|
|
$arrayFilterData = null,
|
|
$sortField = null,
|
|
$sortDir = null,
|
|
$start = null,
|
|
$limit = null
|
|
) {
|
|
try {
|
|
$arrayUser = [];
|
|
|
|
$numRecTotal = 0;
|
|
|
|
//Set variables
|
|
$task = TaskPeer::retrieveByPK($taskUid);
|
|
|
|
$processUid = $task->getProUid();
|
|
|
|
$user = new BmUser();
|
|
$task = new ClassesTasks();
|
|
$group = new Groups();
|
|
|
|
//Set variables
|
|
$filterName = 'filter';
|
|
|
|
if (!is_null($arrayFilterData) && is_array($arrayFilterData) && isset($arrayFilterData['filter'])) {
|
|
$arrayAux = [
|
|
'' => 'filter',
|
|
'LEFT' => 'lfilter',
|
|
'RIGHT' => 'rfilter'
|
|
];
|
|
|
|
$filterName = $arrayAux[(isset($arrayFilterData['filterOption'])) ? $arrayFilterData['filterOption'] : ''];
|
|
}
|
|
|
|
//Get data
|
|
if (!is_null($limit) && $limit . '' == '0') {
|
|
//Return
|
|
return [
|
|
'total' => $numRecTotal,
|
|
'start' => (int)((!is_null($start)) ? $start : 0),
|
|
'limit' => (int)((!is_null($limit)) ? $limit : 0),
|
|
$filterName => (!is_null($arrayFilterData) && is_array($arrayFilterData) && isset($arrayFilterData['filter'])) ? $arrayFilterData['filter'] : '',
|
|
'data' => $arrayUser
|
|
];
|
|
}
|
|
|
|
//Set variables
|
|
$processSupervisor = new BmProcessSupervisor();
|
|
|
|
$arrayResult = $processSupervisor->getProcessSupervisors($processUid, 'ASSIGNED', null, null, null,
|
|
'group');
|
|
|
|
$arrayGroupUid = array_merge(
|
|
array_map(function ($value) {
|
|
return $value['GRP_UID'];
|
|
}, $task->getGroupsOfTask($taskUid, 1)), //Groups
|
|
array_map(function ($value) {
|
|
return $value['GRP_UID'];
|
|
}, $task->getGroupsOfTask($taskUid, 2)), //AdHoc Groups
|
|
array_map(function ($value) {
|
|
return $value['grp_uid'];
|
|
}, $arrayResult['data']) //ProcessSupervisor Groups
|
|
);
|
|
|
|
$sqlTaskUser = '
|
|
SELECT ' . TaskUserPeer::USR_UID . '
|
|
FROM ' . TaskUserPeer::TABLE_NAME . '
|
|
WHERE ' . TaskUserPeer::TAS_UID . ' = \'%s\' AND
|
|
' . TaskUserPeer::TU_TYPE . ' IN (1, 2) AND
|
|
' . TaskUserPeer::TU_RELATION . ' = 1
|
|
';
|
|
|
|
$sqlGroupUser = '
|
|
SELECT ' . GroupUserPeer::USR_UID . '
|
|
FROM ' . GroupUserPeer::TABLE_NAME . '
|
|
WHERE ' . GroupUserPeer::GRP_UID . ' IN (%s)
|
|
';
|
|
|
|
$sqlProcessSupervisor = '
|
|
SELECT ' . ProcessUserPeer::USR_UID . '
|
|
FROM ' . ProcessUserPeer::TABLE_NAME . '
|
|
WHERE ' . ProcessUserPeer::PRO_UID . ' = \'%s\' AND
|
|
' . ProcessUserPeer::PU_TYPE . ' = \'%s\'
|
|
';
|
|
|
|
$sqlUserToReassign = '(' . sprintf($sqlTaskUser, $taskUid) . ')';
|
|
|
|
if (!empty($arrayGroupUid)) {
|
|
$sqlUserToReassign .= ' UNION (' . sprintf($sqlGroupUser,
|
|
'\'' . implode('\', \'', $arrayGroupUid) . '\'') . ')';
|
|
}
|
|
|
|
$sqlUserToReassign .= ' UNION (' . sprintf($sqlProcessSupervisor, $processUid, 'SUPERVISOR') . ')';
|
|
|
|
//Query
|
|
$criteria = new Criteria('workflow');
|
|
|
|
$criteria->addSelectColumn(UsersPeer::USR_UID);
|
|
$criteria->addSelectColumn(UsersPeer::USR_USERNAME);
|
|
$criteria->addSelectColumn(UsersPeer::USR_FIRSTNAME);
|
|
$criteria->addSelectColumn(UsersPeer::USR_LASTNAME);
|
|
|
|
$criteria->addAlias('USER_TO_REASSIGN', '(' . $sqlUserToReassign . ')');
|
|
|
|
$criteria->addJoin(UsersPeer::USR_UID, 'USER_TO_REASSIGN.USR_UID', Criteria::INNER_JOIN);
|
|
|
|
if (!is_null($arrayFilterData) && is_array($arrayFilterData) && isset($arrayFilterData['filter']) && trim($arrayFilterData['filter']) != '') {
|
|
$arraySearch = [
|
|
'' => '%' . $arrayFilterData['filter'] . '%',
|
|
'LEFT' => $arrayFilterData['filter'] . '%',
|
|
'RIGHT' => '%' . $arrayFilterData['filter']
|
|
];
|
|
|
|
$search = $arraySearch[(isset($arrayFilterData['filterOption'])) ? $arrayFilterData['filterOption'] : ''];
|
|
|
|
$criteria->add(
|
|
$criteria->getNewCriterion(UsersPeer::USR_USERNAME, $search, Criteria::LIKE)->addOr(
|
|
$criteria->getNewCriterion(UsersPeer::USR_FIRSTNAME, $search, Criteria::LIKE))->addOr(
|
|
$criteria->getNewCriterion(UsersPeer::USR_LASTNAME, $search, Criteria::LIKE))
|
|
);
|
|
}
|
|
|
|
$criteria->add(UsersPeer::USR_STATUS, 'ACTIVE', Criteria::EQUAL);
|
|
|
|
if (!$user->checkPermission($userUid, 'PM_SUPERVISOR')) {
|
|
$criteria->add(UsersPeer::USR_UID, $userUid, Criteria::NOT_EQUAL);
|
|
}
|
|
|
|
//Number records total
|
|
$numRecTotal = UsersPeer::doCount($criteria);
|
|
|
|
//Query
|
|
$conf = new Configurations();
|
|
$sortFieldDefault = UsersPeer::TABLE_NAME . '.' . $conf->userNameFormatGetFirstFieldByUsersTable();
|
|
|
|
if (!is_null($sortField) && trim($sortField) != '') {
|
|
$sortField = strtoupper($sortField);
|
|
|
|
if (in_array(UsersPeer::TABLE_NAME . '.' . $sortField, $criteria->getSelectColumns())) {
|
|
$sortField = UsersPeer::TABLE_NAME . '.' . $sortField;
|
|
} else {
|
|
$sortField = $sortFieldDefault;
|
|
}
|
|
} else {
|
|
$sortField = $sortFieldDefault;
|
|
}
|
|
|
|
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 = UsersPeer::doSelectRS($criteria);
|
|
$rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
|
|
while ($rsCriteria->next()) {
|
|
$row = $rsCriteria->getRow();
|
|
|
|
$arrayUser[] = $row;
|
|
}
|
|
|
|
//Return
|
|
return [
|
|
'total' => $numRecTotal,
|
|
'start' => (int)((!is_null($start)) ? $start : 0),
|
|
'limit' => (int)((!is_null($limit)) ? $limit : 0),
|
|
$filterName => (!is_null($arrayFilterData) && is_array($arrayFilterData) && isset($arrayFilterData['filter'])) ? $arrayFilterData['filter'] : '',
|
|
'data' => $arrayUser
|
|
];
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Batch reassign
|
|
*
|
|
* @param array $data
|
|
*
|
|
* @return json Return an json with the result of the reassigned cases.
|
|
*/
|
|
|
|
public function doPostReassign($data)
|
|
{
|
|
if (!is_array($data)) {
|
|
$isJson = is_string($data) && is_array(G::json_decode($data, true)) ? true : false;
|
|
if ($isJson) {
|
|
$data = G::json_decode($data, true);
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
$dataResponse = $data;
|
|
$casesToReassign = $data['cases'];
|
|
$oCases = new ClassesCases();
|
|
foreach ($casesToReassign as $key => $val) {
|
|
$appDelegation = AppDelegationPeer::retrieveByPK($val['APP_UID'], $val['DEL_INDEX']);
|
|
$existDelegation = $this->validateReassignData($appDelegation, $val, $data, 'DELEGATION_NOT_EXISTS');
|
|
if ($existDelegation) {
|
|
$existDelegation = $this->validateReassignData($appDelegation, $val, $data,
|
|
'USER_NOT_ASSIGNED_TO_TASK');
|
|
if ($existDelegation) {
|
|
$usrUid = '';
|
|
if (array_key_exists('USR_UID', $val)) {
|
|
if ($val['USR_UID'] != '') {
|
|
$usrUid = $val['USR_UID'];
|
|
}
|
|
}
|
|
if ($usrUid == '') {
|
|
$fields = $appDelegation->toArray(BasePeer::TYPE_FIELDNAME);
|
|
$usrUid = $fields['USR_UID'];
|
|
}
|
|
//Will be not able reassign a case when is paused
|
|
$flagPaused = $this->validateReassignData($appDelegation, $val, $data,
|
|
'ID_REASSIGNMENT_PAUSED_ERROR');
|
|
//Current users of OPEN DEL_INDEX thread
|
|
$flagSameUser = $this->validateReassignData($appDelegation, $val, $data,
|
|
'REASSIGNMENT_TO_THE_SAME_USER');
|
|
//reassign case
|
|
if ($flagPaused && $flagSameUser) {
|
|
$reassigned = $oCases->reassignCase($val['APP_UID'], $val['DEL_INDEX'], $usrUid,
|
|
$data['usr_uid_target']);
|
|
$result = $reassigned ? 1 : 0;
|
|
$this->messageResponse = [
|
|
'APP_UID' => $val['APP_UID'],
|
|
'DEL_INDEX' => $val['DEL_INDEX'],
|
|
'RESULT' => $result,
|
|
'STATUS' => 'SUCCESS'
|
|
];
|
|
}
|
|
}
|
|
}
|
|
$dataResponse['cases'][$key] = $this->messageResponse;
|
|
}
|
|
unset($dataResponse['usr_uid_target']);
|
|
|
|
return G::json_encode($dataResponse);
|
|
}
|
|
|
|
/**
|
|
* @param $appDelegation
|
|
* @param $value
|
|
* @param $data
|
|
* @param string $type
|
|
*
|
|
* @return bool
|
|
*/
|
|
private function validateReassignData($appDelegation, $value, $data, $type = 'DELEGATION_NOT_EXISTS')
|
|
{
|
|
$return = true;
|
|
switch ($type) {
|
|
case 'DELEGATION_NOT_EXISTS':
|
|
if (is_null($appDelegation)) {
|
|
$this->messageResponse = [
|
|
'APP_UID' => $value['APP_UID'],
|
|
'DEL_INDEX' => $value['DEL_INDEX'],
|
|
'RESULT' => 0,
|
|
'STATUS' => $type
|
|
];
|
|
$return = false;
|
|
}
|
|
break;
|
|
case 'USER_NOT_ASSIGNED_TO_TASK':
|
|
$task = new BmTask();
|
|
$supervisor = new BmProcessSupervisor();
|
|
$taskUid = $appDelegation->getTasUid();
|
|
$flagBoolean = $task->checkUserOrGroupAssignedTask($taskUid, $data['usr_uid_target']);
|
|
$flagps = $supervisor->isUserProcessSupervisor($appDelegation->getProUid(), $data['usr_uid_target']);
|
|
|
|
if (!$flagBoolean && !$flagps) {
|
|
$this->messageResponse = [
|
|
'APP_UID' => $value['APP_UID'],
|
|
'DEL_INDEX' => $value['DEL_INDEX'],
|
|
'RESULT' => 0,
|
|
'STATUS' => 'USER_NOT_ASSIGNED_TO_TASK'
|
|
];
|
|
$return = false;
|
|
}
|
|
break;
|
|
case 'ID_REASSIGNMENT_PAUSED_ERROR':
|
|
if (AppDelay::isPaused($value['APP_UID'], $value['DEL_INDEX'])) {
|
|
$this->messageResponse = [
|
|
'APP_UID' => $value['APP_UID'],
|
|
'DEL_INDEX' => $value['DEL_INDEX'],
|
|
'RESULT' => 0,
|
|
'STATUS' => G::LoadTranslation('ID_REASSIGNMENT_PAUSED_ERROR')
|
|
];
|
|
$return = false;
|
|
}
|
|
break;
|
|
case 'REASSIGNMENT_TO_THE_SAME_USER':
|
|
$aCurUser = $appDelegation->getCurrentUsers($value['APP_UID'], $value['DEL_INDEX']);
|
|
if (!empty($aCurUser)) {
|
|
foreach ($aCurUser as $keyAux => $val) {
|
|
if ($val === $data['usr_uid_target']) {
|
|
$this->messageResponse = [
|
|
'APP_UID' => $value['APP_UID'],
|
|
'DEL_INDEX' => $value['DEL_INDEX'],
|
|
'RESULT' => 1,
|
|
'STATUS' => 'SUCCESS'
|
|
];
|
|
$return = false;
|
|
}
|
|
}
|
|
} else {
|
|
//DEL_INDEX is CLOSED
|
|
$this->messageResponse = [
|
|
'APP_UID' => $value['APP_UID'],
|
|
'DEL_INDEX' => $value['DEL_INDEX'],
|
|
'RESULT' => 0,
|
|
'STATUS' => G::LoadTranslation('ID_REASSIGNMENT_ERROR')
|
|
];
|
|
$return = false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* If case already routed
|
|
*
|
|
* @param string $app_uid
|
|
* @param string $del_index
|
|
* @param string $usr_uid
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function caseAlreadyRouted($app_uid, $del_index, $usr_uid = '')
|
|
{
|
|
$c = new Criteria('workflow');
|
|
$c->add(AppDelegationPeer::APP_UID, $app_uid);
|
|
$c->add(AppDelegationPeer::DEL_INDEX, $del_index);
|
|
if (!empty($usr_uid)) {
|
|
$c->add(AppDelegationPeer::USR_UID, $usr_uid);
|
|
}
|
|
$c->add(AppDelegationPeer::DEL_FINISH_DATE, null, Criteria::ISNULL);
|
|
|
|
return !(boolean)AppDelegationPeer::doCount($c);
|
|
}
|
|
|
|
/**
|
|
* This function review if the user has processPermissions or the user is supervisor
|
|
*
|
|
* @param string $userUid
|
|
* @param string $applicationUid
|
|
* @param string $dynaformUid
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function checkUserHasPermissionsOrSupervisor($userUid, $applicationUid, $dynaformUid)
|
|
{
|
|
$arrayApplicationData = $this->getApplicationRecordByPk($applicationUid, [], false);
|
|
//Get all access for the user, we no consider the permissions
|
|
$userCanAccess = $this->userAuthorization(
|
|
$userUid,
|
|
$arrayApplicationData['PRO_UID'],
|
|
$applicationUid,
|
|
[],
|
|
[],
|
|
true
|
|
);
|
|
|
|
//We need to get all the object permission consider the BLOCK
|
|
$case = new ClassesCases();
|
|
$allObjectPermissions = $case->getAllObjects($arrayApplicationData['PRO_UID'], $applicationUid, '', $userUid);
|
|
|
|
//Check case tracker
|
|
$flagCaseTracker = $case->getAllObjectsTrackerDynaform($arrayApplicationData['PRO_UID'], $dynaformUid);
|
|
|
|
//Review if the user has participated in the case
|
|
//Review if the user is supervisor in the case and if had assign the objectSupervisor
|
|
//Review if the user has process permission SUMMARY FORM
|
|
//Review if the user has process permission DYNAFORM for the specific form
|
|
//Review if the form is configured for case tracker
|
|
return (
|
|
$userCanAccess['participated']
|
|
|| ($userCanAccess['supervisor'] && in_array($dynaformUid, $userCanAccess['objectSupervisor']))
|
|
|| $allObjectPermissions['SUMMARY_FORM']
|
|
|| in_array($dynaformUid, $allObjectPermissions['DYNAFORMS'])
|
|
|| $flagCaseTracker
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Delete MultipleFile in Case data
|
|
*
|
|
* @param array $arrayApplicationData Case data
|
|
* @param string $variable1 Variable1
|
|
* @param string $variable2 Variable2
|
|
* @param string $type Type (NORMAL, GRID)
|
|
* @param array $arrayDocumentToDelete Document to delete
|
|
*
|
|
* @return array Returns array with Case data updated
|
|
*/
|
|
private function applicationDataDeleteMultipleFile(
|
|
array $arrayApplicationData,
|
|
$variable1,
|
|
$variable2,
|
|
$type,
|
|
array $arrayDocumentToDelete
|
|
) {
|
|
if (array_key_exists($variable1, $arrayApplicationData) &&
|
|
is_array($arrayApplicationData[$variable1]) && !empty($arrayApplicationData[$variable1])
|
|
) {
|
|
switch ($type) {
|
|
case 'NORMAL':
|
|
$arrayAux = $arrayApplicationData[$variable1];
|
|
$arrayApplicationData[$variable1] = [];
|
|
$keyd = null;
|
|
|
|
foreach ($arrayAux as $key => $value) {
|
|
if ($value['appDocUid'] == $arrayDocumentToDelete['appDocUid'] &&
|
|
(int)($value['version']) == (int)($arrayDocumentToDelete['version'])
|
|
) {
|
|
$keyd = $key;
|
|
} else {
|
|
$arrayApplicationData[$variable1][] = $value;
|
|
}
|
|
}
|
|
|
|
if (!is_null($keyd)) {
|
|
$variable1 = $variable1 . '_label';
|
|
|
|
if (array_key_exists($variable1, $arrayApplicationData) &&
|
|
is_array($arrayApplicationData[$variable1]) && !empty($arrayApplicationData[$variable1])
|
|
) {
|
|
$arrayAux = $arrayApplicationData[$variable1];
|
|
$arrayApplicationData[$variable1] = [];
|
|
|
|
foreach ($arrayAux as $key => $value) {
|
|
if ($key != $keyd) {
|
|
$arrayApplicationData[$variable1][] = $value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 'GRID':
|
|
foreach ($arrayApplicationData[$variable1] as $key => $value) {
|
|
if (array_key_exists($variable2, $value)) {
|
|
$arrayApplicationData[$variable1][$key] = $this->applicationDataDeleteMultipleFile(
|
|
$value, $variable2, null, 'NORMAL', $arrayDocumentToDelete
|
|
);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Return
|
|
return $arrayApplicationData;
|
|
}
|
|
|
|
/**
|
|
* Delete MultipleFile
|
|
*
|
|
* @param string $applicationUid Unique id of Case
|
|
* @param array $arrayVariableDocumentToDelete Variable with Documents to delete
|
|
*
|
|
* @return void
|
|
*/
|
|
public function deleteMultipleFile($applicationUid, array $arrayVariableDocumentToDelete)
|
|
{
|
|
$case = new ClassesCases();
|
|
$appDocument = new AppDocument();
|
|
|
|
$arrayApplicationData = $this->getApplicationRecordByPk($applicationUid, [], false);
|
|
$arrayApplicationData['APP_DATA'] = $case->unserializeData($arrayApplicationData['APP_DATA']);
|
|
$flagDelete = false;
|
|
foreach ($arrayVariableDocumentToDelete as $key => $value) {
|
|
if (is_array($value) && !empty($value)) {
|
|
$type = '';
|
|
|
|
$arrayAux = $value;
|
|
$arrayAux = array_shift($arrayAux);
|
|
|
|
if (array_key_exists('appDocUid', $arrayAux)) {
|
|
$type = 'NORMAL';
|
|
} else {
|
|
$arrayAux = array_shift($arrayAux);
|
|
$arrayAux = array_shift($arrayAux);
|
|
|
|
if (array_key_exists('appDocUid', $arrayAux)) {
|
|
$type = 'GRID';
|
|
}
|
|
}
|
|
|
|
switch ($type) {
|
|
case 'NORMAL':
|
|
$variable = $key;
|
|
$arrayDocumentDelete = $value;
|
|
|
|
foreach ($arrayDocumentDelete as $value2) {
|
|
if ($value2['appDocUid'] !== "") {
|
|
$appDocument->remove($value2['appDocUid'], (int)($value2['version']));
|
|
|
|
$arrayApplicationData['APP_DATA'] = $this->applicationDataDeleteMultipleFile(
|
|
$arrayApplicationData['APP_DATA'], $variable, null, $type, $value2
|
|
);
|
|
|
|
$flagDelete = true;
|
|
}
|
|
}
|
|
break;
|
|
case 'GRID':
|
|
$grid = $key;
|
|
|
|
foreach ($value as $value2) {
|
|
foreach ($value2 as $key3 => $value3) {
|
|
$variable = $key3;
|
|
$arrayDocumentDelete = $value3;
|
|
|
|
foreach ($arrayDocumentDelete as $value4) {
|
|
if ($value4['appDocUid'] !== "") {
|
|
$appDocument->remove($value4['appDocUid'], (int)($value4['version']));
|
|
|
|
$arrayApplicationData['APP_DATA'] = $this->applicationDataDeleteMultipleFile(
|
|
$arrayApplicationData['APP_DATA'], $grid, $variable, $type, $value4
|
|
);
|
|
|
|
$flagDelete = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Delete simple files.
|
|
//The observations suggested by 'pull request' approver are applied (please see pull request).
|
|
foreach ($arrayVariableDocumentToDelete as $key => $value) {
|
|
if (isset($value['appDocUid'])) {
|
|
$appDocument->remove($value['appDocUid'], (int)(isset($value['version']) ? $value['version'] : 1));
|
|
if (is_string($arrayApplicationData['APP_DATA'][$key])) {
|
|
try {
|
|
$files = G::json_decode($arrayApplicationData['APP_DATA'][$key]);
|
|
foreach ($files as $keyFile => $valueFile) {
|
|
if ($valueFile === $value['appDocUid']) {
|
|
unset($files[$keyFile]);
|
|
}
|
|
}
|
|
$arrayApplicationData['APP_DATA'][$key] = G::json_encode($files);
|
|
} catch (Exception $e) {
|
|
$message = $e->getMessage();
|
|
$context = $value;
|
|
Log::channel(':DeleteFile')->error($message, Bootstrap::context($context));
|
|
}
|
|
}
|
|
$flagDelete = true;
|
|
}
|
|
}
|
|
|
|
if ($flagDelete) {
|
|
$result = $case->updateCase($applicationUid, $arrayApplicationData);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get Permissions, Participate, Access, Objects supervisor
|
|
*
|
|
* @param string $usrUid
|
|
* @param string $proUid
|
|
* @param string $appUid
|
|
* @param array $rolesPermissions, the roles that we need to review
|
|
* @param array $objectPermissions, the permissions that we need to review
|
|
* @param boolean $objectSupervisor, if we need to get all the objects supervisor
|
|
* @param string $tasUid
|
|
*
|
|
* @return array
|
|
*/
|
|
public function userAuthorization(
|
|
$usrUid,
|
|
$proUid,
|
|
$appUid,
|
|
$rolesPermissions = [],
|
|
$objectPermissions = [],
|
|
$objectSupervisor = false,
|
|
$tasUid = ''
|
|
) {
|
|
$arrayAccess = [];
|
|
|
|
// User has participated
|
|
$arrayAccess['participated'] = Delegation::participation($appUid, $usrUid);
|
|
|
|
// User is supervisor
|
|
$supervisor = new BmProcessSupervisor();
|
|
$isSupervisor = $supervisor->isUserProcessSupervisor($proUid, $usrUid);
|
|
$arrayAccess['supervisor'] = ($isSupervisor) ? true : false;
|
|
|
|
// If the user is supervisor we will to return the object assigned
|
|
if ($isSupervisor && $objectSupervisor) {
|
|
$ps = new BmProcessSupervisor();
|
|
$arrayAccess['objectSupervisor'] = $ps->getObjectSupervisor($proUid);
|
|
}
|
|
|
|
// Roles Permissions
|
|
if (count($rolesPermissions) > 0) {
|
|
global $RBAC;
|
|
foreach ($rolesPermissions as $value) {
|
|
$arrayAccess['rolesPermissions'][$value] = ($RBAC->userCanAccess($value) < 0) ? false : true;
|
|
}
|
|
}
|
|
|
|
// Object Permissions
|
|
if (count($objectPermissions) > 0) {
|
|
$case = new ClassesCases();
|
|
foreach ($objectPermissions as $key => $value) {
|
|
$resPermission = $case->getAllObjectsFrom($proUid, $appUid, $tasUid, $usrUid, $value);
|
|
if (isset($resPermission[$key])) {
|
|
$arrayAccess['objectPermissions'][$key] = $resPermission[$key];
|
|
}
|
|
}
|
|
}
|
|
|
|
return $arrayAccess;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get Global System Variables
|
|
* @param array $appData
|
|
* @param array $dataVariable
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function getGlobalVariables($appData = array(), $dataVariable = array())
|
|
{
|
|
$appData = array_change_key_case($appData, CASE_UPPER);
|
|
$dataVariable = array_change_key_case($dataVariable, CASE_UPPER);
|
|
|
|
$result = [];
|
|
//we get the appData parameters
|
|
if (!empty($appData['APPLICATION'])) {
|
|
$result['APPLICATION'] = $appData['APPLICATION'];
|
|
}
|
|
if (!empty($appData['PROCESS'])) {
|
|
$result['PROCESS'] = $appData['PROCESS'];
|
|
}
|
|
if (!empty($appData['TASK'])) {
|
|
$result['TASK'] = $appData['TASK'];
|
|
}
|
|
if (!empty($appData['INDEX'])) {
|
|
$result['INDEX'] = $appData['INDEX'];
|
|
}
|
|
|
|
//we try to get the missing elements
|
|
if (!empty($dataVariable['APP_UID']) && empty($result['APPLICATION'])) {
|
|
$result['APPLICATION'] = $dataVariable['APP_UID'];
|
|
}
|
|
if (!empty($dataVariable['PRO_UID']) && empty($result['PROCESS'])) {
|
|
$result['PROCESS'] = $dataVariable['PRO_UID'];
|
|
}
|
|
|
|
$result['USER_LOGGED'] = '';
|
|
$result['USR_USERNAME'] = '';
|
|
global $RBAC;
|
|
if (isset($RBAC) && isset($RBAC->aUserInfo)) {
|
|
$result['USER_LOGGED'] = isset($RBAC->aUserInfo['USER_INFO']['USR_UID']) ? $RBAC->aUserInfo['USER_INFO']['USR_UID'] : '';
|
|
$result['USR_USERNAME'] = isset($RBAC->aUserInfo['USER_INFO']['USR_USERNAME']) ? $RBAC->aUserInfo['USER_INFO']['USR_USERNAME'] : '';
|
|
}
|
|
if (empty($result['USER_LOGGED'])) {
|
|
$result['USER_LOGGED'] = Server::getUserId();
|
|
if (!empty($result['USER_LOGGED'])) {
|
|
$oUserLogged = new ModelUsers();
|
|
$oUserLogged->load($result['USER_LOGGED']);
|
|
$result['USR_USERNAME'] = $oUserLogged->getUsrUsername();
|
|
}
|
|
}
|
|
|
|
//the parameter dataVariable may contain additional elements
|
|
$result = array_merge($dataVariable, $result);
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Get index last participation from a user
|
|
*
|
|
* This function return the last participation
|
|
* by default is not considered the status OPEN or CLOSED
|
|
* in parallel cases return the first to find
|
|
* @param string $appUid
|
|
* @param string $userUid
|
|
* @param string $threadStatus
|
|
*
|
|
* @return integer delIndex
|
|
*/
|
|
public function getLastParticipatedByUser($appUid, $userUid, $threadStatus = '')
|
|
{
|
|
$criteria = new Criteria('workflow');
|
|
$criteria->addSelectColumn(AppDelegationPeer::DEL_INDEX);
|
|
$criteria->addSelectColumn(AppDelegationPeer::DEL_THREAD_STATUS);
|
|
$criteria->add(AppDelegationPeer::APP_UID, $appUid, Criteria::EQUAL);
|
|
$criteria->add(AppDelegationPeer::USR_UID, $userUid, Criteria::EQUAL);
|
|
if (!empty($threadStatus)) {
|
|
$criteria->add(AppDelegationPeer::DEL_THREAD_STATUS, $threadStatus, Criteria::EQUAL);
|
|
}
|
|
$dataSet = AppDelegationPeer::doSelectRS($criteria);
|
|
$dataSet->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$dataSet->next();
|
|
$row = $dataSet->getRow();
|
|
|
|
return isset($row['DEL_INDEX']) ? $row['DEL_INDEX'] : 0;
|
|
}
|
|
|
|
/**
|
|
* Get last index, we can considering the pause thread
|
|
*
|
|
* This function return the last index thread and will be considered the paused cases
|
|
* Is created by Jump to and redirect the correct thread
|
|
* by default is not considered the paused thread
|
|
* in parallel cases return the first thread to find
|
|
* @param string $appUid
|
|
* @param boolean $checkCaseIsPaused
|
|
*
|
|
* @return integer delIndex
|
|
*/
|
|
public function getOneLastThread($appUid, $checkCaseIsPaused = false)
|
|
{
|
|
$criteria = new Criteria('workflow');
|
|
$criteria->addSelectColumn(AppDelegationPeer::DEL_INDEX);
|
|
$criteria->addSelectColumn(AppDelegationPeer::DEL_THREAD_STATUS);
|
|
$criteria->add(AppDelegationPeer::APP_UID, $appUid, Criteria::EQUAL);
|
|
$dataSet = AppDelegationPeer::doSelectRS($criteria);
|
|
$dataSet->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$dataSet->next();
|
|
$row = $dataSet->getRow();
|
|
$delIndex = 0;
|
|
while (is_array($row)) {
|
|
$delIndex = $row['DEL_INDEX'];
|
|
if ($checkCaseIsPaused && AppDelay::isPaused($appUid, $delIndex)) {
|
|
return $delIndex;
|
|
}
|
|
$dataSet->next();
|
|
$row = $dataSet->getRow();
|
|
}
|
|
|
|
return $delIndex;
|
|
}
|
|
|
|
/**
|
|
* This function will be return the criteria for the search filter
|
|
*
|
|
* We considered in the search criteria the custom cases list,
|
|
* the titles related to: caseTitle taskTitle processTitle and
|
|
* the case number
|
|
* @param Criteria $criteria , must be contain the initial criteria for search
|
|
* @param string $listPeer , name of the list class
|
|
* @param string $search , the parameter for search in the table
|
|
* @param string $additionalClassName , name of the className of pmtable
|
|
* @param array $additionalColumns , columns related to the custom cases list ex: TABLE_NAME.COLUMN_NAME
|
|
*
|
|
* @throws PropelException
|
|
*/
|
|
public function getSearchCriteriaListCases(
|
|
&$criteria,
|
|
$listPeer,
|
|
$search,
|
|
$additionalClassName = '',
|
|
$additionalColumns = []
|
|
) {
|
|
$tmpCriteria = '';
|
|
//If we have additional tables configured in the custom cases list, prepare the variables for search
|
|
if (count($additionalColumns) > 0) {
|
|
require_once(PATH_DATA_SITE . 'classes' . PATH_SEP . $additionalClassName . '.php');
|
|
|
|
$columnPivot = current($additionalColumns);
|
|
$tableAndColumn = explode(".", $columnPivot);
|
|
$type = PmTable::getTypeOfColumn($listPeer, $tableAndColumn[0], $tableAndColumn[1]);
|
|
$tmpCriteria = $this->defineCriteriaByColumnType($type, $columnPivot, $search);
|
|
|
|
//We prepare the query related to the custom cases list
|
|
foreach (array_slice($additionalColumns, 1) as $column) {
|
|
$tableAndColumn = explode(".", $column);
|
|
$type = PmTable::getTypeOfColumn($listPeer, $tableAndColumn[0], $tableAndColumn[1]);
|
|
$tmpCriteria = $this->defineCriteriaByColumnType($type, $column, $search)->addOr($tmpCriteria);
|
|
|
|
}
|
|
}
|
|
|
|
if (!empty($tmpCriteria)) {
|
|
$criteria->add(
|
|
$criteria->getNewCriterion($listPeer::APP_TITLE, '%' . $search . '%', Criteria::LIKE)->addOr(
|
|
$criteria->getNewCriterion($listPeer::APP_TAS_TITLE, '%' . $search . '%', Criteria::LIKE)->addOr(
|
|
$criteria->getNewCriterion($listPeer::APP_PRO_TITLE, '%' . $search . '%',
|
|
Criteria::LIKE)->addOr(
|
|
$criteria->getNewCriterion($listPeer::APP_NUMBER, $search, Criteria::EQUAL)->addOr(
|
|
$tmpCriteria
|
|
))))
|
|
);
|
|
} else {
|
|
$criteria->add(
|
|
$criteria->getNewCriterion($listPeer::APP_TITLE, '%' . $search . '%', Criteria::LIKE)->addOr(
|
|
$criteria->getNewCriterion($listPeer::APP_TAS_TITLE, '%' . $search . '%', Criteria::LIKE)->addOr(
|
|
$criteria->getNewCriterion($listPeer::APP_PRO_TITLE, '%' . $search . '%',
|
|
Criteria::LIKE)->addOr(
|
|
$criteria->getNewCriterion($listPeer::APP_NUMBER, $search, Criteria::EQUAL))))
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Define the criteria according to the column type
|
|
*
|
|
* @param string $fieldType
|
|
* @param string $column
|
|
* @param string $search
|
|
*
|
|
* @return Criteria
|
|
*/
|
|
private function defineCriteriaByColumnType($fieldType, $column, $search)
|
|
{
|
|
$newCriteria = new Criteria("workflow");
|
|
|
|
switch ($fieldType) {
|
|
case CreoleTypes::BOOLEAN:
|
|
$criteria = $newCriteria->getNewCriterion($column, $search, Criteria::EQUAL);
|
|
break;
|
|
case CreoleTypes::BIGINT:
|
|
case CreoleTypes::INTEGER:
|
|
case CreoleTypes::SMALLINT:
|
|
case CreoleTypes::TINYINT:
|
|
$criteria = $newCriteria->getNewCriterion($column, $search, Criteria::EQUAL);
|
|
break;
|
|
case CreoleTypes::REAL:
|
|
case CreoleTypes::DECIMAL:
|
|
case CreoleTypes::DOUBLE:
|
|
case CreoleTypes::FLOAT:
|
|
$criteria = $newCriteria->getNewCriterion($column, $search, Criteria::LIKE);
|
|
break;
|
|
case CreoleTypes::CHAR:
|
|
case CreoleTypes::LONGVARCHAR:
|
|
case CreoleTypes::VARCHAR:
|
|
$criteria = $newCriteria->getNewCriterion($column, "%" . $search . "%", Criteria::LIKE);
|
|
break;
|
|
case CreoleTypes::DATE:
|
|
case CreoleTypes::TIME:
|
|
case CreoleTypes::TIMESTAMP://DATETIME
|
|
//@todo use the same constant in other places
|
|
if (preg_match(UtilDateTime::REGEX_IS_DATE,
|
|
$search, $arrayMatch)) {
|
|
$criteria = $newCriteria->getNewCriterion($column, $search, Criteria::GREATER_EQUAL);
|
|
} else {
|
|
$criteria = $newCriteria->getNewCriterion($column, $search, Criteria::EQUAL);
|
|
}
|
|
break;
|
|
default:
|
|
$criteria = $newCriteria->getNewCriterion($column, $search, Criteria::EQUAL);
|
|
}
|
|
|
|
return $criteria;
|
|
}
|
|
|
|
/**
|
|
* This function get the table.column by order by the result
|
|
* We can include the additional table related to the custom cases list
|
|
*
|
|
* @param string $listPeer, name of the list class
|
|
* @param string $field, name of the fieldName
|
|
* @param string $sort, name of column by sort
|
|
* @param string $defaultSort, name of column by sort default
|
|
* @param string $additionalClassName, name of the className of pmTable
|
|
* @param array $additionalColumns, columns related to the custom cases list with the format TABLE_NAME.COLUMN_NAME
|
|
* @param string $userDisplayFormat, user information display format
|
|
*
|
|
* @return string|array could be an string $tableName, could be an array $columnSort
|
|
*/
|
|
public function getSortColumn(
|
|
$listPeer,
|
|
$field,
|
|
$sort,
|
|
$defaultSort,
|
|
$additionalClassName = '',
|
|
$additionalColumns = array(),
|
|
$userDisplayFormat = ''
|
|
) {
|
|
$columnSort = $defaultSort;
|
|
$tableName = '';
|
|
|
|
//We will check if the column by sort is a LIST table
|
|
$columnsList = $listPeer::getFieldNames($field);
|
|
if (in_array($sort, $columnsList)) {
|
|
switch ($sort) {
|
|
case 'DEL_PREVIOUS_USR_UID':
|
|
$columnSort = $this->buildOrderFieldFormatted($columnsList, $userDisplayFormat, 'DEL_PREVIOUS_');
|
|
break;
|
|
case 'USR_UID':
|
|
$columnSort = $this->buildOrderFieldFormatted($columnsList, $userDisplayFormat, 'DEL_CURRENT_');
|
|
if (empty($columnSort)) {
|
|
$columnSort = $this->buildOrderFieldFormatted($columnsList, $userDisplayFormat, '', false);
|
|
}
|
|
break;
|
|
default:
|
|
$columnSort = $listPeer::TABLE_NAME . '.' . $sort;
|
|
}
|
|
} else {
|
|
//We will sort by CUSTOM CASE LIST table
|
|
if (count($additionalColumns) > 0) {
|
|
require_once(PATH_DATA_SITE . 'classes' . PATH_SEP . $additionalClassName . '.php');
|
|
$aTable = explode('.', current($additionalColumns));
|
|
if (count($aTable) > 0) {
|
|
$tableName = $aTable[0];
|
|
}
|
|
}
|
|
if (in_array($tableName . '.' . $sort, $additionalColumns)) {
|
|
$columnSort = $tableName . '.' . $sort;
|
|
}
|
|
}
|
|
|
|
return $columnSort;
|
|
}
|
|
|
|
/**
|
|
* When we order columns related to the user information we need to use the userDisplayFormat
|
|
*
|
|
* @param array $columnsList, the list of columns in the table
|
|
* @param string $format, the user display format
|
|
* @param string $prefix, the initial name of the columns related to the USR_FIRSTNAME USR_LASTNAME USR_USERNAME
|
|
*
|
|
* @return array $columnSort, columns by apply the sql command ORDER BY
|
|
*/
|
|
public function buildOrderFieldFormatted($columnsList, $format, $prefix = 'DEL_PREVIOUS_', $validate = true)
|
|
{
|
|
$columnSort = [];
|
|
|
|
if (!$validate || (in_array($prefix . 'USR_FIRSTNAME', $columnsList) &&
|
|
in_array($prefix . 'USR_LASTNAME', $columnsList) &&
|
|
in_array($prefix . 'USR_USERNAME', $columnsList))
|
|
) {
|
|
switch ($format) {
|
|
case '@firstName @lastName':
|
|
array_push($columnSort, $prefix . 'USR_FIRSTNAME');
|
|
array_push($columnSort, $prefix . 'USR_LASTNAME');
|
|
break;
|
|
case '@firstName @lastName (@userName)':
|
|
array_push($columnSort, $prefix . 'USR_FIRSTNAME');
|
|
array_push($columnSort, $prefix . 'USR_LASTNAME');
|
|
array_push($columnSort, $prefix . 'USR_USERNAME');
|
|
break;
|
|
case '@userName':
|
|
array_push($columnSort, $prefix . 'USR_USERNAME');
|
|
break;
|
|
case '@userName (@firstName @lastName)':
|
|
array_push($columnSort, $prefix . 'USR_USERNAME');
|
|
array_push($columnSort, $prefix . 'USR_FIRSTNAME');
|
|
array_push($columnSort, $prefix . 'USR_LASTNAME');
|
|
break;
|
|
case '@lastName, @firstName':
|
|
array_push($columnSort, $prefix . 'USR_LASTNAME');
|
|
array_push($columnSort, $prefix . 'USR_FIRSTNAME');
|
|
break;
|
|
case '@lastName @firstName':
|
|
array_push($columnSort, $prefix . 'USR_LASTNAME');
|
|
array_push($columnSort, $prefix . 'USR_FIRSTNAME');
|
|
break;
|
|
case '@lastName, @firstName (@userName)':
|
|
array_push($columnSort, $prefix . 'USR_LASTNAME');
|
|
array_push($columnSort, $prefix . 'USR_FIRSTNAME');
|
|
array_push($columnSort, $prefix . 'USR_USERNAME');
|
|
break;
|
|
default:
|
|
array_push($columnSort, $prefix . 'USR_USERNAME');
|
|
break;
|
|
}
|
|
}
|
|
|
|
return $columnSort;
|
|
}
|
|
|
|
/** This function verify if the user is a supervisor
|
|
* If we send the formUid we will to review if has the object form assigned
|
|
*
|
|
* @param string $usrUid, Uid related to the user
|
|
* @param string $appUid, Uid related to the case
|
|
* @param string $formUid, Uid related to the dynaform
|
|
* @param string $proUid, Uid related to the process
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isSupervisorFromForm($usrUid, $appUid, $formUid, $proUid = '')
|
|
{
|
|
|
|
//We will to search the proUid related to the appUid
|
|
if (empty($proUid)) {
|
|
$arrayApplicationData = $this->getApplicationRecordByPk($appUid, [], false);
|
|
$proUid = $arrayApplicationData['PRO_UID'];
|
|
}
|
|
|
|
$supervisor = new BmProcessSupervisor();
|
|
$isSupervisor = $supervisor->isUserProcessSupervisor($proUid, $usrUid);
|
|
|
|
//We will check if the supervisor has the object form assigned
|
|
if ($isSupervisor) {
|
|
$cases = new ClassesCases();
|
|
$resultDynaForm = $cases->getAllDynaformsStepsToRevise($appUid);
|
|
$isSupervisor = false;
|
|
while ($resultDynaForm->next()) {
|
|
$row = $resultDynaForm->getRow();
|
|
//Review if the supervisor has the form assigned
|
|
if ($row["STEP_UID_OBJ"] === $formUid) {
|
|
$isSupervisor = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $isSupervisor;
|
|
}
|
|
|
|
/**
|
|
* Upload file in the corresponding folder
|
|
*
|
|
* @param string $userUid
|
|
* @param string $appUid
|
|
* @param string $varName
|
|
* @param mixed $inpDocUid
|
|
* @param string $appDocUid
|
|
* @param int $delegationIndex
|
|
*
|
|
* @return array
|
|
* @throws Exception
|
|
*/
|
|
public function uploadFiles($userUid, $appUid, $varName, $inpDocUid = -1, $appDocUid = null, $delegationIndex = null)
|
|
{
|
|
$response = [];
|
|
// Review the appUid
|
|
Validator::appUid($appUid, '$appUid');
|
|
|
|
if (isset($_FILES["form"]["name"]) && count($_FILES["form"]["name"]) > 0) {
|
|
// Get the delIndex related to the case
|
|
$cases = new ClassesCases();
|
|
if (!empty($delegationIndex)) {
|
|
$delIndex = $delegationIndex;
|
|
} else {
|
|
$delIndex = $cases->getCurrentDelegation($appUid, $userUid);
|
|
}
|
|
// Get information about the user
|
|
$user = new ModelUsers();
|
|
$userCreator = $user->loadDetailed($userUid)['USR_FULLNAME'];
|
|
$i = 0;
|
|
foreach ($_FILES["form"]["name"] as $fieldIndex => $fieldValue) {
|
|
if (!is_array($fieldValue)) {
|
|
$arrayFileName = [
|
|
'name' => $_FILES["form"]["name"][$fieldIndex],
|
|
'tmp_name' => $_FILES["form"]["tmp_name"][$fieldIndex],
|
|
'error' => $_FILES["form"]["error"][$fieldIndex]
|
|
];
|
|
|
|
// We will to review the validation related to the Input document
|
|
$file = [
|
|
'filename' => $arrayFileName["name"],
|
|
'path' => $arrayFileName["tmp_name"]
|
|
];
|
|
$this->canUploadFileRelatedToInput($inpDocUid, $file);
|
|
|
|
// There is no error, the file uploaded with success
|
|
if ($arrayFileName["error"] === UPLOAD_ERR_OK) {
|
|
$appDocument = new AppDocument();
|
|
$objCreated = $appDocument->uploadAppDocument(
|
|
$appUid,
|
|
$userUid,
|
|
$delIndex,
|
|
$inpDocUid ,
|
|
$arrayFileName,
|
|
$varName,
|
|
$appDocUid
|
|
);
|
|
$response[$i] = [
|
|
'appDocUid' => $objCreated->getAppDocUid(),
|
|
'docVersion' => $objCreated->getDocVersion(),
|
|
'appDocFilename' => $objCreated->getAppDocFilename(),
|
|
'appDocCreateDate' => $objCreated->getAppDocCreateDate(),
|
|
'appDocType' => $objCreated->getAppDocType(),
|
|
'appDocIndex' => $objCreated->getAppDocIndex(),
|
|
'appDocCreateUser' => $userCreator
|
|
];
|
|
|
|
$i++;
|
|
} else {
|
|
throw new UploadException($arrayFileName['error']);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
throw new Exception(G::LoadTranslation('ID_ERROR_UPLOAD_FILE_CONTACT_ADMINISTRATOR'));
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* Add a case note
|
|
*
|
|
* @param string $appUid
|
|
* @param string $userUid
|
|
* @param string $note
|
|
* @param bool $sendMail
|
|
* @param array $files
|
|
* @param int $appNUmber
|
|
*
|
|
* @see Ajax::cancelCase()
|
|
* @see Ajax::pauseCase()
|
|
* @see Ajax::reassignCase()
|
|
* @see AppProxy::postNote()
|
|
* @see WsBase::addCaseNote()
|
|
* @see Cases::saveCaseNote()
|
|
*
|
|
* @return array
|
|
*/
|
|
public function addNote($appUid, $userUid, $note, $sendMail = false, $files = [], $appNumber = 0)
|
|
{
|
|
// Get the appNumber if was not send
|
|
if ($appNumber === 0) {
|
|
$appNumber = ModelApplication::getCaseNumber($appUid);
|
|
}
|
|
|
|
// Register the note
|
|
$attributes = [
|
|
"APP_UID" => $appUid,
|
|
"APP_NUMBER" => $appNumber,
|
|
"USR_UID" => $userUid,
|
|
"NOTE_DATE" => date("Y-m-d H:i:s"),
|
|
"NOTE_CONTENT" => $note,
|
|
"NOTE_TYPE" => "USER",
|
|
"NOTE_AVAILABILITY" => "PUBLIC",
|
|
"NOTE_RECIPIENTS" => ""
|
|
];
|
|
$newNote = Notes::create($attributes);
|
|
// Get the FK
|
|
$noteId = $newNote->NOTE_ID;
|
|
|
|
$attachments = [];
|
|
// Register the files related to the note
|
|
if (!empty($files) || !empty($_FILES["filesToUpload"])) {
|
|
$filesResponse = $this->uploadFilesInCaseNotes($userUid, $appUid, $files, $noteId);
|
|
foreach ($filesResponse['attachments'] as $key => $value) {
|
|
$attachments[$key] = [];
|
|
$attachments[$key]['APP_DOC_FILENAME'] = $value['APP_DOC_FILENAME'];
|
|
$attachments[$key]['LINK'] = "../cases/casesShowCaseNotes?a=" . $value["APP_DOC_UID"] . "&v=" . $value["DOC_VERSION"];
|
|
}
|
|
|
|
}
|
|
|
|
// Send the email
|
|
if ($sendMail) {
|
|
// Get the recipients
|
|
$case = new ClassesCases();
|
|
$p = $case->getUsersParticipatedInCase($appUid, 'ACTIVE');
|
|
$noteRecipientsList = [];
|
|
|
|
foreach ($p["array"] as $key => $userParticipated) {
|
|
if ($key != '') {
|
|
$noteRecipientsList[] = $key;
|
|
}
|
|
}
|
|
|
|
$noteRecipients = implode(",", $noteRecipientsList);
|
|
$note = stripslashes($note);
|
|
|
|
// Send the notification
|
|
$appNote = new AppNotes();
|
|
$appNote->sendNoteNotification($appUid, $userUid, $note, $noteRecipients, '', 0, $noteId);
|
|
}
|
|
|
|
// Prepare the response
|
|
$result = [];
|
|
$result['success'] = 'success';
|
|
$result['message'] = '';
|
|
$result['attachments'] = $attachments;
|
|
$result['attachment_errors'] = [];
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Upload file related to the case notes
|
|
*
|
|
* @param string $userUid
|
|
* @param string $appUid
|
|
* @param array $filesReferences
|
|
* @param int $noteId
|
|
*
|
|
* @return array
|
|
* @throws Exception
|
|
*/
|
|
public function uploadFilesInCaseNotes($userUid, $appUid, $filesReferences = [], $noteId = 0)
|
|
{
|
|
$files = [];
|
|
if (!empty($_FILES["filesToUpload"])) {
|
|
$upload = true;
|
|
// This format is from ext-js multipart
|
|
$filesName = !empty($_FILES["filesToUpload"]["name"]) ? $_FILES["filesToUpload"]["name"] : [];
|
|
$filesTmpName = !empty($_FILES["filesToUpload"]["tmp_name"]) ? $_FILES["filesToUpload"]["tmp_name"] : [];
|
|
$filesError = !empty($_FILES["filesToUpload"]["error"]) ? $_FILES["filesToUpload"]["error"] : [];
|
|
|
|
foreach ($filesName as $index => $value) {
|
|
if (!empty($value)) {
|
|
$files[] = [
|
|
'name' => $filesName[$index],
|
|
'tmp_name' => $filesTmpName[$index],
|
|
'error' => $filesError[$index]
|
|
];
|
|
}
|
|
}
|
|
} elseif (!empty($filesReferences)) {
|
|
$upload = false;
|
|
// Array with path references
|
|
foreach ($filesReferences as $fileIndex => $fileName) {
|
|
$nameFile = !is_numeric($fileIndex) ? basename($fileIndex) : basename($fileName);
|
|
$files[] = [
|
|
'name' => $nameFile,
|
|
'tmp_name' => $fileName,
|
|
'error' => UPLOAD_ERR_OK
|
|
];
|
|
}
|
|
}
|
|
|
|
// Rules validation
|
|
foreach ($files as $key => $value) {
|
|
$entry = [
|
|
"filename" => $value['name'],
|
|
"path" => $value['tmp_name']
|
|
];
|
|
$validator = ValidationUploadedFiles::getValidationUploadedFiles()
|
|
->runRulesForPostFilesOfNote($entry);
|
|
if ($validator->fails()) {
|
|
Notes::where('NOTE_ID', '=', $noteId)->delete();
|
|
$messageError = G::LoadTranslation('ID_THE_FILE_COULDNT_BE_UPLOADED');
|
|
throw new CaseNoteUploadFile($messageError . ' ' . $validator->getMessage());
|
|
}
|
|
}
|
|
|
|
// Get the delIndex related to the case
|
|
$cases = new ClassesCases();
|
|
$delIndex = $cases->getCurrentDelegation($appUid);
|
|
|
|
// We will to register the files in the database
|
|
$response = [];
|
|
$response['attachments'] = [];
|
|
$response['attachment_errors'] = [];
|
|
if (!empty($files)) {
|
|
$i = 0;
|
|
$j = 0;
|
|
foreach ($files as $fileIndex => $fileName) {
|
|
// There is no error, the file uploaded with success
|
|
if ($fileName["error"] === UPLOAD_ERR_OK) {
|
|
$appDocUid = G::generateUniqueID();
|
|
|
|
// Upload or move the file
|
|
$isUploaded = saveAppDocument($fileName, $appUid, $appDocUid, 1, $upload);
|
|
|
|
// If the file was uploaded correctly we will to register in the DB
|
|
if ($isUploaded) {
|
|
$attributes = [
|
|
"DOC_ID" => $noteId,
|
|
"APP_DOC_UID" => $appDocUid,
|
|
"DOC_VERSION" => 1,
|
|
"APP_UID" => $appUid,
|
|
"DEL_INDEX" => $delIndex,
|
|
"USR_UID" => $userUid,
|
|
"DOC_UID" => -1,
|
|
"APP_DOC_TYPE" => 'CASE_NOTE',
|
|
"APP_DOC_CREATE_DATE" => date("Y-m-d H:i:s"),
|
|
"APP_DOC_FILENAME" => $fileName["name"]
|
|
];
|
|
Documents::create($attributes);
|
|
|
|
// List of files uploaded or copy
|
|
$response['attachments'][$i++] = $attributes;
|
|
} else {
|
|
$response['attachment_errors'][$j++] = [
|
|
'error' => 'error',
|
|
'file' => $fileName["name"]
|
|
];
|
|
}
|
|
} else {
|
|
throw new UploadException($fileName['error']);
|
|
}
|
|
}
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* Run the validations related to an Input Document
|
|
*
|
|
* @param array $file
|
|
* @param mixed $inpDocUid
|
|
*
|
|
* @return boolean
|
|
* @throws ExceptionRestApi
|
|
*/
|
|
private function canUploadFileRelatedToInput($file, $inpDocUid = -1)
|
|
{
|
|
if ($inpDocUid !== -1) {
|
|
$inputDocument = new InputDocument();
|
|
$inputExist = $inputDocument->InputExists($inpDocUid);
|
|
if ($inputExist) {
|
|
$inputProperties = $inputDocument->load($inpDocUid);
|
|
$inpDocTypeFile = $inputProperties['INP_DOC_TYPE_FILE'];
|
|
$inpDocMaxFileSize = (int)$inputProperties["INP_DOC_MAX_FILESIZE"];
|
|
$inpDocMaxFileSizeUnit = $inputProperties["INP_DOC_MAX_FILESIZE_UNIT"];
|
|
|
|
$validator = new FileValidator();
|
|
// Rule: extension
|
|
$validator->addRule()
|
|
->validate($file, function ($file) use ($inpDocTypeFile) {
|
|
$result = G::verifyInputDocExtension($inpDocTypeFile, $file->filename, $file->path);
|
|
|
|
return $result->status === false;
|
|
})
|
|
->status(415)
|
|
->message(G::LoadTranslation('ID_UPLOAD_INVALID_DOC_TYPE_FILE', [$inpDocTypeFile]))
|
|
->log(function ($rule) {
|
|
$message = $rule->getMessage();
|
|
$context = [
|
|
'filename' => $rule->getData()->filename,
|
|
'url' => $_SERVER["REQUEST_URI"] ?? ''
|
|
];
|
|
Log::channel(':phpUpload')->notice($message, Bootstrap::context($context));
|
|
});
|
|
// Rule: maximum file size
|
|
$validator->addRule()
|
|
->validate($file, function ($file) use ($inpDocMaxFileSize, $inpDocMaxFileSizeUnit) {
|
|
if ($inpDocMaxFileSize > 0) {
|
|
$totalMaxFileSize = $inpDocMaxFileSize * ($inpDocMaxFileSizeUnit == self::UNIT_MB ? self::MB_TO_KB * self::MB_TO_KB : self::MB_TO_KB);
|
|
$fileSize = filesize($file->path);
|
|
if ($fileSize > $totalMaxFileSize) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
})
|
|
->status(413)
|
|
->message(G::LoadTranslation("ID_UPLOAD_INVALID_DOC_MAX_FILESIZE",
|
|
[$inpDocMaxFileSize . $inpDocMaxFileSizeUnit]))
|
|
->log(function ($rule) {
|
|
$message = $rule->getMessage();
|
|
$context = [
|
|
'filename' => $rule->getData()->filename,
|
|
'url' => $_SERVER["REQUEST_URI"] ?? ''
|
|
];
|
|
Log::channel(':phpUpload')->notice($message, Bootstrap::context($context));
|
|
});
|
|
$validator->validate();
|
|
// We will to review if the validator has some error
|
|
if ($validator->fails()) {
|
|
throw new ExceptionRestApi($validator->getMessage(), $validator->getStatus());
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get the cases related to the self services timeout that needs to execute the trigger related
|
|
*
|
|
* @return array
|
|
* @throws Exception
|
|
*/
|
|
public static function executeSelfServiceTimeout()
|
|
{
|
|
try {
|
|
$casesSelfService = ListUnassigned::selfServiceTimeout();
|
|
$casesExecuted = [];
|
|
foreach ($casesSelfService as $row) {
|
|
$appUid = $row["APP_UID"];
|
|
$appNumber = $row["APP_NUMBER"];
|
|
$delIndex = $row["DEL_INDEX"];
|
|
$delegateDate = $row["DEL_DELEGATE_DATE"];
|
|
$proUid = $row["PRO_UID"];
|
|
$taskUid = $row["TAS_UID"];
|
|
$taskSelfServiceTime = intval($row["TAS_SELFSERVICE_TIME"]);
|
|
$taskSelfServiceTimeUnit = $row["TAS_SELFSERVICE_TIME_UNIT"];
|
|
$triggerUid = $row["TAS_SELFSERVICE_TRIGGER_UID"];
|
|
|
|
/*----------------------------------********---------------------------------*/
|
|
$typeOfExecution = $row["TAS_SELFSERVICE_EXECUTION"];
|
|
$flagExecuteOnce = true;
|
|
// This option will be executed just once, can check if was executed before
|
|
if ($typeOfExecution == 'ONCE') {
|
|
$appTimeout = new AppTimeoutAction();
|
|
$appTimeout->setCaseUid($appUid);
|
|
$appTimeout->setIndex($delIndex);
|
|
$caseExecuted = $appTimeout->cases();
|
|
$flagExecuteOnce = !empty($caseExecuted) ? false : true;
|
|
}
|
|
/*----------------------------------********---------------------------------*/
|
|
|
|
// Add the time in the corresponding unit to the delegation date
|
|
$delegateDate = calculateDate($delegateDate, $taskSelfServiceTimeUnit, $taskSelfServiceTime);
|
|
$datetime = new DateTime($delegateDate);
|
|
//please the seconds is variant not must be considered
|
|
$delegateDate = $datetime->format('Y-m-d H:i:00');
|
|
|
|
// Define the current time
|
|
$datetime = new DateTime('now');
|
|
//please the seconds is variant not must be considered
|
|
$currentDate = $datetime->format('Y-m-d H:i:00');
|
|
$currentDate = UtilDateTime::convertDataToUtc($currentDate);
|
|
|
|
// Check if the triggers to be executed
|
|
if ($currentDate >= $delegateDate && $flagExecuteOnce) {
|
|
// Review if the session process is defined
|
|
$sessProcess = null;
|
|
$sessProcessSw = false;
|
|
if (isset($_SESSION["PROCESS"])) {
|
|
$sessProcess = $_SESSION["PROCESS"];
|
|
$sessProcessSw = true;
|
|
}
|
|
// Load case data
|
|
$case = new ClassesCases();
|
|
$appFields = $case->loadCase($appUid);
|
|
$appFields["APP_DATA"]["APPLICATION"] = $appUid;
|
|
// Set the process defined in the case related
|
|
$_SESSION["PROCESS"] = $appFields["PRO_UID"];
|
|
|
|
// Get the trigger related and execute
|
|
$triggersList = [];
|
|
if (!empty($triggerUid)) {
|
|
$trigger = new Triggers();
|
|
$trigger->setTrigger($triggerUid);
|
|
$triggersList = $trigger->triggers();
|
|
}
|
|
|
|
// If the trigger exist, let's to execute
|
|
if (!empty($triggersList)) {
|
|
// Execute the trigger defined in the self service timeout
|
|
$fieldsCase['APP_DATA'] = $case->executeTriggerFromList(
|
|
$triggersList,
|
|
$appFields['APP_DATA'],
|
|
'SELF_SERVICE_TIMEOUT',
|
|
'',
|
|
'',
|
|
'',
|
|
false
|
|
);
|
|
|
|
// Update the case
|
|
$case->updateCase($appUid, $fieldsCase);
|
|
|
|
/*----------------------------------********---------------------------------*/
|
|
if ($typeOfExecution == 'ONCE') {
|
|
// Saving the case`s data if the 'Execution' is set in ONCE.
|
|
$appTimeoutActionExecuted = new AppTimeoutActionExecuted();
|
|
$dataSelf = [];
|
|
$dataSelf["APP_UID"] = $appUid;
|
|
$dataSelf["DEL_INDEX"] = $delIndex;
|
|
$dataSelf["EXECUTION_DATE"] = time();
|
|
$appTimeoutActionExecuted->create($dataSelf);
|
|
}
|
|
/*----------------------------------********---------------------------------*/
|
|
|
|
array_push($casesExecuted, $appNumber); // Register the cases executed
|
|
|
|
// Logging this action
|
|
$context = [
|
|
'appUid' => $appUid,
|
|
'appNumber' => $appNumber,
|
|
'triUid' => $triggerUid,
|
|
'proUid' => $proUid,
|
|
'tasUid' => $taskUid,
|
|
'selfServiceTime' => $taskSelfServiceTime,
|
|
'selfServiceTimeUnit' => $taskSelfServiceTimeUnit,
|
|
'currentDate' => $currentDate,
|
|
'delegateDate' => $delegateDate
|
|
];
|
|
Log::channel('taskScheduler:executeSelfServiceTimeout')->info('TriggerExecution', Bootstrap::context($context));
|
|
}
|
|
|
|
unset($_SESSION["PROCESS"]);
|
|
|
|
if ($sessProcessSw) {
|
|
$_SESSION["PROCESS"] = $sessProcess;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $casesExecuted;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get DynaForms Uids assigned as steps in the related process by application Uid
|
|
*
|
|
* @param string $appUid
|
|
* @param int $sourceTask
|
|
* @param string $dynUid
|
|
* @param string $caseStatus
|
|
* @return array
|
|
*/
|
|
public static function dynaFormsByApplication($appUid, $sourceTask = 0, $dynUid = '', $caseStatus = '')
|
|
{
|
|
// Select distinct DYN_UID
|
|
$query = ModelApplication::query()->select('STEP.STEP_UID_OBJ AS DYN_UID')->distinct();
|
|
|
|
// Join with STEP table
|
|
$query->join('STEP', function ($join) {
|
|
$join->on('APPLICATION.PRO_UID', '=', 'STEP.PRO_UID');
|
|
$join->on('STEP.STEP_TYPE_OBJ', '=', DB::raw("'DYNAFORM'"));
|
|
});
|
|
|
|
// Filter by application Uid
|
|
$query->where('APPLICATION.APP_UID', '=', $appUid);
|
|
|
|
// Filter by source task
|
|
if (!empty($sourceTask) && (int)$sourceTask != 0) {
|
|
$query->where('STEP.TAS_UID', '=', $sourceTask);
|
|
}
|
|
|
|
// Filter by DynaForm Uid
|
|
if ($dynUid != '' && $dynUid != '0') {
|
|
$query->where('STEP.STEP_UID_OBJ', '=', $dynUid);
|
|
}
|
|
|
|
// Get results
|
|
$dynaForms = [];
|
|
$items = $query->get();
|
|
$items->each(function ($item) use (&$dynaForms) {
|
|
$dynaForms[] = $item->DYN_UID;
|
|
});
|
|
|
|
// Return results
|
|
return $dynaForms;
|
|
}
|
|
}
|