fernando/luos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

PMC-786

Browse Source
This commit is contained in:
Paula Quispe
2019-05-13 16:44:40 -04:00
parent 4064c1bebf
commit ff33075228
14 changed files with 1655 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
phpunit.xml
View File

@@ -17,6 +17,9 @@
<testsuite name="Unit">
<directory suffix="Test.php">./tests/Unit</directory>
</testsuite>
<testsuite name="Performance">
<directory>./tests/Performance/</directory>
</testsuite>
</testsuites>
<filter>
@@ -45,6 +48,8 @@
<env name="MSSQL_DATABASE" value="testexternal" />
<env name="MSSQL_USERNAME" value="test" />
<env name="MSSQL_PASSWORD" value="test" />
<!--Performance Mysql test-->
<env name="RUN_MYSQL_PERFORMANCE_TESTS" value="false" />
<!--Php variables-->
<var name="APP_ENV" value="testing" />
<var name="SYS_SYS" value="test" />

514
tests/Performance/workflow/engine/src/ProcessMaker/Model/DelegationTest.php Normal file
View File

@@ -0,0 +1,514 @@
<?php
namespace Tests\Perfomance\workflow\src\ProcessMaker\Model;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use ProcessMaker\Model\AppAssignSelfServiceValue;
use ProcessMaker\Model\AppAssignSelfServiceValueGroup;
use ProcessMaker\Model\Application;
use ProcessMaker\Model\Delegation;
use ProcessMaker\Model\GroupUser;
use ProcessMaker\Model\Groupwf;
use ProcessMaker\Model\Process;
use ProcessMaker\Model\Task;
use ProcessMaker\Model\TaskUser;
use ProcessMaker\Model\User;
use Tests\TestCase;
class DelegationTest extends TestCase
{
use DatabaseTransactions;
//This parameter is used for performance test, It has to be divisible by 4, because we have 4 types of self-service
private $totalCases;
//This parameter is used for performance test, It the maximum time in seconds
private $maximumExecutionTime;
/**
* Define values of some parameters of the test
*/
protected function setUp()
{
if (!env('RUN_MYSQL_PERFORMANCE_TESTS')) {
$this->markTestSkipped('Test related to the performance are disabled for this server configuration');
} else {
$this->totalCases = (int)env('TOTAL_CASES', 120);
$this->maximumExecutionTime = (int)env('MAX_EXECUTION_TIME', 60);
}
}
/**
* This checks the counters is working properly in self-service user assigned
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_user_assigned()
{
//Define the total of cases to create
$total = $this->totalCases;
//Define the maximum time of execution
$maximumTime = $this->maximumExecutionTime;
//Create process
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task self service
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create the register in delegation relate to self-service
factory(Delegation::class, $total)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$timeStart = microtime(true);
Delegation::countSelfService($user->USR_UID);
$timeEnd = microtime(true);
$time = $timeEnd - $timeStart;
//Compare if the time of execution is minor than the time defined in the .env
$this->assertLessThan($maximumTime, $time);
error_log('it_should_count_cases_by_user_with_self_service_user_assigned took [' . $total . ']--->' . $time);
}
/**
* This checks the counters is working properly in self-service-value-based when the variable has a value related with the USR_UID
* When the value assigned in the variable @@ARRAY_OF_USERS = [USR_UID]
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_value_based_usr_uid()
{
//Define the total of cases to create
$total = $this->totalCases;
//Define the maximum time of execution
$maximumTime = $this->maximumExecutionTime;
//Create process
$process = factory(Process::class)->create();
//Create a case
$application = factory(Application::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task self service value based
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => 2,
'TAS_ID' => $task->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in self-service
factory(Delegation::class, $total)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$timeStart = microtime(true);
Delegation::countSelfService($user->USR_UID);
$timeEnd = microtime(true);
$time = $timeEnd - $timeStart;
//Compare if the time of execution is minor than the time defined in the .env
$this->assertLessThan($maximumTime, $time);
error_log('it_should_count_cases_by_user_with_self_service_value_based_usr_uid took [' . $total . ']--->' . $time);
}
/**
* This checks the counters is working properly in self-service and self-service value based
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_mixed_with_self_service_value_based()
{
//Define the total of cases to create
$total = $this->totalCases;
//Define the maximum time of execution
$maximumTime = $this->maximumExecutionTime;
//Create process
$process = factory(Process::class)->create();
//Create a case
$application = factory(Application::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task self service
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create the register in self service
factory(Delegation::class, $total / 2)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Create a task self service value based
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => 2,
'TAS_ID' => $task1->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in self service value based
factory(Delegation::class, $total / 2)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$timeStart = microtime(true);
Delegation::countSelfService($user->USR_UID);
$timeEnd = microtime(true);
$time = $timeEnd - $timeStart;
//Compare if the time of execution is minor than the time defined in the .env
$this->assertLessThan($maximumTime, $time);
error_log('it_should_count_cases_by_user_with_self_service_mixed_with_self_service_value_based took [' . $total . ']--->' . $time);
}
/**
* This checks the counters is working properly in self-service group assigned
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_group_assigned()
{
//Define the total of cases to create
$total = $this->totalCases;
//Define the maximum time of execution
$maximumTime = $this->maximumExecutionTime;
//Create process
$process = factory(Process::class)->create();
//Create group
$group = factory(Groupwf::class)->create();
//Create user
$user = factory(User::class)->create();
//Assign a user in the group
factory(GroupUser::class)->create([
'GRP_UID' => $group->GRP_UID,
'GRP_ID' => $group->GRP_ID,
'USR_UID' => $user->USR_UID
]);
//Create a task self service
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 2, //Related to the group
'TU_TYPE' => 1
]);
//Create the register in self-service
factory(Delegation::class, $total)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$timeStart = microtime(true);
Delegation::countSelfService($user->USR_UID);
$timeEnd = microtime(true);
$time = $timeEnd - $timeStart;
//Compare if the time of execution is minor than the time defined in the .env
$this->assertLessThan($maximumTime, $time);
error_log('it_should_count_cases_by_user_with_self_service_group_assigned took [' . $total . ']--->' . $time);
}
/**
* This checks the counters is working properly in self-service-value-based when the variable has a value related with the GRP_UID
* When the value assigned in the variable @@ARRAY_OF_USERS = [GRP_UID]
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_value_based_grp_uid()
{
//Define the total of cases to create
$total = $this->totalCases;
//Define the maximum time of execution
$maximumTime = $this->maximumExecutionTime;
//Create process
$process = factory(Process::class)->create();
//Create a task self service value based
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process->PRO_UID
]);
//Create a case
$application = factory(Application::class)->create();
//Create group
$group = factory(Groupwf::class)->create();
//Create user
$user = factory(User::class)->create([
'USR_USERNAME' => 'gary',
'USR_LASTNAME' => 'Gary',
'USR_FIRSTNAME' => 'Bailey',
]);
//Assign a user in the group
factory(GroupUser::class)->create([
'GRP_UID' => $group->GRP_UID,
'GRP_ID' => $group->GRP_ID,
'USR_UID' => $user->USR_UID,
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'APP_UID' => $application->APP_UID,
'DEL_INDEX' => 2,
'TAS_ID' => $task->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $group->GRP_UID,
'ASSIGNEE_ID' => $group->GRP_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 2 //Related to the user=1 related to the group=2
]);
//Create the register in self-service
factory(Delegation::class, $total)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => 2,
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$timeStart = microtime(true);
Delegation::countSelfService($user->USR_UID);
$timeEnd = microtime(true);
$time = $timeEnd - $timeStart;
//Compare if the time of execution is minor than the time defined in the .env
$this->assertLessThan($maximumTime, $time);
error_log('it_should_count_cases_by_user_with_self_service_value_based_grp_uid took [' . $total . ']--->' . $time);
}
/**
* This checks the counters is working properly in self-service user and group assigned in parallel task
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_user_and_group_assigned_parallel_task()
{
//Define the total of cases to create
$total = $this->totalCases;
//Define the maximum time of execution
$maximumTime = $this->maximumExecutionTime;
//Create process
$process = factory(Process::class)->create();
//Create group
$group = factory(Groupwf::class)->create();
//Create user
$user = factory(User::class)->create();
//Assign a user in the group
factory(GroupUser::class)->create([
'GRP_UID' => $group->GRP_UID,
'GRP_ID' => $group->GRP_ID,
'USR_UID' => $user->USR_UID
]);
//Create a task self service
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task1
factory(TaskUser::class)->create([
'TAS_UID' => $task1->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create a task self service
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task2
factory(TaskUser::class)->create([
'TAS_UID' => $task2->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create a task self service
$task3 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class)->create([
'TAS_UID' => $task3->TAS_UID,
'USR_UID' => $group->GRP_UID,
'TU_RELATION' => 2, //Related to the group
'TU_TYPE' => 1
]);
//Create a task self service
$task4 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class)->create([
'TAS_UID' => $task4->TAS_UID,
'USR_UID' => $group->GRP_UID,
'TU_RELATION' => 2, //Related to the group
'TU_TYPE' => 1
]);
//Create the register in self-service related to the task1
factory(Delegation::class, $total / 4)->create([
'TAS_ID' => $task1->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Create the register in self-service related to the task2
factory(Delegation::class, $total / 4)->create([
'TAS_ID' => $task2->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Create the register in self-service related to the task3
factory(Delegation::class, $total / 4)->create([
'TAS_ID' => $task3->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Create the register in self-service related to the task4
factory(Delegation::class, $total / 4)->create([
'TAS_ID' => $task4->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$timeStart = microtime(true);
Delegation::countSelfService($user->USR_UID);
$timeEnd = microtime(true);
$time = $timeEnd - $timeStart;
//Compare if the time of execution is minor than the time defined in the .env
$this->assertLessThan($maximumTime, $time);
error_log('it_should_count_cases_by_user_with_self_service_user_and_group_assigned_parallel_task took [' . $total . ']--->' . $time);
}
/**
* This checks the counters is working properly in self-service-value-based with GRP_UID and USR_UID in parallel task
* When the value assigned in the variable @@ARRAY_OF_USERS = [GRP_UID, USR_UID]
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_value_based_usr_uid_and_grp_uid()
{
//Define the total of cases to create
$total = $this->totalCases;
//Define the maximum time of execution
$maximumTime = $this->maximumExecutionTime;
//Create process
$process = factory(Process::class)->create();
//Create a case
$application = factory(Application::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task1 self service value based
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task1->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in self-service
factory(Delegation::class, $total / 2)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task1->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Create a task2 self service value based
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task2->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in self-service
factory(Delegation::class, $total / 2)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task2->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$timeStart = microtime(true);
Delegation::countSelfService($user->USR_UID);
$timeEnd = microtime(true);
$time = $timeEnd - $timeStart;
//Compare if the time of execution is minor than the time defined in the .env
$this->assertLessThan($maximumTime, $time);
error_log('it_should_count_cases_by_user_with_self_service_value_based_usr_uid_and_grp_uid took [' . $total . ']--->' . $time);
}
}

419
tests/unit/workflow/engine/src/ProcessMaker/Model/DelegationTest.php
View File

@@ -2,13 +2,17 @@
namespace Tests\unit\workflow\src\ProcessMaker\Model;
use G;
use Faker;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use ProcessMaker\Model\AppAssignSelfServiceValue;
use ProcessMaker\Model\AppAssignSelfServiceValueGroup;
use ProcessMaker\Model\Application;
use ProcessMaker\Model\Delegation;
use ProcessMaker\Model\GroupUser;
use ProcessMaker\Model\Groupwf;
use ProcessMaker\Model\Process;
use ProcessMaker\Model\ProcessCategory;
use ProcessMaker\Model\Task;
use ProcessMaker\Model\TaskUser;
use ProcessMaker\Model\User;
use Tests\TestCase;
@@ -1136,4 +1140,417 @@ class DelegationTest extends TestCase
// Check the information returned
$this->assertEmpty($results);
}
/**
* This checks the counters is working properly in self-service user assigned
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_user_assigned()
{
//Create process
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task self service
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create the register in delegation relate to self-service
factory(Delegation::class, 25)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$result = Delegation::countSelfService($user->USR_UID);
$this->assertEquals(25, $result);
}
/**
* This checks the counters is working properly in self-service-value-based when the variable has a value related with the USR_UID
* When the value assigned in the variable @@ARRAY_OF_USERS = [USR_UID]
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_value_based_usr_uid()
{
//Create process
$process = factory(Process::class)->create();
//Create a case
$application = factory(Application::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task self service value based
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => 2,
'TAS_ID' => $task->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in self-service
factory(Delegation::class, 25)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$result = Delegation::countSelfService($user->USR_UID);
$this->assertEquals(25, $result);
}
/**
* This checks the counters is working properly in self-service and self-service value based
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_mixed_with_self_service_value_based()
{
//Create process
$process = factory(Process::class)->create();
//Create a case
$application = factory(Application::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task self service
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create the register in self service
factory(Delegation::class, 15)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Create a task self service value based
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => 2,
'TAS_ID' => $task1->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in self service value based
factory(Delegation::class, 15)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$result = Delegation::countSelfService($user->USR_UID);
$this->assertEquals(30, $result);
}
/**
* This checks the counters is working properly in self-service group assigned
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_group_assigned()
{
//Create process
$process = factory(Process::class)->create();
//Create group
$group = factory(Groupwf::class)->create();
//Create user
$user = factory(User::class)->create();
//Assign a user in the group
factory(GroupUser::class)->create([
'GRP_UID' => $group->GRP_UID,
'GRP_ID' => $group->GRP_ID,
'USR_UID' => $user->USR_UID
]);
//Create a task self service
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 2, //Related to the group
'TU_TYPE' => 1
]);
//Create the register in self-service
factory(Delegation::class, 25)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$result = Delegation::countSelfService($user->USR_UID);
$this->assertEquals(25, $result);
}
/**
* This checks the counters is working properly in self-service-value-based when the variable has a value related with the GRP_UID
* When the value assigned in the variable @@ARRAY_OF_USERS = [GRP_UID]
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_value_based_grp_uid()
{
//Create process
$process = factory(Process::class)->create();
//Create a task self service value based
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process->PRO_UID
]);
//Create a case
$application = factory(Application::class)->create();
//Create group
$group = factory(Groupwf::class)->create();
//Create user
$user = factory(User::class)->create([
'USR_USERNAME' => 'gary',
'USR_LASTNAME' => 'Gary',
'USR_FIRSTNAME' => 'Bailey',
]);
//Assign a user in the group
factory(GroupUser::class)->create([
'GRP_UID' => $group->GRP_UID,
'GRP_ID' => $group->GRP_ID,
'USR_UID' => $user->USR_UID,
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'APP_UID' => $application->APP_UID,
'DEL_INDEX' => 2,
'TAS_ID' => $task->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $group->GRP_UID,
'ASSIGNEE_ID' => $group->GRP_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 2 //Related to the user=1 related to the group=2
]);
//Create the register in self-service
factory(Delegation::class, 25)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => 2,
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$result = Delegation::countSelfService($user->USR_UID);
$this->assertEquals(25, $result);
}
/**
* This checks the counters is working properly in self-service user and group assigned in parallel task
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_user_and_group_assigned_parallel_task()
{
//Create process
$process = factory(Process::class)->create();
//Create group
$group = factory(Groupwf::class)->create();
//Create user
$user = factory(User::class)->create();
//Assign a user in the group
factory(GroupUser::class)->create([
'GRP_UID' => $group->GRP_UID,
'GRP_ID' => $group->GRP_ID,
'USR_UID' => $user->USR_UID
]);
//Create a task self service
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task1
factory(TaskUser::class)->create([
'TAS_UID' => $task1->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create a task self service
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task2
factory(TaskUser::class)->create([
'TAS_UID' => $task2->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create a task self service
$task3 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class)->create([
'TAS_UID' => $task3->TAS_UID,
'USR_UID' => $group->GRP_UID,
'TU_RELATION' => 2, //Related to the group
'TU_TYPE' => 1
]);
//Create a task self service
$task4 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class)->create([
'TAS_UID' => $task4->TAS_UID,
'USR_UID' => $group->GRP_UID,
'TU_RELATION' => 2, //Related to the group
'TU_TYPE' => 1
]);
//Create the register in self-service related to the task1
factory(Delegation::class, 10)->create([
'TAS_ID' => $task1->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Create the register in self-service related to the task2
factory(Delegation::class, 10)->create([
'TAS_ID' => $task2->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Create the register in self-service related to the task3
factory(Delegation::class, 10)->create([
'TAS_ID' => $task3->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Create the register in self-service related to the task4
factory(Delegation::class, 10)->create([
'TAS_ID' => $task4->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$result = Delegation::countSelfService($user->USR_UID);
$this->assertEquals(40, $result);
}
/**
* This checks the counters is working properly in self-service-value-based with GRP_UID and USR_UID in parallel task
* When the value assigned in the variable @@ARRAY_OF_USERS = [GRP_UID, USR_UID]
* @covers Delegation::countSelfService
* @test
*/
public function it_should_count_cases_by_user_with_self_service_value_based_usr_uid_and_grp_uid()
{
//Create process
$process = factory(Process::class)->create();
//Create a case
$application = factory(Application::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task1 self service value based
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task1->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in self-service
factory(Delegation::class, 10)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task1->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Create a task2 self service value based
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task2->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in self-service
factory(Delegation::class, 15)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task2->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
]);
//Review the count self-service
$result = Delegation::countSelfService($user->USR_UID);
$this->assertEquals(25, $result);
}
}

572
tests/unit/workflow/engine/src/ProcessMaker/Model/ListUnassignedTest.php
View File

@@ -32,32 +32,29 @@ class ListUnassignedTest extends TestCase
public function it_should_count_cases_by_user_with_self_service_user_assigned()
{
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Create a task self service
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 15)->create([
'TAS_ID' => $task[0]->TAS_ID
factory(ListUnassigned::class, 25)->create([
'TAS_ID' => $task->TAS_ID
]);
$timeStart = microtime(true);
$result = ListUnassigned::doCount($user[0]->USR_UID);
$timeEnd = microtime(true);
$this->assertEquals(15, $result);
$time = $timeEnd - $timeStart;
error_log('it_should_count_cases_by_user_with_self_service_user_assigned took [15]--->' . $time);
//Review the count self-service
$result = ListUnassigned::countSelfService($user->USR_UID);
$this->assertEquals(25, $result);
}
/**
@@ -69,41 +66,38 @@ class ListUnassignedTest extends TestCase
public function it_should_count_cases_by_user_with_self_service_value_based_usr_uid()
{
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create a case
$application = factory(Application::class, 1)->create();
$application = factory(Application::class)->create();
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Create a task self service value based
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class, 1)->create([
'APP_NUMBER' => $application[0]->APP_NUMBER,
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => 2,
'TAS_ID' => $task[0]->TAS_ID
'TAS_ID' => $task->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class, 1)->create([
'ID' => $appSelfValue[0]->ID,
'GRP_UID' => $user[0]->USR_UID,
'ASSIGNEE_ID' => $user[0]->USR_ID, //The usrId or grpId
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 10)->create([
'APP_NUMBER' => $application[0]->APP_NUMBER,
'DEL_INDEX' => $appSelfValue[0]->DEL_INDEX,
'TAS_ID' => $task[0]->TAS_ID,
factory(ListUnassigned::class, 25)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task->TAS_ID,
]);
$timeStart = microtime(true);
$result = ListUnassigned::doCount($user[0]->USR_UID);
$this->assertEquals(10, $result);
$timeEnd = microtime(true);
$time = $timeEnd - $timeStart;
error_log('it_should_count_cases_by_user_with_self_service_value_based_usr_uid took [10]--->' . $time);
//Review the count self-service
$result = ListUnassigned::countSelfService($user->USR_UID);
$this->assertEquals(25, $result);
}
/**
@@ -114,59 +108,55 @@ class ListUnassignedTest extends TestCase
public function it_should_count_cases_by_user_with_self_service_mixed_with_self_service_value_based()
{
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create a case
$application = factory(Application::class, 1)->create();
$application = factory(Application::class)->create();
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Create a task self service
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create the register in self service
factory(ListUnassigned::class, 15)->create([
'TAS_ID' => $task[0]->TAS_ID
'TAS_ID' => $task->TAS_ID
]);
//Create a task self service value based
$task1 = factory(Task::class, 1)->create([
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class, 1)->create([
'APP_NUMBER' => $application[0]->APP_NUMBER,
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => 2,
'TAS_ID' => $task1[0]->TAS_ID
'TAS_ID' => $task1->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class, 1)->create([
'ID' => $appSelfValue[0]->ID,
'GRP_UID' => $user[0]->USR_UID,
'ASSIGNEE_ID' => $user[0]->USR_ID, //The usrId or grpId
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in self service value based
factory(ListUnassigned::class, 10)->create([
'APP_NUMBER' => $application[0]->APP_NUMBER,
'DEL_INDEX' => $appSelfValue[0]->DEL_INDEX,
'TAS_ID' => $task[0]->TAS_ID,
factory(ListUnassigned::class, 15)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task->TAS_ID,
]);
$timeStart = microtime(true);
$result = ListUnassigned::doCount($user[0]->USR_UID);
$timeEnd = microtime(true);
$this->assertEquals(25, $result);
$time = $timeEnd - $timeStart;
error_log('it_should_count_cases_by_user_with_self_service_mixed_with_self_service_value_based took [25]--->' . $time);
//Review the count self-service
$result = ListUnassigned::countSelfService($user->USR_UID);
$this->assertEquals(30, $result);
}
/**
@@ -177,40 +167,37 @@ class ListUnassignedTest extends TestCase
public function it_should_count_cases_by_user_with_self_service_group_assigned()
{
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create group
$group = factory(Groupwf::class, 1)->create();
$group = factory(Groupwf::class)->create();
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Assign a user in the group
factory(GroupUser::class, 1)->create([
'GRP_UID' => $group[0]->GRP_UID,
'GRP_ID' => $group[0]->GRP_ID,
'USR_UID' => $user[0]->USR_UID
factory(GroupUser::class)->create([
'GRP_UID' => $group->GRP_UID,
'GRP_ID' => $group->GRP_ID,
'USR_UID' => $user->USR_UID
]);
//Create a task self service
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 2, //Related to the group
'TU_TYPE' => 1
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 15)->create([
'TAS_ID' => $task[0]->TAS_ID
factory(ListUnassigned::class, 25)->create([
'TAS_ID' => $task->TAS_ID
]);
$timeStart = microtime(true);
$result = ListUnassigned::doCount($user[0]->USR_UID);
$timeEnd = microtime(true);
$this->assertEquals(15, $result);
$time = $timeEnd - $timeStart;
error_log('it_should_count_cases_by_user_with_self_service_group_assigned took [15]--->' . $time);
//Review the count self-service
$result = ListUnassigned::countSelfService($user->USR_UID);
$this->assertEquals(25, $result);
}
/**
@@ -222,54 +209,51 @@ class ListUnassignedTest extends TestCase
public function it_should_count_cases_by_user_with_self_service_value_based_grp_uid()
{
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create a task self service value based
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Create a case
$application = factory(Application::class, 1)->create();
$application = factory(Application::class)->create();
//Create group
$group = factory(Groupwf::class, 1)->create();
$group = factory(Groupwf::class)->create();
//Create user
$user = factory(User::class, 1)->create([
$user = factory(User::class)->create([
'USR_USERNAME' => 'gary',
'USR_LASTNAME' => 'Gary',
'USR_FIRSTNAME' => 'Bailey',
]);
//Assign a user in the group
factory(GroupUser::class, 1)->create([
'GRP_UID' => $group[0]->GRP_UID,
'GRP_ID' => $group[0]->GRP_ID,
'USR_UID' => $user[0]->USR_UID,
factory(GroupUser::class)->create([
'GRP_UID' => $group->GRP_UID,
'GRP_ID' => $group->GRP_ID,
'USR_UID' => $user->USR_UID,
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class, 1)->create([
'APP_NUMBER' => $application[0]->APP_NUMBER,
'APP_UID' => $application[0]->APP_UID,
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'APP_UID' => $application->APP_UID,
'DEL_INDEX' => 2,
'TAS_ID' => $task[0]->TAS_ID
'TAS_ID' => $task->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class, 1)->create([
'ID' => $appSelfValue[0]->ID,
'GRP_UID' => $group[0]->GRP_UID,
'ASSIGNEE_ID' => $group[0]->GRP_ID, //The usrId or grpId
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $group->GRP_UID,
'ASSIGNEE_ID' => $group->GRP_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 2 //Related to the user=1 related to the group=2
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 10)->create([
'APP_NUMBER' => $application[0]->APP_NUMBER,
factory(ListUnassigned::class, 25)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => 2,
'TAS_ID' => $task[0]->TAS_ID,
'TAS_ID' => $task->TAS_ID,
]);
$timeStart = microtime(true);
$result = ListUnassigned::doCount($user[0]->USR_UID);
$this->assertEquals(10, $result);
$timeEnd = microtime(true);
$time = $timeEnd - $timeStart;
error_log('it_should_count_cases_by_user_with_self_service_value_based_grp_uid took [10]--->' . $time);
//Review the count self-service
$result = ListUnassigned::countSelfService($user->USR_UID);
$this->assertEquals(25, $result);
}
/**
@@ -280,91 +264,88 @@ class ListUnassignedTest extends TestCase
public function it_should_count_cases_by_user_with_self_service_user_and_group_assigned_parallel_task()
{
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create group
$group = factory(Groupwf::class, 1)->create();
$group = factory(Groupwf::class)->create();
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Assign a user in the group
factory(GroupUser::class, 1)->create([
'GRP_UID' => $group[0]->GRP_UID,
'GRP_ID' => $group[0]->GRP_ID,
'USR_UID' => $user[0]->USR_UID
factory(GroupUser::class)->create([
'GRP_UID' => $group->GRP_UID,
'GRP_ID' => $group->GRP_ID,
'USR_UID' => $user->USR_UID
]);
//Create a task self service
$task1 = factory(Task::class, 1)->create([
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task1
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task1[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task1->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create a task self service
$task2 = factory(Task::class, 1)->create([
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task2
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task2[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task2->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create a task self service
$task3 = factory(Task::class, 1)->create([
$task3 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task3[0]->TAS_UID,
'USR_UID' => $group[0]->GRP_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task3->TAS_UID,
'USR_UID' => $group->GRP_UID,
'TU_RELATION' => 2, //Related to the group
'TU_TYPE' => 1
]);
//Create a task self service
$task4 = factory(Task::class, 1)->create([
$task4 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task4[0]->TAS_UID,
'USR_UID' => $group[0]->GRP_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task4->TAS_UID,
'USR_UID' => $group->GRP_UID,
'TU_RELATION' => 2, //Related to the group
'TU_TYPE' => 1
]);
//Create the register in list unassigned related to the task1
factory(ListUnassigned::class, 15)->create([
'TAS_ID' => $task1[0]->TAS_ID
factory(ListUnassigned::class, 10)->create([
'TAS_ID' => $task1->TAS_ID
]);
//Create the register in list unassigned related to the task2
factory(ListUnassigned::class, 15)->create([
'TAS_ID' => $task2[0]->TAS_ID
factory(ListUnassigned::class, 10)->create([
'TAS_ID' => $task2->TAS_ID
]);
//Create the register in list unassigned related to the task3
factory(ListUnassigned::class, 15)->create([
'TAS_ID' => $task3[0]->TAS_ID
factory(ListUnassigned::class, 10)->create([
'TAS_ID' => $task3->TAS_ID
]);
//Create the register in list unassigned related to the task4
factory(ListUnassigned::class, 15)->create([
'TAS_ID' => $task4[0]->TAS_ID
factory(ListUnassigned::class, 10)->create([
'TAS_ID' => $task4->TAS_ID
]);
$timeStart = microtime(true);
$result = ListUnassigned::doCount($user[0]->USR_UID);
$timeEnd = microtime(true);
$this->assertEquals(60, $result);
$time = $timeEnd - $timeStart;
error_log('it_should_count_cases_by_user_with_self_service_user_and_group_assigned_parallel_task took [60]--->' . $time);
//Review the count self-service
$result = ListUnassigned::countSelfService($user->USR_UID);
$this->assertEquals(40, $result);
}
/**
@@ -376,63 +357,60 @@ class ListUnassignedTest extends TestCase
public function it_should_count_cases_by_user_with_self_service_value_based_usr_uid_and_grp_uid()
{
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create a case
$application = factory(Application::class, 1)->create();
$application = factory(Application::class)->create();
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Create a task1 self service value based
$task1 = factory(Task::class, 1)->create([
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class, 1)->create([
'APP_NUMBER' => $application[0]->APP_NUMBER,
'TAS_ID' => $task1[0]->TAS_ID
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task1->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class, 1)->create([
'ID' => $appSelfValue[0]->ID,
'GRP_UID' => $user[0]->USR_UID,
'ASSIGNEE_ID' => $user[0]->USR_ID, //The usrId or grpId
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 10)->create([
'APP_NUMBER' => $application[0]->APP_NUMBER,
'DEL_INDEX' => $appSelfValue[0]->DEL_INDEX,
'TAS_ID' => $task1[0]->TAS_ID,
factory(ListUnassigned::class, 15)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task1->TAS_ID,
]);
//Create a task2 self service value based
$task2 = factory(Task::class, 1)->create([
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '@@ARRAY_OF_USERS',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Create the relation for the value assigned in the TAS_GROUP_VARIABLE
$appSelfValue = factory(AppAssignSelfServiceValue::class, 1)->create([
'APP_NUMBER' => $application[0]->APP_NUMBER,
'TAS_ID' => $task2[0]->TAS_ID
$appSelfValue = factory(AppAssignSelfServiceValue::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task2->TAS_ID
]);
factory(AppAssignSelfServiceValueGroup::class, 1)->create([
'ID' => $appSelfValue[0]->ID,
'GRP_UID' => $user[0]->USR_UID,
'ASSIGNEE_ID' => $user[0]->USR_ID, //The usrId or grpId
factory(AppAssignSelfServiceValueGroup::class)->create([
'ID' => $appSelfValue->ID,
'GRP_UID' => $user->USR_UID,
'ASSIGNEE_ID' => $user->USR_ID, //The usrId or grpId
'ASSIGNEE_TYPE' => 1 //Related to the user=1 related to the group=2
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 10)->create([
'APP_NUMBER' => $application[0]->APP_NUMBER,
'DEL_INDEX' => $appSelfValue[0]->DEL_INDEX,
'TAS_ID' => $task2[0]->TAS_ID,
factory(ListUnassigned::class, 15)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_INDEX' => $appSelfValue->DEL_INDEX,
'TAS_ID' => $task2->TAS_ID,
]);
$timeStart = microtime(true);
$result = ListUnassigned::doCount($user[0]->USR_UID);
$this->assertEquals(20, $result);
$timeEnd = microtime(true);
$time = $timeEnd - $timeStart;
error_log('it_should_count_cases_by_user_with_self_service_value_based_usr_uid_and_grp_uid took [20]--->' . $time);
//Review the count self-service
$result = ListUnassigned::countSelfService($user->USR_UID);
$this->assertEquals(30, $result);
}
/**
@@ -443,38 +421,38 @@ class ListUnassignedTest extends TestCase
public function it_should_return_pages_of_data()
{
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Create a task self service
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 51)->create([
'TAS_ID' => $task[0]->TAS_ID
'TAS_ID' => $task->TAS_ID
]);
//Define the filters
$filters = ['start' => 0, 'limit' => 25];
//Get data first page
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(25, $result);
//Get data second page
$filters = ['start' => 25, 'limit' => 25];
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(25, $result);
//Get data third page
$filters = ['start' => 50, 'limit' => 25];
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(1, $result);
}
@@ -486,44 +464,44 @@ class ListUnassignedTest extends TestCase
public function it_should_sort_by_case_number()
{
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Create a task self service
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create a case
$application = factory(Application::class, 1)->create([
$application = factory(Application::class)->create([
'APP_NUMBER' => 3000
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 1)->create([
'TAS_ID' => $task[0]->TAS_ID,
'APP_NUMBER' => $application[0]->APP_NUMBER
factory(ListUnassigned::class)->create([
'TAS_ID' => $task->TAS_ID,
'APP_NUMBER' => $application->APP_NUMBER
]);
//Create a case
$application = factory(Application::class, 1)->create([
$application = factory(Application::class)->create([
'APP_NUMBER' => 2000
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 1)->create([
'TAS_ID' => $task[0]->TAS_ID,
'APP_NUMBER' => $application[0]->APP_NUMBER
factory(ListUnassigned::class)->create([
'TAS_ID' => $task->TAS_ID,
'APP_NUMBER' => $application->APP_NUMBER
]);
//Define the filters
$filters = ['sort' => 'APP_NUMBER', 'dir' => 'ASC'];
//Get data
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
//Get the minor case number first
$this->assertEquals(2000, $result[0]['APP_NUMBER']);
@@ -532,7 +510,7 @@ class ListUnassignedTest extends TestCase
//Define the filters
$filters = ['sort' => 'APP_NUMBER', 'dir' => 'DESC'];
//Get data
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
//Get the major case number first
$this->assertEquals(3000, $result[0]['APP_NUMBER']);
@@ -548,46 +526,46 @@ class ListUnassignedTest extends TestCase
public function it_should_sort_by_case_title()
{
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Create a task self service
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create a case
$application = factory(Application::class, 1)->create([
$application = factory(Application::class)->create([
'APP_NUMBER' => 3001
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 1)->create([
'TAS_ID' => $task[0]->TAS_ID,
'APP_NUMBER' => $application[0]->APP_NUMBER,
'APP_TITLE' => 'Request nro ' . $application[0]->APP_NUMBER,
factory(ListUnassigned::class)->create([
'TAS_ID' => $task->TAS_ID,
'APP_NUMBER' => $application->APP_NUMBER,
'APP_TITLE' => 'Request nro ' . $application->APP_NUMBER,
]);
//Create a case
$application = factory(Application::class, 1)->create([
$application = factory(Application::class)->create([
'APP_NUMBER' => 2001
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 1)->create([
'TAS_ID' => $task[0]->TAS_ID,
'APP_NUMBER' => $application[0]->APP_NUMBER,
'APP_TITLE' => 'Request nro ' . $application[0]->APP_NUMBER,
factory(ListUnassigned::class)->create([
'TAS_ID' => $task->TAS_ID,
'APP_NUMBER' => $application->APP_NUMBER,
'APP_TITLE' => 'Request nro ' . $application->APP_NUMBER,
]);
//Define the filters
$filters = ['sort' => 'APP_TITLE', 'dir' => 'ASC'];
//Get data
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
//Get the minor case title first
$this->assertEquals('Request nro 2001', $result[0]['APP_TITLE']);
@@ -596,7 +574,7 @@ class ListUnassignedTest extends TestCase
//Define the filters
$filters = ['sort' => 'APP_TITLE', 'dir' => 'DESC'];
//Get data
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
//Get the major case title first
$this->assertEquals('Request nro 3001', $result[0]['APP_TITLE']);
@@ -612,37 +590,37 @@ class ListUnassignedTest extends TestCase
public function it_should_sort_by_process()
{
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create a task self service
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 1)->create([
'TAS_ID' => $task[0]->TAS_ID,
factory(ListUnassigned::class)->create([
'TAS_ID' => $task->TAS_ID,
'APP_PRO_TITLE' => 'Egypt Supplier Payment Proposal',
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 1)->create([
'TAS_ID' => $task[0]->TAS_ID,
factory(ListUnassigned::class)->create([
'TAS_ID' => $task->TAS_ID,
'APP_PRO_TITLE' => 'Russia Supplier Payment Proposal',
]);
//Define the filters
$filters = ['sort' => 'APP_PRO_TITLE', 'dir' => 'ASC'];
//Get data
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
//Get the minor process name first
$this->assertEquals('Egypt Supplier Payment Proposal', $result[0]['APP_PRO_TITLE']);
@@ -651,7 +629,7 @@ class ListUnassignedTest extends TestCase
//Define the filters
$filters = ['sort' => 'APP_PRO_TITLE', 'dir' => 'DESC'];
//Get data
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
//Get the major process name first
$this->assertEquals('Russia Supplier Payment Proposal', $result[0]['APP_PRO_TITLE']);
@@ -667,36 +645,36 @@ class ListUnassignedTest extends TestCase
public function it_should_sort_by_task()
{
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create a task self service
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 1)->create([
'TAS_ID' => $task[0]->TAS_ID,
factory(ListUnassigned::class)->create([
'TAS_ID' => $task->TAS_ID,
'APP_TAS_TITLE' => 'Initiate Request',
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 1)->create([
'TAS_ID' => $task[0]->TAS_ID,
factory(ListUnassigned::class)->create([
'TAS_ID' => $task->TAS_ID,
'APP_TAS_TITLE' => 'Waiting for AP Manager Validation',
]);
//Define the filters
$filters = ['sort' => 'APP_TAS_TITLE', 'dir' => 'ASC'];
//Get data
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
//Get the minor task name first
$this->assertEquals('Initiate Request', $result[0]['APP_TAS_TITLE']);
@@ -705,7 +683,7 @@ class ListUnassignedTest extends TestCase
//Define the filters
$filters = ['sort' => 'APP_TAS_TITLE', 'dir' => 'DESC'];
//Get data
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
//Get the major task name first
$this->assertEquals('Waiting for AP Manager Validation', $result[0]['APP_TAS_TITLE']);
@@ -721,54 +699,54 @@ class ListUnassignedTest extends TestCase
public function it_should_return_data_filtered_by_process_category()
{
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Create a category
$category = factory(ProcessCategory::class, 1)->create();
$category = factory(ProcessCategory::class)->create();
//Create process
$process = factory(Process::class, 1)->create([
'PRO_CATEGORY' => $category[0]->CATEGORY_UID
$process = factory(Process::class)->create([
'PRO_CATEGORY' => $category->CATEGORY_UID
]);
//Create a category
$category1 = factory(ProcessCategory::class, 1)->create();
$category1 = factory(ProcessCategory::class)->create();
//Create process
$process1 = factory(Process::class, 1)->create([
'PRO_CATEGORY' => $category1[0]->CATEGORY_UID
$process1 = factory(Process::class)->create([
'PRO_CATEGORY' => $category1->CATEGORY_UID
]);
//Create a task self service
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 2)->create([
'TAS_ID' => $task[0]->TAS_ID,
'PRO_UID' => $process[0]->PRO_UID,
'TAS_ID' => $task->TAS_ID,
'PRO_UID' => $process->PRO_UID,
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 5)->create([
'TAS_ID' => $task[0]->TAS_ID,
'PRO_UID' => $process1[0]->PRO_UID,
'TAS_ID' => $task->TAS_ID,
'PRO_UID' => $process1->PRO_UID,
]);
//Get all data
$result = ListUnassigned::loadList($user[0]->USR_UID);
$result = ListUnassigned::loadList($user->USR_UID);
$this->assertCount(7, $result);
//Define the filters
$filters = ['category' => $category[0]->CATEGORY_UID];
$filters = ['category' => $category->CATEGORY_UID];
//Get data
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
//Get the minor case number first
$this->assertEquals($category[0]->CATEGORY_UID, $result[0]['PRO_CATEGORY']);
$this->assertEquals($category->CATEGORY_UID, $result[0]['PRO_CATEGORY']);
//Get the major case number second
$this->assertEquals($category[0]->CATEGORY_UID, $result[1]['PRO_CATEGORY']);
$this->assertEquals($category->CATEGORY_UID, $result[1]['PRO_CATEGORY']);
}
/**
@@ -779,55 +757,55 @@ class ListUnassignedTest extends TestCase
public function it_should_return_data_filtered_by_generic_search()
{
//Create user
$user = factory(User::class, 1)->create();
$user = factory(User::class)->create();
//Create process
$process = factory(Process::class, 1)->create();
$process = factory(Process::class)->create();
//Create a task self service
$task = factory(Task::class, 1)->create([
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process[0]->PRO_UID
'PRO_UID' => $process->PRO_UID
]);
//Assign a user in the task
factory(TaskUser::class, 1)->create([
'TAS_UID' => $task[0]->TAS_UID,
'USR_UID' => $user[0]->USR_UID,
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1, //Related to the user
'TU_TYPE' => 1
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 2)->create([
'TAS_ID' => $task[0]->TAS_ID,
'TAS_ID' => $task->TAS_ID,
'APP_TITLE' => 'This is a case name',
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 2)->create([
'TAS_ID' => $task[0]->TAS_ID,
'TAS_ID' => $task->TAS_ID,
'APP_PRO_TITLE' => 'This is a process name',
]);
//Create the register in list unassigned
factory(ListUnassigned::class, 2)->create([
'TAS_ID' => $task[0]->TAS_ID,
'TAS_ID' => $task->TAS_ID,
'APP_TAS_TITLE' => 'This is a task name',
]);
//Create other registers
factory(ListUnassigned::class, 4)->create([
'TAS_ID' => $task[0]->TAS_ID
'TAS_ID' => $task->TAS_ID
]);
//Define the filters
$filters = ['search' => 'case name'];
//Get data related to the search
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
//Define the filters
$filters = ['search' => 'process name'];
//Get data related to the search
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
//Define the filters
$filters = ['search' => 'task name'];
//Get data related to the search
$result = ListUnassigned::loadList($user[0]->USR_UID, $filters);
$result = ListUnassigned::loadList($user->USR_UID, $filters);
$this->assertCount(2, $result);
}
}

18
workflow/engine/src/ProcessMaker/BusinessModel/Lists.php
View File

@@ -2,13 +2,13 @@
namespace ProcessMaker\BusinessModel;
use \G;
use \Criteria;
use \UsersPeer;
use \PMLicensedFeatures;
use G;
use Criteria;
use PMLicensedFeatures;
use ProcessMaker\Model\Delegation;
use UsersPeer;
/**
* @author Brayan Pereyra (Cochalo) <brayan@colosa.com>
* @copyright Colosa - Bolivia
*/
class Lists
@@ -258,6 +258,7 @@ class Lists
/**
* Get counters for lists
*
* @param $userId
* @return array
*/
@@ -271,6 +272,13 @@ class Lists
$total = $this->$listObject->getCountList($userId, array('action' => 'draft'));
array_push($response, (array('count' => $total, 'item' => $item)));
break;
case 'ListSelfService':
$total = Delegation::countSelfService($userId);
array_push($response, ([
'count' => $total,
'item' => $item
]));
break;
/*----------------------------------********---------------------------------*/
case 'ListConsolidated':
$licensedFeatures = PMLicensedFeatures::getSingleton();

58
workflow/engine/src/ProcessMaker/Model/AppAssignSelfServiceValue.php
View File

@@ -10,5 +10,63 @@ class AppAssignSelfServiceValue extends Model
protected $primaryKey = 'ID';
// We do not have create/update timestamps for this table
public $timestamps = false;
/**
* Return the case number this belongs to
*/
public function appNumber()
{
return $this->belongsTo(Delegation::class, 'APP_NUMBER', 'APP_NUMBER');
}
/**
* Return the index this belongs to
*/
public function index()
{
return $this->belongsTo(Delegation::class, 'DEL_INDEX', 'DEL_INDEX');
}
/**
* Return the task this belongs to
*/
public function task()
{
return $this->belongsTo(Task::class, 'TAS_ID', 'TAS_ID');
}
/**
* Get cases with assignment Self-Service Value Based
*
* @param string $usrUid
*
* @return array
*/
public static function getSelfServiceCasesByEvaluatePerUser($usrUid)
{
//Get the groups related to the user
$groups = GroupUser::getGroups($usrUid);
// Build query
$query = AppAssignSelfServiceValue::query()->select();
$query->join('APP_ASSIGN_SELF_SERVICE_VALUE_GROUP', function ($join) {
$join->on('APP_ASSIGN_SELF_SERVICE_VALUE.ID', '=', 'APP_ASSIGN_SELF_SERVICE_VALUE_GROUP.ID');
});
$query->where(function ($query) use ($usrUid, $groups) {
//Filtering the user assigned in the task
$query->where('APP_ASSIGN_SELF_SERVICE_VALUE_GROUP.GRP_UID', '=', $usrUid);
if (!empty($groups)) {
//Consider the group related to the user
$query->orWhere(function ($query) use ($groups) {
$query->whereIn('APP_ASSIGN_SELF_SERVICE_VALUE_GROUP.ASSIGNEE_ID', $groups);
$query->where('APP_ASSIGN_SELF_SERVICE_VALUE_GROUP.ASSIGNEE_TYPE', '=', 2);
});
}
});
$query->distinct();
$result = $query->get()->values()->toArray();
return $result;
}
}

8
workflow/engine/src/ProcessMaker/Model/AppAssignSelfServiceValueGroup.php
View File

@@ -9,5 +9,13 @@ class AppAssignSelfServiceValueGroup extends Model
protected $table = 'APP_ASSIGN_SELF_SERVICE_VALUE_GROUP';
// We do not have create/update timestamps for this table
public $timestamps = false;
/**
* Return the appSelfServiceValue this belongs to
*/
public function appSelfService()
{
return $this->belongsTo(AppAssignSelfServiceValue::class, 'ID', 'ID');
}
}

116
workflow/engine/src/ProcessMaker/Model/Delegation.php
View File

@@ -58,6 +58,79 @@ class Delegation extends Model
return $query->where('APP_UID', '=', $appUid);
}
/**
* Scope a query to only include open threads
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeIsThreadOpen($query)
{
return $query->where('DEL_THREAD_STATUS', '=', 'OPEN');
}
/**
* Scope a query to only include threads without user
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeNoUserInThread($query)
{
return $query->where('USR_ID', '=', 0);
}
/**
* Scope a query to only include specific tasks
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param array $tasks
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeTasksIn($query, array $tasks)
{
return $query->whereIn('APP_DELEGATION.TAS_ID', $tasks);
}
/**
* Scope a query to only include a specific case
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param integer $appNumber
*
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeCase($query, $appNumber)
{
return $query->where('APP_NUMBER', '=', $appNumber);
}
/**
* Scope a query to only include a specific index
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param integer $index
*
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeIndex($query, $index)
{
return $query->where('DEL_INDEX', '=', $index);
}
/**
* Scope a query to only include a specific task
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param integer $task
*
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeTask($query, $task)
{
return $query->where('APP_DELEGATION.TAS_ID', '=', $task);
}
/**
* Searches for delegations which match certain criteria
*
@@ -389,4 +462,47 @@ class Delegation extends Model
return $arrayData;
}
/**
* Count the self-services cases by user
*
* @param string $usrUid
*
* @return integer
*/
public static function countSelfService($usrUid)
{
//Get the task self services related to the user
$taskSelfService = TaskUser::getSelfServicePerUser($usrUid);
//Get the task self services value based related to the user
$selfServiceValueBased = AppAssignSelfServiceValue::getSelfServiceCasesByEvaluatePerUser($usrUid);
//Start the query for get the cases related to the user
$query = Delegation::query()->select('APP_NUMBER');
//Add Join with task filtering only the type self-service
$query->join('TASK', function ($join) {
$join->on('APP_DELEGATION.TAS_ID', '=', 'TASK.TAS_ID')
->where('TASK.TAS_ASSIGN_TYPE', '=', 'SELF_SERVICE');
});
//Filtering the open threads and without users
$query->isThreadOpen()->noUserInThread();
//Get the cases unassigned
if (!empty($selfServiceValueBased)) {
$query->where(function ($query) use ($selfServiceValueBased, $taskSelfService) {
//Get the cases related to the task self service
$query->tasksIn($taskSelfService);
foreach ($selfServiceValueBased as $case) {
//Get the cases related to the task self service value based
$query->orWhere(function ($query) use ($case) {
$query->case($case['APP_NUMBER'])->index($case['DEL_INDEX'])->task($case['TAS_ID']);
});
}
});
} else {
//Get the cases related to the task self service
$query->tasksIn($taskSelfService);
}
return $query->count();
}
}

48
workflow/engine/src/ProcessMaker/Model/GroupUser.php
View File

@@ -9,5 +9,53 @@ class GroupUser extends Model
protected $table = 'GROUP_USER';
// We do not have create/update timestamps for this table
public $timestamps = false;
/**
* Return the user this belongs to
*/
public function user()
{
return $this->belongsTo(User::class, 'USR_UID', 'USR_UID');
}
/**
* Return the group user this belongs to
*/
public function groupsWf()
{
return $this->belongsTo(Groupwf::class, 'GRP_ID', 'GRP_ID');
}
/**
* Scope a query to specific user
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param string $user
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeUser($query, $user)
{
return $query->where('USR_UID', '=', $user);
}
/**
* Return the groups from a user
*
* @param string $usrUid
* @param string $column
*
* @return array
*/
public static function getGroups($usrUid, $column = 'GRP_ID')
{
$groups = GroupUser::query()->select(['GROUP_USER.' . $column])
->join('GROUPWF', function ($join) use ($usrUid) {
$join->on('GROUPWF.GRP_ID', '=', 'GROUP_USER.GRP_ID')
->where('GROUPWF.GRP_STATUS', 'ACTIVE')
->where('GROUP_USER.USR_UID', $usrUid);
})->get()->values()->toArray();
return $groups;
}
}

19
workflow/engine/src/ProcessMaker/Model/Groupwf.php
View File

@@ -10,5 +10,24 @@ class Groupwf extends Model
protected $primaryKey = 'GRP_ID';
// We do not have create/update timestamps for this table
public $timestamps = false;
/**
* Scope a query to active groups
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeActive($query)
{
return $query->where('GRP_STATUS', '=', 'ACTIVE');
}
/**
* Return the user this belongs to
*/
public function groupUsers()
{
return $this->belongsTo(GroupUser::class, 'GRP_ID', 'GRP_ID');
}
}

88
workflow/engine/src/ProcessMaker/Model/ListUnassigned.php
View File

@@ -35,6 +35,57 @@ class ListUnassigned extends Model
return $this->belongsTo(Process::class, 'PRO_ID', 'PRO_ID');
}
/**
* Scope a query to only include specific tasks
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param array $tasks
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeTasksIn($query, array $tasks)
{
return $query->whereIn('TAS_ID', $tasks);
}
/**
* Scope a query to only include a specific case
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param integer $appNumber
*
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeCase($query, $appNumber)
{
return $query->where('APP_NUMBER', '=', $appNumber);
}
/**
* Scope a query to only include a specific index
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param integer $index
*
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeIndex($query, $index)
{
return $query->where('DEL_INDEX', '=', $index);
}
/**
* Scope a query to only include a specific task
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param integer $task
*
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeTask($query, $task)
{
return $query->where('TAS_ID', '=', $task);
}
/**
* Get count
*
@@ -51,6 +102,43 @@ class ListUnassigned extends Model
return $result;
}
/**
* Count the self-services cases by user
*
* @param string $usrUid
*
* @return integer
*/
public static function countSelfService($usrUid)
{
//Get the task self services related to the user
$taskSelfService = TaskUser::getSelfServicePerUser($usrUid);
//Get the task self services value based related to the user
$selfServiceValueBased = AppAssignSelfServiceValue::getSelfServiceCasesByEvaluatePerUser($usrUid);
//Start the query for get the cases related to the user
$query = ListUnassigned::query()->select('APP_NUMBER');
//Get the cases unassigned
if (!empty($selfServiceValueBased)) {
$query->where(function ($query) use ($selfServiceValueBased, $taskSelfService) {
//Get the cases related to the task self service
$query->tasksIn($taskSelfService);
foreach ($selfServiceValueBased as $case) {
//Get the cases related to the task self service value based
$query->orWhere(function ($query) use ($case) {
$query->case($case['APP_NUMBER'])->index($case['DEL_INDEX'])->task($case['TAS_ID']);
});
}
});
} else {
//Get the cases related to the task self service
$query->tasksIn($taskSelfService);
}
return $query->count();
}
/**
* Search data
*

12
workflow/engine/src/ProcessMaker/Model/Task.php
View File

@@ -20,4 +20,16 @@ class Task extends Model
{
return $this->hasMany(Delegation::class, 'TAS_ID', 'TAS_ID');
}
/**
* Scope a query to only include self-service
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeIsSelfService($query)
{
return $query->where('TAS_ASSIGN_TYPE', '=', 'SELF_SERVICE')
->where('TAS_GROUP_VARIABLE', '=', '');
}
}

60
workflow/engine/src/ProcessMaker/Model/TaskUser.php
View File

@@ -9,4 +9,64 @@ class TaskUser extends Model
protected $table = 'TASK_USER';
public $timestamps = false;
/**
* Return the task this belongs to
*/
public function task()
{
return $this->belongsTo(Task::class, 'TAS_UID', 'TAS_UID');
}
/**
* Return the user this belongs to
*/
public function user()
{
return $this->belongsTo(User::class, 'USR_UID', 'USR_UID');
}
/**
* Get the task self services related to the user
*
* @param string $usrUid
*
* @return array
*/
public static function getSelfServicePerUser($usrUid)
{
//Get the groups related to the user
$groups = GroupUser::getGroups($usrUid, 'GRP_UID');
// Build query
$query = Task::query()->select('TAS_ID');
//Add Join with process filtering only the active process
$query->join('PROCESS', function ($join) {
$join->on('PROCESS.PRO_UID', '=', 'TASK.PRO_UID')
->where('PROCESS.PRO_STATUS', 'ACTIVE');
});
//Add join with with the task users
$query->join('TASK_USER', function ($join) {
$join->on('TASK.TAS_UID', '=', 'TASK_USER.TAS_UID')
//We not considered the Ad-hoc
->where('TASK_USER.TU_TYPE', '=', 1);
});
//Filtering only the task self-service
$query->isSelfService();
//Filtering the task related to the user
$query->where(function ($query) use ($usrUid, $groups) {
//Filtering the user assigned in the task
$query->where('TASK_USER.USR_UID', '=', $usrUid);
if (!empty($groups)) {
//Consider the group related to the user
$query->orWhere(function ($query) use ($groups) {
$query->whereIn('TASK_USER.USR_UID', $groups);
});
}
});
$query->distinct();
$tasks = $query->get()->values()->toArray();
return $tasks;
}
}

21
workflow/engine/src/ProcessMaker/Model/User.php
View File

@@ -7,6 +7,7 @@ use Illuminate\Database\Eloquent\Model;
class User extends Model
{
protected $table = "USERS";
protected $primaryKey = 'USR_ID';
// Our custom timestamp columns
const CREATED_AT = 'USR_CREATE_DATE';
const UPDATED_AT = 'USR_UPDATE_DATE';
@@ -18,4 +19,24 @@ class User extends Model
{
return $this->hasMany(Delegation::class, 'USR_ID', 'USR_ID');
}
/**
* Return the user this belongs to
*/
public function groups()
{
return $this->belongsTo(GroupUser::class, 'USR_UID', 'USR_UID');
}
/**
* Return the groups from a user
*
* @param boolean $usrUid
*
* @return array
*/
public static function getGroups($usrUid)
{
return User::find($usrUid)->groups()->get();
}
}