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

Merged in feature/PMCORE-3130 (pull request #7978)

Browse Source 
PMCORE-3130

Approved-by: Julio Cesar Laura Avendaño
This commit is contained in:
Andrea Adamczyk
2021-07-15 13:00:26 +00:00
committed by Julio Cesar Laura Avendaño
parent f578eaf98f a17597e5d4
commit 4be69e3ffa
9 changed files with 1057 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
database/factories/ProcessFactory.php
View File

@@ -1,7 +1,9 @@
<?php
/**
* Model factory for a process
*/
use Faker\Generator as Faker;
$factory->define(\ProcessMaker\Model\Process::class, function (Faker $faker) {
@@ -27,6 +29,7 @@ $factory->define(\ProcessMaker\Model\Process::class, function(Faker $faker) {
'PRO_CATEGORY' => function () {
return factory(\ProcessMaker\Model\ProcessCategory::class)->create()->CATEGORY_UID;
},
'CATEGORY_ID' => 0
];
});

336
tests/unit/workflow/engine/src/ProcessMaker/BusinessModel/Cases/DraftTest.php
View File

@@ -7,6 +7,7 @@ use Illuminate\Support\Facades\DB;
use ProcessMaker\BusinessModel\Cases\Draft;
use ProcessMaker\Model\Application;
use ProcessMaker\Model\Delegation;
use ProcessMaker\Model\Process;
use ProcessMaker\Model\User;
use Tests\TestCase;
@@ -305,4 +306,339 @@ class DraftTest extends TestCase
$this->assertEquals(1, $res);
}
/**
* It tests the getCountersByProcesses() method without filters
*
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_no_filter()
{
$process = factory(Process::class)->create();
$process2 = factory(Process::class)->create();
$user = factory(User::class)->create();
$application1 = factory(Application::class)->states('draft')->create([
'APP_INIT_USER' => $user->USR_UID,
'APP_CUR_USER' => $user->USR_UID,
]);
$application2 = factory(Application::class)->states('draft')->create([
'APP_INIT_USER' => $user->USR_UID,
'APP_CUR_USER' => $user->USR_UID,
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application1->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application1->APP_UID,
'APP_NUMBER' => $application1->APP_NUMBER,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application2->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application2->APP_UID,
'APP_NUMBER' => $application2->APP_NUMBER,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setUserUid($user->USR_ID);
$res = $draft->getCountersByProcesses();
$this->assertCount(2, $res);
}
/**
* It tests the getCountersByProcesses() method with the category filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_category()
{
$process = factory(Process::class)->create([
'CATEGORY_ID' => 1
]);
$process2 = factory(Process::class)->create([
'CATEGORY_ID' => 2
]);
$user = factory(User::class)->create();
$application = factory(Application::class, 5)->states('draft')->create([
'APP_INIT_USER' => $user->USR_UID,
'APP_CUR_USER' => $user->USR_UID,
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[0]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[0]->APP_UID,
'APP_NUMBER' => $application[0]->APP_NUMBER,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[1]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[1]->APP_UID,
'APP_NUMBER' => $application[1]->APP_NUMBER,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[2]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[2]->APP_UID,
'APP_NUMBER' => $application[2]->APP_NUMBER,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[3]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[3]->APP_UID,
'APP_NUMBER' => $application[3]->APP_NUMBER,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[4]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[4]->APP_UID,
'APP_NUMBER' => $application[4]->APP_NUMBER,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setUserUid($user->USR_ID);
$res = $draft->getCountersByProcesses(2);
$this->assertCount(1, $res);
}
/**
* It tests the getCountersByProcesses() method with the top ten filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_top_ten()
{
$process1 = factory(Process::class)->create();
$process2 = factory(Process::class)->create();
$process3 = factory(Process::class)->create();
$process4 = factory(Process::class)->create();
$process5 = factory(Process::class)->create();
$process6 = factory(Process::class)->create();
$process7 = factory(Process::class)->create();
$process8 = factory(Process::class)->create();
$process9 = factory(Process::class)->create();
$process10 = factory(Process::class)->create();
$process11 = factory(Process::class)->create();
$user = factory(User::class)->create();
$application = factory(Application::class, 14)->states('draft')->create([
'APP_INIT_USER' => $user->USR_UID,
'APP_CUR_USER' => $user->USR_UID,
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[0]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[0]->APP_UID,
'APP_NUMBER' => $application[0]->APP_NUMBER,
'PRO_ID' => $process1->PRO_ID,
'PRO_UID' => $process1->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[1]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[1]->APP_UID,
'APP_NUMBER' => $application[1]->APP_NUMBER,
'PRO_ID' => $process1->PRO_ID,
'PRO_UID' => $process1->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[2]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[2]->APP_UID,
'APP_NUMBER' => $application[2]->APP_NUMBER,
'PRO_ID' => $process1->PRO_ID,
'PRO_UID' => $process1->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[3]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[3]->APP_UID,
'APP_NUMBER' => $application[3]->APP_NUMBER,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[4]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[4]->APP_UID,
'APP_NUMBER' => $application[4]->APP_NUMBER,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[5]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[5]->APP_UID,
'APP_NUMBER' => $application[5]->APP_NUMBER,
'PRO_ID' => $process3->PRO_ID,
'PRO_UID' => $process3->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[6]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[6]->APP_UID,
'APP_NUMBER' => $application[6]->APP_NUMBER,
'PRO_ID' => $process4->PRO_ID,
'PRO_UID' => $process4->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[7]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[7]->APP_UID,
'APP_NUMBER' => $application[7]->APP_NUMBER,
'PRO_ID' => $process5->PRO_ID,
'PRO_UID' => $process5->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[8]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[8]->APP_UID,
'APP_NUMBER' => $application[8]->APP_NUMBER,
'PRO_ID' => $process6->PRO_ID,
'PRO_UID' => $process6->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[9]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[9]->APP_UID,
'APP_NUMBER' => $application[9]->APP_NUMBER,
'PRO_ID' => $process7->PRO_ID,
'PRO_UID' => $process7->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[10]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[10]->APP_UID,
'APP_NUMBER' => $application[10]->APP_NUMBER,
'PRO_ID' => $process8->PRO_ID,
'PRO_UID' => $process8->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[11]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[11]->APP_UID,
'APP_NUMBER' => $application[11]->APP_NUMBER,
'PRO_ID' => $process9->PRO_ID,
'PRO_UID' => $process9->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[12]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[12]->APP_UID,
'APP_NUMBER' => $application[12]->APP_NUMBER,
'PRO_ID' => $process10->PRO_ID,
'PRO_UID' => $process10->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[13]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[13]->APP_UID,
'APP_NUMBER' => $application[13]->APP_NUMBER,
'PRO_ID' => $process11->PRO_ID,
'PRO_UID' => $process11->PRO_UID
]);
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setUserUid($user->USR_ID);
$res = $draft->getCountersByProcesses(null, true);
$this->assertCount(10, $res);
}
/**
* It tests the getCountersByProcesses() method with the processes filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_processes()
{
$process = factory(Process::class)->create();
$process2 = factory(Process::class)->create();
$user = factory(User::class)->create();
$application = factory(Application::class, 14)->states('draft')->create([
'APP_INIT_USER' => $user->USR_UID,
'APP_CUR_USER' => $user->USR_UID,
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[0]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[0]->APP_UID,
'APP_NUMBER' => $application[0]->APP_NUMBER,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'USR_UID' => $application[1]->APP_INIT_USER,
'USR_ID' => $user->USR_ID,
'APP_UID' => $application[1]->APP_UID,
'APP_NUMBER' => $application[1]->APP_NUMBER,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setUserUid($user->USR_ID);
$res = $draft->getCountersByProcesses(null, false, [$process->PRO_ID]);
$this->assertCount(1, $res);
}
}

270
tests/unit/workflow/engine/src/ProcessMaker/BusinessModel/Cases/InboxTest.php
View File

@@ -211,7 +211,6 @@ class InboxTest extends TestCase
$inbox->setTaskId($cases->TAS_ID);
$res = $inbox->getData();
$this->assertNotEmpty($res);
}
/**
@@ -298,4 +297,273 @@ class InboxTest extends TestCase
$res = $inbox->getPagingCounters();
$this->assertEquals(1, $res);
}
/**
* It tests the getCountersByProcesses() method without filters
*
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_no_filter()
{
$user = factory(User::class)->create();
$process = factory(Process::class)->create();
$process2 = factory(Process::class)->create();
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
$inbox = new Inbox();
$inbox->setUserId($user->USR_ID);
$inbox->setUserUid($user->USR_UID);
$res = $inbox->getCountersByProcesses();
$this->assertCount(2, $res);
}
/**
* It tests the getCountersByProcesses() method with the category filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_category()
{
$user = factory(User::class)->create();
$process = factory(Process::class)->create([
'CATEGORY_ID' => 1
]);
$process2 = factory(Process::class)->create([
'CATEGORY_ID' => 2
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
$inbox = new Inbox();
$inbox->setUserId($user->USR_ID);
$inbox->setUserUid($user->USR_UID);
$res = $inbox->getCountersByProcesses(2);
$this->assertCount(1, $res);
}
/**
* It tests the getCountersByProcesses() method with the top ten filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_top_ten()
{
$user = factory(User::class)->create();
$process1 = factory(Process::class)->create();
$process2 = factory(Process::class)->create();
$process3 = factory(Process::class)->create();
$process4 = factory(Process::class)->create();
$process5 = factory(Process::class)->create();
$process6 = factory(Process::class)->create();
$process7 = factory(Process::class)->create();
$process8 = factory(Process::class)->create();
$process9 = factory(Process::class)->create();
$process10 = factory(Process::class)->create();
$process11 = factory(Process::class)->create();
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process1->PRO_ID,
'PRO_UID' => $process1->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process1->PRO_ID,
'PRO_UID' => $process1->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process1->PRO_ID,
'PRO_UID' => $process1->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process3->PRO_ID,
'PRO_UID' => $process3->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process4->PRO_ID,
'PRO_UID' => $process4->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process5->PRO_ID,
'PRO_UID' => $process5->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process6->PRO_ID,
'PRO_UID' => $process6->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process7->PRO_ID,
'PRO_UID' => $process7->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process8->PRO_ID,
'PRO_UID' => $process8->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process9->PRO_ID,
'PRO_UID' => $process9->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process10->PRO_ID,
'PRO_UID' => $process10->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process11->PRO_ID,
'PRO_UID' => $process11->PRO_UID
]);
$inbox = new Inbox();
$inbox->setUserId($user->USR_ID);
$inbox->setUserUid($user->USR_UID);
$res = $inbox->getCountersByProcesses(null, true);
$this->assertCount(10, $res);
}
/**
* It tests the getCountersByProcesses() method with the processes filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_processes()
{
$user = factory(User::class)->create();
$process = factory(Process::class)->create();
$process2 = factory(Process::class)->create();
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID
]);
factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID
]);
$inbox = new Inbox();
$inbox->setUserId($user->USR_ID);
$inbox->setUserUid($user->USR_UID);
$res = $inbox->getCountersByProcesses(null, false, [$process->PRO_ID]);
$this->assertCount(1, $res);
}
}

120
tests/unit/workflow/engine/src/ProcessMaker/BusinessModel/Cases/PausedTest.php
View File

@@ -136,13 +136,15 @@ class PausedTest extends TestCase
* @param int
* @return object
*/
public function createMultiplePaused($cases)
public function createMultiplePaused($cases, $category = 1, $user = null)
{
$user = factory(\ProcessMaker\Model\User::class)->create();
if (is_null($user)) {
$user = factory(User::class)->create();
}
for ($i = 0; $i < $cases; $i = $i + 1) {
$process1 = factory(Process::class)->create(
['PRO_CATEGORY' => '1']
['PRO_CATEGORY' => 1, 'CATEGORY_ID' => $category]
);
$task = factory(Task::class)->create([
@@ -386,4 +388,116 @@ class PausedTest extends TestCase
$res = $paused->getPagingCounters();
$this->assertEquals(1, $res);
}
/**
* It tests the getCountersByProcesses() method without filters
*
* @covers \ProcessMaker\BusinessModel\Cases\Paused::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_no_filter()
{
$cases = $this->createMultiplePaused(2);
$paused = new Paused();
$paused->setUserId($cases->USR_ID);
$paused->setUserUid($cases->USR_ID);
$res = $paused->getCountersByProcesses();
$this->assertCount(2, $res);
}
/**
* It tests the getCountersByProcesses() method with the category filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Paused::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_category()
{
$user = factory(User::class)->create();
$this->createMultiplePaused(3, 2, $user);
$this->createMultiplePaused(2, 3, $user);
$paused = new Paused();
$paused->setUserId($user->USR_ID);
$paused->setUserUid($user->USR_ID);
$res = $paused->getCountersByProcesses(2);
$this->assertCount(3, $res);
}
/**
* It tests the getCountersByProcesses() method with the top ten filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Paused::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_top_ten()
{
$user = factory(User::class)->create();
$this->createMultiplePaused(20, 2, $user);
$paused = new Paused();
$paused->setUserId($user->USR_ID);
$paused->setUserUid($user->USR_UID);
$res = $paused->getCountersByProcesses(null, true);
$this->assertCount(10, $res);
}
/**
* It tests the getCountersByProcesses() method with the processes filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Paused::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_processes_filter()
{
$user = factory(User::class)->create();
$process1 = factory(Process::class)->create();
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process1->PRO_UID,
'TAS_TYPE' => 'NORMAL'
]);
$application1 = factory(Application::class)->create();
factory(Delegation::class)->create([
'APP_UID' => $application1->APP_UID,
'APP_NUMBER' => $application1->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'CLOSED',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process1->PRO_ID,
'PRO_UID' => $process1->PRO_UID,
'DEL_PREVIOUS' => 0,
'DEL_INDEX' => 1
]);
$delegation1 = factory(Delegation::class)->create([
'APP_UID' => $application1->APP_UID,
'APP_NUMBER' => $application1->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process1->PRO_ID,
'PRO_UID' => $process1->PRO_UID,
'DEL_PREVIOUS' => 1,
'DEL_INDEX' => 2
]);
factory(AppDelay::class)->create([
'APP_DELEGATION_USER' => $user->USR_UID,
'PRO_UID' => $process1->PRO_UID,
'APP_NUMBER' => $delegation1->APP_NUMBER,
'APP_DEL_INDEX' => $delegation1->DEL_INDEX,
'APP_DISABLE_ACTION_USER' => 0,
'APP_TYPE' => 'PAUSE'
]);
$this->createMultiplePaused(3, 2, $user);
$paused = new Paused();
$paused->setUserId($user->USR_ID);
$paused->setUserUid($user->USR_UID);
$res = $paused->getCountersByProcesses(null, false, [$process1->PRO_ID]);
$this->assertCount(1, $res);
}
}

163
tests/unit/workflow/engine/src/ProcessMaker/BusinessModel/Cases/UnassignedTest.php
View File

@@ -88,7 +88,6 @@ class UnassignedTest extends TestCase
'taskUser' => $taskUser,
'delegation' => $delegation
];
}
/**
@@ -418,4 +417,166 @@ class UnassignedTest extends TestCase
$res = $unassigned->getPagingCounters();
$this->assertNotEmpty($res);
}
/**
* It tests the getCountersByProcesses() method without filters
*
* @covers \ProcessMaker\BusinessModel\Cases\Unassigned::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_no_filter()
{
$cases = $this->createMultipleUnassigned(3);
$unassigned = new Unassigned();
$unassigned->setUserId($cases->USR_ID);
$unassigned->setUserUid($cases->USR_UID);
$res = $unassigned->getCountersByProcesses();
$this->assertCount(3, $res);
}
/**
* It tests the getCountersByProcesses() method with the category filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Unassigned::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_category()
{
$user = factory(User::class)->create();
$process1 = factory(Process::class)->create([
'CATEGORY_ID' => 2
]);
$process2 = factory(Process::class)->create([
'CATEGORY_ID' => 3
]);
$application = factory(Application::class)->create([
'APP_STATUS_ID' => 2
]);
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process1->PRO_UID,
'PRO_ID' => $process1->PRO_ID,
]);
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1,
'TU_TYPE' => 1
]);
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'PRO_ID' => $process1->PRO_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
'DEL_DELEGATE_DATE' => date('Y-m-d H:m:s', strtotime("-1 year"))
]);
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process2->PRO_UID,
'PRO_ID' => $process2->PRO_ID,
]);
factory(TaskUser::class)->create([
'TAS_UID' => $task2->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1,
'TU_TYPE' => 1
]);
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task2->TAS_ID,
'PRO_ID' => $process2->PRO_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
'DEL_DELEGATE_DATE' => date('Y-m-d H:m:s', strtotime("-2 year"))
]);
$unassigned = new Unassigned();
$unassigned->setUserId($user->USR_ID);
$unassigned->setUserUid($user->USR_UID);
$res = $unassigned->getCountersByProcesses(2);
$this->assertCount(1, $res);
}
/**
* It tests the getCountersByProcesses() method with the top ten filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Unassigned::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_top_ten()
{
$cases = $this->createMultipleUnassigned(20);
$unassigned = new Unassigned();
$unassigned->setUserId($cases->USR_ID);
$unassigned->setUserUid($cases->USR_UID);
$res = $unassigned->getCountersByProcesses(null, true);
$this->assertCount(10, $res);
}
/**
* It tests the getCountersByProcesses() method with the processes filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Unassigned::getCountersByProcesses()
* @test
*/
public function it_should_test_get_counters_by_processes_method_processes()
{
$user = factory(User::class)->create();
$process1 = factory(Process::class)->create([
'CATEGORY_ID' => 2
]);
$process2 = factory(Process::class)->create([
'CATEGORY_ID' => 3
]);
$application = factory(Application::class)->create([
'APP_STATUS_ID' => 2
]);
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process1->PRO_UID,
'PRO_ID' => $process1->PRO_ID,
]);
factory(TaskUser::class)->create([
'TAS_UID' => $task->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1,
'TU_TYPE' => 1
]);
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'PRO_ID' => $process1->PRO_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
'DEL_DELEGATE_DATE' => date('Y-m-d H:m:s', strtotime("-1 year"))
]);
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'SELF_SERVICE',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process2->PRO_UID,
'PRO_ID' => $process2->PRO_ID,
]);
factory(TaskUser::class)->create([
'TAS_UID' => $task2->TAS_UID,
'USR_UID' => $user->USR_UID,
'TU_RELATION' => 1,
'TU_TYPE' => 1
]);
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task2->TAS_ID,
'PRO_ID' => $process2->PRO_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_ID' => 0,
'DEL_DELEGATE_DATE' => date('Y-m-d H:m:s', strtotime("-2 year"))
]);
$unassigned = new Unassigned();
$unassigned->setUserId($user->USR_ID);
$unassigned->setUserUid($user->USR_UID);
$res = $unassigned->getCountersByProcesses(null, false, [$process1->PRO_ID]);
$this->assertCount(1, $res);
}
}

43
workflow/engine/src/ProcessMaker/BusinessModel/Cases/AbstractCases.php
View File

@@ -1431,4 +1431,47 @@ class AbstractCases implements CasesInterface
{
throw new Exception("Method '" . __FUNCTION__ . "' should be implemented in the extended class '" . get_class($this) . "'.");
}
/**
* Count how many cases has each process
*
* @param string $list
* @param int $category
* @param bool $topTen
* @param array $processes
*
* @return array
*/
public function getCountersByProcesses($category = null, $topTen = false, $processes = [])
{
$query = Delegation::selectRaw('count(APP_DELEGATION.DELEGATION_ID) as TOTAL, APP_DELEGATION.PRO_ID, PROCESS.PRO_TITLE')
->groupBy('APP_DELEGATION.PRO_UID');
$listArray = explode("\\", get_class($this));
$list = end($listArray);
switch ($list) {
case 'Inbox':
$query->inbox($this->getUserId());
break;
case 'Draft':
$query->draft($this->getUserId());
break;
case 'Paused':
$query->paused($this->getUserId());
break;
case 'Unassigned':
$query->selfService($this->getUserUid());
break;
}
$query->joinProcess();
if (!is_null($category)) {
$query->categoryId($category);
}
if ($topTen) {
$query->topTen('TOTAL', 'DESC');
}
if (!empty($processes)) {
$query->inProcesses($processes);
}
return $query->get()->values()->toArray();
}
}

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

@@ -1015,6 +1015,49 @@ class Delegation extends Model
return $query;
}
/**
* Scope process category id
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param int $category
*
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeCategoryId($query, $category)
{
$query->where('PROCESS.CATEGORY_ID', $category);
return $query;
}
/**
* Scope top ten
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param string $column
* @param string $order
*
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeTopTen($query, $column, $order)
{
$query->orderBy($column, $order)->limit(10);
return $query;
}
/**
* Scope where in processes
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param array $processes
*
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeInProcesses($query, $processes)
{
$query->whereIn('PROCESS.PRO_ID', $processes);
return $query;
}
/**
* Get specific cases unassigned that the user can view
*

69
workflow/engine/src/ProcessMaker/Services/Api/Metrics.php Normal file
View File

@@ -0,0 +1,69 @@
<?php
namespace ProcessMaker\Services\Api;
use Exception;
use ProcessMaker\BusinessModel\Cases\Draft;
use ProcessMaker\BusinessModel\Cases\Inbox;
use ProcessMaker\BusinessModel\Cases\Paused;
use ProcessMaker\BusinessModel\Cases\Unassigned;
use ProcessMaker\Services\Api;
use RBAC;
class Metrics extends Api
{
/**
* Constructor of the class
* Defines the $RBAC definition
*/
public function __construct()
{
global $RBAC;
if (!isset($RBAC)) {
$RBAC = RBAC::getSingleton(PATH_DATA, session_id());
$RBAC->sSystem = 'PROCESSMAKER';
$RBAC->initRBAC();
$RBAC->loadUserRolePermission($RBAC->sSystem, $this->getUserId());
}
}
/**
* Get total cases per process
*
* @url /process-total-cases
*
* @param string $caseList
* @param int $category
* @param bool $topTen
* @param array $processes
*
* @return array
*
* @throws RestException
*
* @class AccessControl {@permission TASK_METRICS_VIEW}
*/
public function getProcessTotalCases($caseList, $category = null, $topTen = false, $processes = [])
{
try {
switch ($caseList) {
case 'inbox':
$list = new Inbox();
break;
case 'draft':
$list = new Draft();
break;
case 'paused':
$list = new Paused();
break;
case 'unassigned':
$list = new Unassigned();
break;
}
$result = $list->getCountersByProcesses($category, $topTen, $processes);
return $result;
} catch (Exception $e) {
throw new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage());
}
}
}