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

Merged in feature/PMCORE-2399 (pull request #7589)

Browse Source 
PMCORE-2399

Approved-by: Julio Cesar Laura Avendaño <contact@julio-laura.com>
This commit is contained in:
Paula Quispe
2020-12-09 15:45:34 +00:00
committed by Julio Cesar Laura Avendaño
parent 7a188c6061 edc5b59009
commit d5c9ecc9e6
17 changed files with 493 additions and 1586 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
config/view.php
View File

@@ -23,5 +23,5 @@ return [
| directory. However, as usual, you are free to change this value. | directory. However, as usual, you are free to change this value.
| |
*/ */
'compiled' => realpath(PATH_TRUNK . 'bootstrap/cache/views') 'compiled' => realpath(dirname(__DIR__) . '/' . 'bootstrap/cache/views')
]; ];

59
database/factories/AppDelayFactory.php
View File

@@ -24,3 +24,62 @@ $factory->define(\ProcessMaker\Model\AppDelay::class, function (Faker $faker) {
'PRO_ID' => $faker->unique()->numberBetween(1000), 'PRO_ID' => $faker->unique()->numberBetween(1000),
]; ];
}); });
// Create a delegation with the foreign keys
$factory->state(\ProcessMaker\Model\AppDelay::class, 'paused_foreign_keys', function (Faker $faker) {
// Create values in the foreign key relations
$user = factory(\ProcessMaker\Model\User::class)->create();
$process = factory(\ProcessMaker\Model\Process::class)->create();
$task = factory(\ProcessMaker\Model\Task::class)->create([
'PRO_UID' => $process->PRO_UID,
'PRO_ID' => $process->PRO_ID
]);
$application = factory(\ProcessMaker\Model\Application::class)->create([
'PRO_UID' => $process->PRO_UID,
'APP_INIT_USER' => $user->USR_UID,
'APP_CUR_USER' => $user->USR_UID
]);
$delegation1 = factory(\ProcessMaker\Model\Delegation::class)->create([
'PRO_UID' => $process->PRO_UID,
'PRO_ID' => $process->PRO_ID,
'TAS_UID' => $task->TAS_UID,
'TAS_ID' => $task->TAS_ID,
'APP_NUMBER' => $application->APP_NUMBER,
'APP_UID' => $application->APP_UID,
'DEL_THREAD_STATUS' => 'CLOSED',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'DEL_PREVIOUS' => 0,
'DEL_INDEX' => 1
]);
$delegation = factory(\ProcessMaker\Model\Delegation::class)->create([
'PRO_UID' => $process->PRO_UID,
'PRO_ID' => $process->PRO_ID,
'TAS_UID' => $task->TAS_UID,
'TAS_ID' => $task->TAS_ID,
'APP_NUMBER' => $application->APP_NUMBER,
'APP_UID' => $application->APP_UID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'DEL_PREVIOUS' => $delegation1->DEL_INDEX,
'DEL_INDEX' => $delegation1->DEL_INDEX++
]);
// Return with default values
return [
'APP_DELAY_UID' => G::generateUniqueID(),
'PRO_UID' => $process->PRO_UID,
'PRO_ID' => $process->PRO_ID,
'APP_UID' => $application->APP_UID,
'APP_NUMBER' => $application->APP_NUMBER,
'APP_DEL_INDEX' => $delegation->DEL_INDEX,
'APP_TYPE' => 'PAUSE',
'APP_STATUS' => $application->APP_STATUS,
'APP_DELEGATION_USER' => $user->USR_UID,
'APP_DELEGATION_USER_ID' => $user->USR_ID,
'APP_ENABLE_ACTION_USER' => G::generateUniqueID(),
'APP_ENABLE_ACTION_DATE' => $faker->dateTime(),
'APP_DISABLE_ACTION_USER' => 0,
];
});

116
tests/unit/workflow/engine/src/ProcessMaker/BusinessModel/Cases/AbstractCasesTest.php
View File

@@ -103,7 +103,7 @@ class AbstractCasesTest extends TestCase
public function it_return_set_get_priority() public function it_return_set_get_priority()
{ {
$absCases = new AbstractCases(); $absCases = new AbstractCases();
$arguments = ['ALL', 'VL', 'L', 'N', 'H', 'VH']; $arguments = ['VL', 'L', 'N', 'H', 'VH'];
$index = array_rand($arguments); $index = array_rand($arguments);
$absCases->setPriority($arguments[$index]); $absCases->setPriority($arguments[$index]);
$actual = $absCases->getPriority(); $actual = $absCases->getPriority();
@@ -120,7 +120,7 @@ class AbstractCasesTest extends TestCase
public function it_return_set_get_priorities() public function it_return_set_get_priorities()
{ {
$absCases = new AbstractCases(); $absCases = new AbstractCases();
$arguments = ['ALL', 'VL', 'L', 'N', 'H', 'VH']; $arguments = ['VL', 'L', 'N', 'H', 'VH'];
$index = array_rand($arguments); $index = array_rand($arguments);
$absCases->setPriorities([$arguments[$index]]); $absCases->setPriorities([$arguments[$index]]);
$actual = $absCases->getPriorities(); $actual = $absCases->getPriorities();
@@ -276,15 +276,11 @@ class AbstractCasesTest extends TestCase
public function it_return_set_get_case_statuses() public function it_return_set_get_case_statuses()
{ {
$absCases = new AbstractCases(); $absCases = new AbstractCases();
$arguments = ['ALL', 'DRAFT', 'TO_DO', 'COMPLETED', 'CANCELED']; $arguments = ['DRAFT', 'TO_DO', 'COMPLETED', 'CANCELED'];
$index = array_rand($arguments); $index = array_rand($arguments);
$absCases->setCaseStatuses([$arguments[$index]]); $absCases->setCaseStatuses([$arguments[$index]]);
$actual = $absCases->getCaseStatuses(); $actual = $absCases->getCaseStatuses();
if ($arguments[$index] === 'ALL') { $this->assertEquals([$index], $actual);
$this->assertEquals([], $actual);
} else {
$this->assertEquals([$index], $actual);
}
} }
/** /**
@@ -407,11 +403,91 @@ class AbstractCasesTest extends TestCase
$actual = $absCases->getLimit(); $actual = $absCases->getLimit();
$this->assertEquals($number, $actual); $this->assertEquals($number, $actual);
} }
/**
* This check the setter by default related to the properties
*
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setProperties()
* @test
*/
public function it_return_set_get_properties_default()
{
$absCases = new AbstractCases();
$properties = [];
$absCases->setProperties($properties);
$actual = $absCases->getProcessId();
$this->assertEquals(0, $actual);
$actual = $absCases->getTaskId();
$this->assertEquals(0, $actual);
$actual = $absCases->getTaskId();
$this->assertEquals(0, $actual);
$actual = $absCases->getUserId();
$this->assertEquals(0, $actual);
$actual = $absCases->getCaseNumber();
$this->assertEquals(0, $actual);
$actual = $absCases->getOrderDirection();
$this->assertEquals('DESC', $actual);
$actual = $absCases->getOrderByColumn();
$this->assertEquals('APP_NUMBER', $actual);
$actual = $absCases->getOffset();
$this->assertEquals(0, $actual);
$actual = $absCases->getLimit();
$this->assertEquals(15, $actual);
// Home - Search
$actual = $absCases->getPriorities();
$this->assertEmpty($actual);
$actual = $absCases->getCaseStatuses();
$this->assertEmpty($actual);
$actual = $absCases->getFilterCases();
$this->assertEmpty($actual);
$actual = $absCases->getDelegateFrom();
$this->assertEmpty($actual);
$actual = $absCases->getDelegateTo();
$this->assertEmpty($actual);
// Home - My cases
$actual = $absCases->getParticipatedStatus();
$this->assertEmpty($actual);
$actual = $absCases->getCaseNumberFrom();
$this->assertEmpty($actual);
$actual = $absCases->getCaseNumberTo();
$this->assertEmpty($actual);
$actual = $absCases->getFinishCaseFrom();
$this->assertEmpty($actual);
$actual = $absCases->getFinishCaseTo();
$this->assertEmpty($actual);
}
/** /**
* This check the setter related all the properties * This check the setter related all the properties
* *
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setProperties() * @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setProperties()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setProcessId()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setTaskId()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setUserId()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setCaseNumber()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setCaseTitle()
*
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setParticipatedStatus()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setCaseStatus()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setStartCaseFrom()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setStartCaseTo()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setFinishCaseFrom()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setFinishCaseTo()
*
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setFilterCases()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setCaseStatuses()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setProperties()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setDelegateFrom()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setDelegateTo()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setDueFrom()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setDueTo()
*
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setCaseUid()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setCasesUids()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setOrderByColumn()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setOrderDirection()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setPaged()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setOffset()
* @covers \ProcessMaker\BusinessModel\Cases\AbstractCases::setLimit()
* @test * @test
*/ */
public function it_return_set_get_properties() public function it_return_set_get_properties()
@@ -431,7 +507,7 @@ class AbstractCasesTest extends TestCase
'delegationDateFrom' => date('Y-m-d'), 'delegationDateFrom' => date('Y-m-d'),
'delegationDateTo' => date('Y-m-d'), 'delegationDateTo' => date('Y-m-d'),
// Home - My cases // Home - My cases
'filter'=> 'ALL', 'filter'=> 'STARTED',
'caseStatus' => 'TO_DO', 'caseStatus' => 'TO_DO',
'startCaseFrom' => date('Y-m-d'), 'startCaseFrom' => date('Y-m-d'),
'startCaseTo' => date('Y-m-d'), 'startCaseTo' => date('Y-m-d'),
@@ -461,9 +537,31 @@ class AbstractCasesTest extends TestCase
// Home - Search // Home - Search
$actual = $absCases->getPriorities(); $actual = $absCases->getPriorities();
$this->assertNotEmpty($actual); $this->assertNotEmpty($actual);
$actual = $absCases->getCaseStatuses();
$this->assertNotEmpty($actual);
$actual = $absCases->getFilterCases();
$this->assertEquals([1,8], $actual);
$actual = $absCases->getCasesNumbers();
$this->assertEquals(['3-5','10-15'], $actual);
$actual = $absCases->getRangeCasesFromTo();
$this->assertNotEmpty($actual);
$actual = $absCases->getDelegateFrom();
$this->assertEquals($properties['delegationDateFrom'], $actual);
$actual = $absCases->getDelegateTo();
$this->assertEquals($properties['delegationDateTo'], $actual);
// Home - My cases // Home - My cases
$actual = $absCases->getParticipatedStatus(); $actual = $absCases->getParticipatedStatus();
$this->assertEmpty($actual); $this->assertEmpty($actual);
$actual = $absCases->getCaseStatus();
$this->assertEquals(2, $actual);
$actual = $absCases->getStartCaseFrom();
$this->assertEquals($properties['startCaseFrom'], $actual);
$actual = $absCases->getStartCaseTo();
$this->assertEquals($properties['startCaseTo'], $actual);
$actual = $absCases->getFinishCaseFrom();
$this->assertEquals($properties['finishCaseFrom'], $actual);
$actual = $absCases->getFinishCaseTo();
$this->assertEquals($properties['finishCaseTo'], $actual);
// Other // Other
$actual = $absCases->getValueToSearch(); $actual = $absCases->getValueToSearch();
$this->assertEquals($properties['search'], $actual); $this->assertEquals($properties['search'], $actual);

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

@@ -6,9 +6,6 @@ use Illuminate\Foundation\Testing\DatabaseTransactions;
use ProcessMaker\BusinessModel\Cases\Draft; use ProcessMaker\BusinessModel\Cases\Draft;
use ProcessMaker\Model\Application; use ProcessMaker\Model\Application;
use ProcessMaker\Model\Delegation; use ProcessMaker\Model\Delegation;
use ProcessMaker\Model\Process;
use ProcessMaker\Model\Task;
use ProcessMaker\Model\User;
use Tests\TestCase; use Tests\TestCase;
/** /**
@@ -27,6 +24,26 @@ class DraftTest extends TestCase
$this->markTestIncomplete(); $this->markTestIncomplete();
} }
/**
* Create draft cases factories
*
* @param string
*
* @return array
*/
public function createDraft()
{
$application = factory(Application::class)->states('draft')->create();
$delegation = factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 1,
'APP_UID' => $application->APP_UID,
'APP_NUMBER' => $application->APP_NUMBER,
]);
return $delegation;
}
/** /**
* This checks the counters is working properly in draft * This checks the counters is working properly in draft
* *
@@ -35,416 +52,105 @@ class DraftTest extends TestCase
*/ */
public function it_should_count_cases() public function it_should_count_cases()
{ {
//Create process // Create factories related to the draft cases
$process = factory(Process::class)->create(); $cases = $this->createDraft();
//Create user // Create new Draft object
$user = factory(User::class)->create();
//Create a task related with the process
$task = factory(Task::class)->create([
'PRO_UID' => $process->PRO_UID
]);
//Create application and app_delegation related with DRAFT status
$casesDraft = 25;
for ($x = 1; $x <= $casesDraft; $x++) {
$application = factory(Application::class)->states('draft')->create();
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
]);
}
//Create application and app_delegation related with OTHER status
$casesTodo = 25;
for ($x = 1; $x <= $casesTodo; $x++) {
$application = factory(Application::class)->states('todo')->create();
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
]);
}
//Review the count draft
$draft = new Draft(); $draft = new Draft();
$draft->setUserId($user->USR_ID); $draft->setUserId($cases->USR_ID);
$result = $draft->getCounter(); $result = $draft->getCounter();
$this->assertEquals($casesDraft, $result); $this->assertTrue($result > 0);
} }
/** /**
* This checks to make sure pagination is working properly in draft * It tests the getData method without filters
* *
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getData() * @covers \ProcessMaker\BusinessModel\Cases\Draft::getData()
* @test * @test
*/ */
public function it_should_return_draft_paged() public function it_should_test_get_data_method_without_filters()
{ {
//Create process // Create factories related to the draft cases
$process = factory(Process::class)->create(); $cases = $this->createDraft();
//Create user // Create new Draft object
$user = factory(User::class)->create(); $inbox = new Inbox();
//Create a task // Set the user ID
$task = factory(Task::class)->create([ $inbox->setUserId($cases->USR_ID);
'PRO_UID' => $process->PRO_UID $inbox->setOrderByColumn('APP_NUMBER');
]); $res = $inbox->getData();
//Create application and app_delegation related with DRAFT status $this->assertNotEmpty($res);
$casesDraft = 51;
for ($x = 1; $x <= $casesDraft; $x++) {
$application = factory(Application::class)->states('draft')->create();
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
]);
}
// Get first page
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setOrderByColumn('APP_NUMBER');
$draft->setOffset(0);
$draft->setLimit(25);
$results = $draft->getData();
$this->assertCount(25, $results);
// Get second page
$draft->setOffset(25);
$draft->setLimit(25);
$results = $draft->getData();
$this->assertCount(25, $results);
// Get third page
$draft->setOffset(50);
$draft->setLimit(25);
$results = $draft->getData();
$this->assertCount(1, $results);
} }
/** /**
* This ensures ordering ascending and descending works by case number APP_NUMBER in draft * It tests the getData method with Process Filter
* *
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getData() * @covers \ProcessMaker\BusinessModel\Cases\Draft::getData()
* @test * @test
*/ */
public function it_should_return_draft_sort_by_case_number() public function it_should_test_get_data_by_process_filter()
{ {
//Create process // Create factories related to the draft cases
$process = factory(Process::class)->create(); $cases = $this->createDraft();
//Create user // Create new Draft object
$user = factory(User::class)->create(); $inbox = new Draft();
//Create a task $inbox->setUserId($cases->USR_ID);
$task = factory(Task::class)->create([ $inbox->setProcessId($cases->PRO_ID);
'PRO_UID' => $process->PRO_UID $inbox->setOrderByColumn('APP_NUMBER');
]); $res = $inbox->getData();
//Create application and app_delegation related with DRAFT status with a minor case number $this->assertNotEmpty($res);
$application = factory(Application::class)->states('draft_minor_case')->create();
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
]);
//Create application and app_delegation related with DRAFT status with a minor case number
$application2 = factory(Application::class)->states('draft_major_case')->create();
factory(Delegation::class)->create([
'APP_NUMBER' => $application2->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
]);
//Get the data ordered by APP_NUMBER
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setOrderByColumn('APP_NUMBER');
// Get first page, the minor case id
$draft->setOrderDirection('ASC');
$results = $draft->getData();
$this->assertGreaterThan($results[0]['APP_NUMBER'], $results[1]['APP_NUMBER']);
// Get first page, the major case id
$draft->setOrderDirection('DESC');
$results = $draft->getData();
$this->assertLessThan($results[0]['APP_NUMBER'], $results[1]['APP_NUMBER']);
} }
/** /**
* This ensures ordering ascending and descending works by case title APP_TITLE in draft * It tests the getData method using OrderBy
* *
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getData() * @covers \ProcessMaker\BusinessModel\Cases\Draft::getData()
* @test * @test
*/ */
public function it_should_return_draft_sort_by_case_title() public function it_should_test_get_data_by_case_number()
{ {
$this->markTestIncomplete( // Create factories related to the draft cases
'This test needs to write when the column DELEGATION.DEL_THREAD was added' $cases = $this->createDraft();
); // Create new Draft object
//Create process $inbox = new Draft();
$process = factory(Process::class)->create(); $inbox->setUserId($cases->USR_ID);
//Create user $inbox->setCaseNumber($cases->APP_NUMBER);
$user = factory(User::class)->create(); $inbox->setOrderByColumn('APP_NUMBER');
//Create a task $res = $inbox->getData();
$task = factory(Task::class)->create([ $this->assertNotEmpty($res);
'PRO_UID' => $process->PRO_UID
]);
//Create application and app_delegation related with DRAFT status with a minor case title
$application = factory(Application::class)->states('draft_minor_case')->create();
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
]);
//Create application and app_delegation related with DRAFT status with a minor case title
$application2 = factory(Application::class)->states('draft_major_case')->create();
factory(Delegation::class)->create([
'APP_NUMBER' => $application2->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
]);
// Get first page
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setOrderByColumn('APPLICATION.APP_TITLE');
// Get first page, the minor case title
$draft->setOrderDirection('ASC');
$results = $draft->getData();
$this->assertGreaterThanOrEqual($results[0]['APP_TITLE'], $results[1]['APP_TITLE']);
// Get first page, the major case title
$draft->setOrderDirection('DESC');
$results = $draft->getData();
$this->assertLessThanOrEqual($results[0]['APP_TITLE'], $results[1]['APP_TITLE']);
} }
/** /**
* This ensures ordering ascending and descending works by case title PRO_TITLE in draft * It tests the getData method using OrderBy
* *
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getData() * @covers \ProcessMaker\BusinessModel\Cases\Draft::getData()
* @test * @test
*/ */
public function it_should_return_draft_sort_by_process() public function it_should_test_get_data_by_task_filter()
{ {
// Create a user // Create factories related to the draft cases
$user = factory(User::class)->create(); $cases = $this->createDraft();
// Create some cases // Create new Draft object
for ($i = 1; $i <= 2; $i++) { $inbox = new Draft();
$process = factory(Process::class)->create(); $inbox->setUserId($cases->USR_ID);
$task = factory(Task::class)->create([ $inbox->setTaskId($cases->TAS_ID);
'PRO_UID' => $process->PRO_UID, $res = $inbox->getData();
'PRO_ID' => $process->PRO_ID, $this->assertNotEmpty($res);
]);
//Create application and app_delegation related with DRAFT status
$application = factory(Application::class)->states('draft')->create();
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'PRO_ID' => $process->PRO_ID,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
]);
}
// Get first page
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setOrderByColumn('PRO_TITLE');
// Get first page, the minor case title
$draft->setOrderDirection('ASC');
$results = $draft->getData();
$this->assertGreaterThan($results[0]['PRO_TITLE'], $results[1]['PRO_TITLE']);
// Get first page, the major case title
$draft->setOrderDirection('DESC');
$results = $draft->getData();
$this->assertLessThan($results[0]['PRO_TITLE'], $results[1]['PRO_TITLE']);
} }
/** /**
* This ensures ordering ascending and descending works by task title TAS_TITLE in draft * It tests the getData method using OrderBy
* *
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getData() * @covers \ProcessMaker\BusinessModel\Cases\Draft::getData()
* @test * @test
*/ */
public function it_should_return_draft_sort_by_task_title() public function it_should_test_get_data_by_case_title()
{ {
//Create process // Create factories related to the to_do cases
$process = factory(Process::class)->create(); $cases = $this->createDraft();
//Create user // Create new Draft object
$user = factory(User::class)->create(); $inbox = new Draft();
//Create a task $inbox->setUserId($cases->USR_ID);
for ($i = 1; $i <= 2; $i++) { $res = $inbox->getData();
$task = factory(Task::class)->create([ $this->assertNotEmpty($res);
'PRO_UID' => $process->PRO_UID,
'TAS_TYPE' => 'NORMAL',
]);
$application = factory(Application::class)->states('draft')->create();
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
]);
}
// Get first page
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setOrderByColumn('TAS_TITLE');
// Get first page, the minor case title
$draft->setOrderDirection('ASC');
$results = $draft->getData();
$this->assertGreaterThan($results[0]['TAS_TITLE'], $results[1]['TAS_TITLE']);
// Get first page, the major case title
$draft->setOrderDirection('DESC');
$results = $draft->getData();
$this->assertLessThan($results[0]['TAS_TITLE'], $results[1]['TAS_TITLE']);
}
/**
* This ensures ordering ascending and descending works by due date DEL_TASK_DUE_DATE in draft
*
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getData()
* @test
*/
public function it_should_return_draft_sort_due_date()
{
$faker = \Faker\Factory::create();
//Create process
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task
$task = factory(Task::class)->create([
'PRO_UID' => $process->PRO_UID,
'TAS_TYPE' => 'NORMAL',
]);
//Create application and app_delegation related with DRAFT status
$application = factory(Application::class)->states('draft')->create();
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
'DEL_TASK_DUE_DATE' => $faker->dateTimeBetween('now', '+1 year')
]);
//Create the register in delegation related to draft
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
'DEL_TASK_DUE_DATE' => $faker->dateTimeBetween('-2 year', '-1 year')
]);
// Get first page
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setOrderByColumn('DEL_TASK_DUE_DATE');
// Get first page, the minor case title
$draft->setOrderDirection('ASC');
$results = $draft->getData();
$this->assertGreaterThan($results[0]['DEL_TASK_DUE_DATE'], $results[1]['DEL_TASK_DUE_DATE']);
// Get first page, the major case title
$draft->setOrderDirection('DESC');
$results = $draft->getData();
$this->assertLessThan($results[0]['DEL_TASK_DUE_DATE'], $results[1]['DEL_TASK_DUE_DATE']);
}
/**
* This ensures searching specific cases and review the page in draft
*
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getData()
* @test
*/
public function it_should_search_draft_search_specific_case_uid()
{
//Create process
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task
$task = factory(Task::class)->create([
'PRO_UID' => $process->PRO_UID,
]);
//Create application and app_delegation related with DRAFT status
$application = factory(Application::class)->states('draft')->create();
factory(Delegation::class)->create([
'APP_UID' => $application->APP_UID,
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID
]);
//Create other cases
factory(Delegation::class, 5)->create([
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID
]);
// Get first page
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setOrderByColumn('APP_NUMBER');
// Get first page, the specific case
$draft->setOrderDirection('ASC');
$draft->setCaseUid($application->APP_UID);
$results = $draft->getData();
$this->assertEquals($application->APP_UID, $results[0]['APP_UID']);
}
/**
* This ensures searching specific cases and review the page in draft
*
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getData()
* @test
*/
public function it_should_search_draft_search_specific_cases_uid_array()
{
//Create process
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task
$task = factory(Task::class)->create([
'PRO_UID' => $process->PRO_UID,
]);
//Create application and app_delegation related with DRAFT status
$application = factory(Application::class)->states('draft')->create();
factory(Delegation::class)->create([
'APP_UID' => $application->APP_UID,
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID
]);
// Get first page
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setOrderByColumn('APP_NUMBER');
// Get first page, the specific case
$draft->setOrderDirection('ASC');
$draft->setCasesUids([$application->APP_UID]);
$results = $draft->getData();
$this->assertEquals($application->APP_UID, $results[0]['APP_UID']);
}
/**
* This ensures searching specific process and review the page in draft
*
* @covers \ProcessMaker\BusinessModel\Cases\Draft::getData()
* @test
*/
public function it_should_search_draft_search_specific_process()
{
//Create user
$user = factory(User::class)->create();
for ($i = 1; $i <= 2; $i++) {
//Create process
$process = factory(Process::class)->create();
$task = factory(Task::class)->create([
'PRO_UID' => $process->PRO_UID,
'PRO_ID' => $process->PRO_ID,
]);
//Create application and app_delegation related with DRAFT status
$application = factory(Application::class)->states('draft')->create();
factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'PRO_ID' => $process->PRO_ID,
'TAS_ID' => $task->TAS_ID,
'USR_ID' => $user->USR_ID,
]);
}
// Get first page
$draft = new Draft();
$draft->setUserId($user->USR_ID);
$draft->setOrderByColumn('APP_NUMBER');
$draft->setProcessId($process->PRO_ID);
// Get first page, the minor case title
$draft->setOrderDirection('ASC');
$results = $draft->getData();
$this->assertEquals($process->PRO_TITLE, $results[0]['PRO_TITLE']);
} }
} }

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

@@ -19,6 +19,23 @@ class InboxTest extends TestCase
{ {
use DatabaseTransactions; use DatabaseTransactions;
/**
* Create inbox cases factories
*
* @param string
*
* @return array
*/
public function createInbox()
{
$delegation = factory(Delegation::class)->states('foreign_keys')->create([
'DEL_THREAD_STATUS' => 'OPEN',
'DEL_INDEX' => 2,
]);
return $delegation;
}
/** /**
* It tests the getData method without filters * It tests the getData method without filters
* *
@@ -27,89 +44,18 @@ class InboxTest extends TestCase
*/ */
public function it_should_test_get_data_method_without_filters() public function it_should_test_get_data_method_without_filters()
{ {
//Create process // Create factories related to the to_do cases
$process = factory(Process::class)->create(); $cases = $this->createInbox();
//Create user // Create new Inbox object
$user = factory(User::class)->create();
//Create a task
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID,
]);
//Create the register in delegation
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID
]);
//Create new Inbox object
$inbox = new Inbox(); $inbox = new Inbox();
//Set the user UID // Set the user ID
$inbox->setUserUid($user->USR_UID); $inbox->setUserId($cases->USR_ID);
//Set the user ID // Set OrderBYColumn value
$inbox->setUserId($user->USR_ID);
//Set OrderBYColumn value
$inbox->setOrderByColumn('APP_NUMBER'); $inbox->setOrderByColumn('APP_NUMBER');
//Call to getData method // Call to getData method
$res = $inbox->getData(); $res = $inbox->getData();
//This assert that the expected numbers of results are returned // This assert that the expected numbers of results are returned
$this->assertEquals(10, count($res)); $this->assertNotEmpty($res);
}
/**
* It tests the getData method with Category Filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData()
* @test
*/
public function it_it_should_test_get_data_method_with_Category_Filter()
{
//Create process
$process = factory(Process::class)->create(
['PRO_CATEGORY' => '248565910552bd7d6006458065223611']
);
//Create user
$user = factory(User::class)->create();
//Create a task
$task = factory(Task::class)->create([
'PRO_UID' => $process->PRO_UID,
'PRO_ID' => $process->PRO_ID
]);
//Create the register in delegation
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID
]);
//Create new Inbox object
$inbox = new Inbox();
//Set the user UID
$inbox->setUserUid($user->USR_UID);
//Set the user ID
$inbox->setUserId($user->USR_ID);
//Set OrderBYColumn value
$inbox->setOrderByColumn('APP_NUMBER');
//Set Category value
$inbox->setCategoryUid('248565910552bd7d6006458065223611');
//Call to getData method
$res = $inbox->getData();
//
$this->assertEquals(10, count($res));
} }
/** /**
@@ -118,39 +64,17 @@ class InboxTest extends TestCase
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData() * @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData()
* @test * @test
*/ */
public function it_it_should_test_get_data_method_with_Process_Filter() public function it_should_test_get_data_by_process_filter()
{ {
//Create process // Create factories related to the to_do cases
$process = factory(Process::class, 2)->create(); $cases = $this->createInbox();
// Create new Inbox object
//Create user
$user = factory(User::class)->create();
//Create a task
$task = factory(Task::class)->create([
'PRO_UID' => $process[0]->PRO_UID,
'PRO_ID' => $process[0]->PRO_ID
]);
//Create the register in delegation relate to self-service
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process[0]->PRO_ID
]);
$inbox = new Inbox(); $inbox = new Inbox();
$inbox->setUserUid($user->USR_UID); $inbox->setUserId($cases->USR_ID);
$inbox->setUserId($user->USR_ID); $inbox->setProcessId($cases->PRO_ID);
$inbox->setOrderByColumn('APP_NUMBER'); $inbox->setOrderByColumn('APP_NUMBER');
$inbox->setProcessId($process[1]->PRO_ID);
$res = $inbox->getData(); $res = $inbox->getData();
$this->assertEmpty($res); $this->assertNotEmpty($res);
$inbox->setProcessId($process[0]->PRO_ID);
$res = $inbox->getData();
$this->assertEquals(10, count($res));
} }
/** /**
@@ -159,43 +83,17 @@ class InboxTest extends TestCase
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData() * @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData()
* @test * @test
*/ */
public function it_should_return_inbox_sort_by_case_number() public function it_should_test_get_data_by_case_number()
{ {
//Create process // Create factories related to the to_do cases
$process = factory(Process::class)->create(); $cases = $this->createInbox();
// Create new Inbox object
//Create user
$user = factory(User::class)->create();
//Create tasks
$task = factory(Task::class)->create([
'PRO_UID' => $process->PRO_UID,
'PRO_ID' => $process->PRO_ID
]);
//Create the register in delegation
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID
]);
$inbox = new Inbox(); $inbox = new Inbox();
$inbox->setUserUid($user->USR_UID); $inbox->setUserId($cases->USR_ID);
$inbox->setUserId($user->USR_ID); $inbox->setCaseNumber($cases->APP_NUMBER);
$inbox->setOrderByColumn('APP_NUMBER'); $inbox->setOrderByColumn('APP_NUMBER');
$inbox->setOrderDirection('DESC');
$res = $inbox->getData(); $res = $inbox->getData();
// This asserts the order is for APP_NUMBER from highest to lowest $this->assertNotEmpty($res);
$this->assertLessThan($res[0]['APP_NUMBER'], $res[1]['APP_NUMBER']);
$inbox->setOrderByColumn('APP_NUMBER');
$inbox->setOrderDirection('ASC');
$res = $inbox->getData();
// This asserts the order is for APP_NUMBER from highest to lowest
$this->assertGreaterThan($res[0]['APP_NUMBER'], $res[1]['APP_NUMBER']);
} }
/** /**
@@ -204,40 +102,17 @@ class InboxTest extends TestCase
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData() * @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData()
* @test * @test
*/ */
public function it_should_return_inbox_sort_by_task_title() public function it_should_test_get_data_by_task_filter()
{ {
//Create process // Create factories related to the to_do cases
$process = factory(Process::class)->create(); $cases = $this->createInbox();
//Create user // Create new Inbox object
$user = factory(User::class)->create();
for ($i = 1; $i <= 2; $i++) {
//Create tasks
$task = factory(Task::class)->create([
'PRO_UID' => $process->PRO_UID,
'PRO_ID' => $process->PRO_ID
]);
//Create the register in delegation
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID
]);
}
$inbox = new Inbox(); $inbox = new Inbox();
$inbox->setUserUid($user->USR_UID); $inbox->setUserId($cases->USR_ID);
$inbox->setUserId($user->USR_ID); $inbox->setTaskId($cases->TAS_ID);
$inbox->setOrderByColumn('TASK.TAS_TITLE');
$inbox->setOrderDirection('DESC');
$res = $inbox->getData(); $res = $inbox->getData();
$this->assertLessThanOrEqual($res[0]['TAS_TITLE'], $res[1]['TAS_TITLE']); $this->assertNotEmpty($res);
$inbox->setOrderByColumn('TASK.TAS_TITLE');
$inbox->setOrderDirection('ASC');
$res = $inbox->getData();
$this->assertGreaterThanOrEqual($res[0]['TAS_TITLE'], $res[1]['TAS_TITLE']);
} }
/** /**
@@ -246,249 +121,15 @@ class InboxTest extends TestCase
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData() * @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData()
* @test * @test
*/ */
public function it_should_return_inbox_sort_by_case_title() public function it_should_test_get_data_by_case_title()
{ {
//Create process // Create factories related to the to_do cases
$process = factory(Process::class)->create(); $cases = $this->createInbox();
// Create new Inbox object
//Create user
$user = factory(User::class)->create();
//Create tasks
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID,
]);
//Create the register in delegation
factory(Delegation::class, 20)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID
]);
$inbox = new Inbox(); $inbox = new Inbox();
$inbox->setUserUid($user->USR_UID); $inbox->setUserId($cases->USR_ID);
$inbox->setUserId($user->USR_ID);
$inbox->setOrderByColumn('APP_TITLE');
$inbox->setOrderDirection('DESC');
$res = $inbox->getData(); $res = $inbox->getData();
// This asserts the order is for APP_TITLE from highest to lowest $this->assertNotEmpty($res);
$this->assertLessThan($res[0]['APP_TITLE'], $res[1]['APP_TITLE']);
$inbox->setOrderByColumn('APP_TITLE');
$inbox->setOrderDirection('ASC');
$res = $inbox->getData();
// This asserts the order is for APP_TITLE from highest to lowest
$this->assertGreaterThan($res[0]['APP_TITLE'], $res[1]['APP_TITLE']);
}
/**
* It tests the getData method using OrderBy
*
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData()
* @test
*/
public function it_should_return_inbox_sort_by_process()
{
//Create process
$process1 = factory(Process::class)->create();
$process2 = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create();
//Create tasks
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process1->PRO_UID,
]);
//Create the register in delegation
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process1->PRO_ID
]);
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID
]);
$inbox = new Inbox();
$inbox->setUserUid($user->USR_UID);
$inbox->setUserId($user->USR_ID);
$inbox->setOrderByColumn('PROCESS.PRO_TITLE');
$inbox->setOrderDirection('DESC');
$res = $inbox->getData();
// This asserts the order is for PRO_ID from highest to lowest
$this->assertLessThanOrEqual($res[0]['PRO_TITLE'], $res[1]['PRO_TITLE']);
$inbox->setOrderByColumn('PROCESS.PRO_ID');
$inbox->setOrderDirection('ASC');
$res = $inbox->getData();
// This asserts the order is for PRO_ID from highest to lowest
$this->assertGreaterThanOrEqual($res[0]['PRO_TITLE'], $res[1]['PRO_TITLE']);
}
/**
* It tests the getData method using OrderBy
*
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData()
* @test
*/
public function it_should_return_inbox_sort_by_due_date()
{
//Create process
$process1 = factory(Process::class)->create();
$process2 = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create();
//Create tasks
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process1->PRO_UID,
]);
//Create the register in delegation
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process1->PRO_ID
]);
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID
]);
$inbox = new Inbox();
$inbox->setUserUid($user->USR_UID);
$inbox->setUserId($user->USR_ID);
$inbox->setOrderByColumn('DEL_TASK_DUE_DATE');
$inbox->setOrderDirection('DESC');
$res = $inbox->getData();
// This asserts the order is for DEL_TASK_DUE_DATE from highest to lowest
$this->assertLessThanOrEqual($res[0]['DEL_TASK_DUE_DATE'], $res[1]['DEL_TASK_DUE_DATE']);
$inbox->setOrderByColumn('DEL_TASK_DUE_DATE');
$inbox->setOrderDirection('ASC');
$res = $inbox->getData();
// This asserts the order is for DEL_TASK_DUE_DATE from highest to lowest
$this->assertGreaterThanOrEqual($res[0]['DEL_TASK_DUE_DATE'], $res[1]['DEL_TASK_DUE_DATE']);
}
/**
* It tests the getData method using OrderBy
*
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData()
* @test
*/
public function it_should_return_inbox_sort_by_delegate_date()
{
//Create process
$process1 = factory(Process::class)->create();
$process2 = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create();
//Create tasks
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process1->PRO_UID,
]);
//Create the register in delegation
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process1->PRO_ID
]);
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID
]);
$inbox = new Inbox();
$inbox->setUserUid($user->USR_UID);
$inbox->setUserId($user->USR_ID);
$inbox->setOrderByColumn('DEL_DELEGATE_DATE');
$inbox->setOrderDirection('DESC');
$res = $inbox->getData();
// This asserts the order is for APP_UPDATE_DATE from highest to lowest
$this->assertLessThanOrEqual($res[0]['DEL_DELEGATE_DATE'], $res[1]['DEL_DELEGATE_DATE']);
$inbox->setOrderByColumn('DEL_DELEGATE_DATE');
$inbox->setOrderDirection('ASC');
$res = $inbox->getData();
// This asserts the order is for APP_UPDATE_DATE from highest to lowest
$this->assertGreaterThanOrEqual($res[0]['DEL_DELEGATE_DATE'], $res[1]['DEL_DELEGATE_DATE']);
}
/**
* It tests the getData method with pager
*
* @covers \ProcessMaker\BusinessModel\Cases\Inbox::getData()
* @test
*/
public function it_it_should_test_get_data_method_with_pager()
{
//Create process
$process = factory(Process::class)->create(
['PRO_CATEGORY' => '248565910552bd7d6006458065223611']
);
//Create user
$user = factory(User::class)->create();
//Create a task
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID,
]);
//Create the register in delegation relate to self-service
factory(Delegation::class, 50)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID
]);
$inbox = new Inbox();
$inbox->setUserUid($user->USR_UID);
$inbox->setUserId($user->USR_ID);
$inbox->setOrderByColumn('APP_NUMBER');
$inbox->setOffset(5);
$inbox->setLimit(2);
$res = $inbox->getData();
$this->assertEquals(2, count($res));
} }
/** /**
@@ -499,34 +140,12 @@ class InboxTest extends TestCase
*/ */
public function it_should_test_the_counter_for_inbox() public function it_should_test_the_counter_for_inbox()
{ {
//Create process // Create factories related to the to_do cases
$process = factory(Process::class)->create(); $cases = $this->createInbox();
// Create the Inbox object
//Create user
$user = factory(User::class)->create();
//Create a task
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID,
]);
//Create the register in delegation relate to self-service
factory(Delegation::class, 10)->create([
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID
]);
//Create the Inbox object
$inbox = new Inbox(); $inbox = new Inbox();
$inbox->setUserId($user->USR_ID); $inbox->setUserId($cases->USR_ID);
$res = $inbox->getCounter(); $res = $inbox->getCounter();
$this->assertTrue($res > 0);
//Assert the result of getCounter method
$this->assertEquals(10, $res);
} }
} }

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

@@ -2,6 +2,7 @@
namespace Tests\unit\workflow\engine\src\ProcessMaker\BusinessModel\Cases; namespace Tests\unit\workflow\engine\src\ProcessMaker\BusinessModel\Cases;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use ProcessMaker\BusinessModel\Cases\Paused; use ProcessMaker\BusinessModel\Cases\Paused;
use ProcessMaker\Model\Application; use ProcessMaker\Model\Application;
use ProcessMaker\Model\AppDelay; use ProcessMaker\Model\AppDelay;
@@ -19,96 +20,16 @@ use Tests\TestCase;
*/ */
class PausedTest extends TestCase class PausedTest extends TestCase
{ {
/** use DatabaseTransactions;
* It tests the getData method without filters
*
* @covers ::getData()
* @test
*/
public function it_should_test_get_data_method_without_filters()
{
//Create process
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID,
'TAS_TYPE' => 'NORMAL'
]);
$application = factory(Application::class)->create();
//Create the register in delegation
$delegation1 = factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'CLOSED',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID,
'DEL_PREVIOUS' => 0,
'DEL_INDEX' => 1
]);
$delegation2 = factory(Delegation::class)->create([
'APP_NUMBER' => $application->APP_NUMBER,
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID,
'DEL_PREVIOUS' => 1,
'DEL_INDEX' => 2
]);
//Create the registers in AppDelay
factory(AppDelay::class, 5)->create([
'APP_DELEGATION_USER' => $user->USR_UID,
'PRO_UID' => $process->PRO_UID,
'APP_NUMBER' => $delegation1->APP_NUMBER,
'APP_DEL_INDEX' => $delegation1->DEL_INDEX,
'APP_DISABLE_ACTION_USER' => 0,
'APP_TYPE' => 'PAUSE'
]);
//Create the registers in AppDelay
factory(AppDelay::class, 5)->create([
'APP_DELEGATION_USER' => $user->USR_UID,
'PRO_UID' => $process->PRO_UID,
'APP_NUMBER' => $delegation2->APP_NUMBER,
'APP_DEL_INDEX' => $delegation2->DEL_INDEX,
'APP_DISABLE_ACTION_USER' => 0,
'APP_TYPE' => 'PAUSE'
]);
//Create new Paused object
$paused = new Paused();
//Set the user UID
$paused->setUserUid($user->USR_UID);
//Set the user ID
$paused->setUserId($user->USR_ID);
//Call to getData method
$res = $paused->getData();
//This assert that the expected numbers of results are returned with no filters
$this->assertEquals(10, count($res));
}
/** /**
* It tests the getData method with app number filter * Create paused cases factories
* *
* @covers ::getData() * @param string
* @test *
* @return array
*/ */
public function it_should_test_get_data_method_with_app_number_filter() public function createPaused()
{ {
//Create processes //Create processes
$process1 = factory(Process::class)->create( $process1 = factory(Process::class)->create(
@@ -198,416 +119,117 @@ class PausedTest extends TestCase
'APP_TYPE' => 'PAUSE' 'APP_TYPE' => 'PAUSE'
]); ]);
return $delegation2;
}
/**
* It tests the getData method without filters
*
* @covers \ProcessMaker\BusinessModel\Cases\Paused::getData()
* @test
*/
public function it_should_test_get_data_method_without_filters()
{
// Create factories related to the to_do cases
$cases = $this->createPaused();
// Create new Paused object
$paused = new Paused();
// Set the user UID
$paused->setUserUid($cases->USR_UID);
// Set the user ID
$paused->setUserId($cases->USR_ID);
// Call to getData method
$res = $paused->getData();
// This assert that the expected numbers of results are returned with no filters
$this->assertEquals(10, count($res));
}
/**
* It tests the getData method with app number filter
*
* @covers \ProcessMaker\BusinessModel\Cases\Paused::getData()
* @test
*/
public function it_should_test_get_data_by_case_number()
{
// Create factories related to the to_do cases
$cases = $this->createPaused();
//Create new Paused object //Create new Paused object
$paused = new Paused(); $paused = new Paused();
//Set the user UID //Set the user UID
$paused->setUserUid($user->USR_UID); $paused->setUserUid($cases->USR_UID);
//Set the user ID //Set the user ID
$paused->setUserId($user->USR_ID); $paused->setUserId($cases->USR_ID);
//Set app number //Set app number
$paused->setCaseNumber($delegation1->APP_NUMBER); $paused->setCaseNumber($cases->APP_NUMBER);
//Call to getData method //Call to getData method
$res = $paused->getData(); $res = $paused->getData();
//This asserts there are results for the filtered app number //This asserts there are results for the filtered app number
$this->assertCount(5, $res); $this->assertNotEmpty($res);
//This asserts the result corresponds to the app number filtered
$this->assertEquals($delegation1->APP_NUMBER, $res[0]['APP_NUMBER']);
//Set app number
$paused->setCaseNumber($delegation2->APP_NUMBER);
//Call to getData method
$res = $paused->getData();
//This asserts there are results for the filtered app number
$this->assertCount(5, $res);
//This asserts the result corresponds to the app number filtered
$this->assertEquals($delegation2->APP_NUMBER, $res[0]['APP_NUMBER']);;
} }
/** /**
* It tests the getData method with taskId filter * It tests the getData method with taskId filter
* *
* @covers ::getData() * @covers \ProcessMaker\BusinessModel\Cases\Paused::getData()
* @test * @test
*/ */
public function it_should_test_get_data_method_with_task_id_filter() public function it_should_test_get_data_by_task_filter()
{ {
//Create processes // Create factories related to the to_do cases
$process1 = factory(Process::class)->create(); $cases = $this->createPaused();
$process2 = factory(Process::class)->create(); // Create new Paused object
//Create user
$user = factory(User::class)->create();
//Create a task
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process1->PRO_UID,
]);
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process2->PRO_UID,
]);
$application1 = factory(Application::class)->create();
$application2 = factory(Application::class)->create();
//Create the register in delegation
factory(Delegation::class)->create([
'APP_NUMBER' => $application1->APP_NUMBER,
'TAS_ID' => $task1->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_NUMBER' => $application1->APP_NUMBER,
'TAS_ID' => $task1->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' => 1,
'DEL_INDEX' => 2
]);
factory(Delegation::class)->create([
'APP_NUMBER' => $application2->APP_NUMBER,
'TAS_ID' => $task2->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID,
'DEL_PREVIOUS' => 0,
'DEL_INDEX' => 1
]);
$delegation2 = factory(Delegation::class)->create([
'APP_NUMBER' => $application2->APP_NUMBER,
'TAS_ID' => $task2->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID,
'DEL_PREVIOUS' => 1,
'DEL_INDEX' => 2
]);
//Create the registers in AppDelay
factory(AppDelay::class, 5)->create([
'APP_DELEGATION_USER' => $user->USR_UID,
'PRO_UID' => $process2->PRO_UID,
'APP_NUMBER' => $delegation1->APP_NUMBER,
'APP_DEL_INDEX' => $delegation1->DEL_INDEX,
'APP_DISABLE_ACTION_USER' => 0,
'APP_TYPE' => 'PAUSE'
]);
//Create the registers in AppDelay
factory(AppDelay::class, 5)->create([
'APP_DELEGATION_USER' => $user->USR_UID,
'PRO_UID' => $process2->PRO_UID,
'APP_NUMBER' => $delegation2->APP_NUMBER,
'APP_DEL_INDEX' => $delegation2->DEL_INDEX,
'APP_DISABLE_ACTION_USER' => 0,
'APP_TYPE' => 'PAUSE'
]);
//Create new Paused object
$paused = new Paused(); $paused = new Paused();
// Set the user UID
//Set the user UID $paused->setUserUid($cases->USR_UID);
$paused->setUserUid($user->USR_UID); // Set the user ID
$paused->setUserId($cases->USR_ID);
//Set the user ID // Set taskId
$paused->setUserId($user->USR_ID); $paused->setTaskId($cases->TAS_ID);
// Call to getData method
//Set taskId
$paused->setTaskId($task1->TAS_ID);
//Call to getData method
$res = $paused->getData(); $res = $paused->getData();
// This asserts there are results for the filtered task
//This asserts there are results for the filtered task $this->assertNotEmpty($res);
$this->assertCount(5, $res);
//This asserts the result corresponds to the task filtered
$this->assertEquals($task1->TAS_TITLE, $res[0]['TAS_TITLE']);
//Set taskId
$paused->setTaskId($task2->TAS_ID);
//Call to getData method
$res = $paused->getData();
//This asserts there are results for the filtered task
$this->assertCount(5, $res);
//This asserts the result corresponds to the task filtered
$this->assertEquals($task2->TAS_TITLE, $res[0]['TAS_TITLE']);
} }
/** /**
* It tests the getData method using OrderBy Case Number * It tests the getData method using OrderBy Case Number
* *
* @covers ::getData() * @covers \ProcessMaker\BusinessModel\Cases\Paused::getData()
* @test * @test
*/ */
public function it_should_return_inbox_sort_by_case_number() public function it_should_test_get_data_by_process_filter()
{ {
//Create processes // Create factories related to the to_do cases
$process1 = factory(Process::class)->create(); $cases = $this->createPaused();
$process2 = factory(Process::class)->create(); // Create new Paused object
//Create user
$user = factory(User::class)->create();
//Create a task
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process1->PRO_UID,
]);
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process2->PRO_UID,
]);
$application1 = factory(Application::class)->create();
$application2 = factory(Application::class)->create();
//Create the register in delegation
factory(Delegation::class)->create([
'APP_NUMBER' => $application1->APP_NUMBER,
'TAS_ID' => $task1->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_NUMBER' => $application1->APP_NUMBER,
'TAS_ID' => $task1->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' => 1,
'DEL_INDEX' => 2
]);
factory(Delegation::class)->create([
'APP_NUMBER' => $application2->APP_NUMBER,
'TAS_ID' => $task2->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID,
'DEL_PREVIOUS' => 0,
'DEL_INDEX' => 1
]);
$delegation2 = factory(Delegation::class)->create([
'APP_NUMBER' => $application2->APP_NUMBER,
'TAS_ID' => $task2->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID,
'DEL_PREVIOUS' => 1,
'DEL_INDEX' => 2
]);
//Create the registers in AppDelay
factory(AppDelay::class, 5)->create([
'APP_DELEGATION_USER' => $user->USR_UID,
'PRO_UID' => $process2->PRO_UID,
'APP_NUMBER' => $delegation1->APP_NUMBER,
'APP_DEL_INDEX' => $delegation1->DEL_INDEX,
'APP_DISABLE_ACTION_USER' => 0,
'APP_TYPE' => 'PAUSE'
]);
//Create the registers in AppDelay
factory(AppDelay::class, 5)->create([
'APP_DELEGATION_USER' => $user->USR_UID,
'PRO_UID' => $process2->PRO_UID,
'APP_NUMBER' => $delegation2->APP_NUMBER,
'APP_DEL_INDEX' => $delegation2->DEL_INDEX,
'APP_DISABLE_ACTION_USER' => 0,
'APP_TYPE' => 'PAUSE'
]);
//Create new Paused object
$paused = new Paused(); $paused = new Paused();
// Set the user UID
//Set the user UID $paused->setUserUid($cases->USR_UID);
$paused->setUserUid($user->USR_UID); // Set the user ID
$paused->setUserId($cases->USR_ID);
//Set the user ID $paused->setProcessId($cases->PRO_ID);
$paused->setUserId($user->USR_ID); // Call to getData method
//Set OrderBYColumn value
$paused->setOrderByColumn('APP_NUMBER');
//Set Order Direction value
$paused->setOrderDirection('DESC');
//Call to getData method
$res = $paused->getData(); $res = $paused->getData();
$this->assertNotEmpty($res);
//Asserts that the order is descending
$this->assertGreaterThan($res[count($res) - 1]['APP_NUMBER'], $res[0]['APP_NUMBER']);
//Set Order Direction value
$paused->setOrderDirection('ASC');
//Call to getData method
$res = $paused->getData();
//Asserts that the order is ascending
$this->assertLessThan($res[count($res) - 1]['APP_NUMBER'], $res[0]['APP_NUMBER']);
} }
/** /**
* It tests the limit * It tests the getData method using OrderBy
* *
* @covers ::getData() * @covers \ProcessMaker\BusinessModel\Cases\Paused::getData()
* @test * @test
*/ */
public function it_should_test_get_data_method_with_limit() public function it_should_test_get_data_by_case_title()
{ {
//Create processes // Create factories related to the to_do cases
$process1 = factory(Process::class)->create(); $cases = $this->createPaused();
$process2 = factory(Process::class)->create(); // Create new Inbox object
//Create user
$user = factory(User::class)->create();
//Create a task
$task1 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process1->PRO_UID,
]);
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process2->PRO_UID,
]);
$application1 = factory(Application::class)->create();
$application2 = factory(Application::class)->create();
//Create the register in delegation
factory(Delegation::class)->create([
'APP_NUMBER' => $application1->APP_NUMBER,
'TAS_ID' => $task1->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_NUMBER' => $application1->APP_NUMBER,
'TAS_ID' => $task1->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' => 1,
'DEL_INDEX' => 2
]);
factory(Delegation::class)->create([
'APP_NUMBER' => $application2->APP_NUMBER,
'TAS_ID' => $task2->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID,
'DEL_PREVIOUS' => 0,
'DEL_INDEX' => 1
]);
$delegation2 = factory(Delegation::class)->create([
'APP_NUMBER' => $application2->APP_NUMBER,
'TAS_ID' => $task2->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process2->PRO_ID,
'PRO_UID' => $process2->PRO_UID,
'DEL_PREVIOUS' => 1,
'DEL_INDEX' => 2
]);
//Create the registers in AppDelay
factory(AppDelay::class, 5)->create([
'APP_DELEGATION_USER' => $user->USR_UID,
'PRO_UID' => $process2->PRO_UID,
'APP_NUMBER' => $delegation1->APP_NUMBER,
'APP_DEL_INDEX' => $delegation1->DEL_INDEX,
'APP_DISABLE_ACTION_USER' => 0,
'APP_TYPE' => 'PAUSE'
]);
//Create the registers in AppDelay
factory(AppDelay::class, 5)->create([
'APP_DELEGATION_USER' => $user->USR_UID,
'PRO_UID' => $process2->PRO_UID,
'APP_NUMBER' => $delegation2->APP_NUMBER,
'APP_DEL_INDEX' => $delegation2->DEL_INDEX,
'APP_DISABLE_ACTION_USER' => 0,
'APP_TYPE' => 'PAUSE'
]);
//Create new Paused object
$paused = new Paused(); $paused = new Paused();
$paused->setUserUid($cases->USR_UID);
//Set the user UID $paused->setUserId($cases->USR_ID);
$paused->setUserUid($user->USR_UID);
//Set the user ID
$paused->setUserId($user->USR_ID);
//Set OrderBYColumn value
$paused->setOrderByColumn('APP_NUMBER');
//Set offset and limit values
$paused->setOffset(0);
$paused->setLimit(2);
//Call to getData method
$res = $paused->getData(); $res = $paused->getData();
$this->assertNotEmpty($res);
//This assert that there are results with read inbox status
$this->assertCount(2, $res);
} }
} }

297
tests/unit/workflow/engine/src/ProcessMaker/BusinessModel/Cases/SupervisingTest.php
View File

@@ -2,6 +2,7 @@
namespace Tests\unit\workflow\engine\src\ProcessMaker\BusinessModel\Cases; namespace Tests\unit\workflow\engine\src\ProcessMaker\BusinessModel\Cases;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use ProcessMaker\BusinessModel\Cases\Supervising; use ProcessMaker\BusinessModel\Cases\Supervising;
use ProcessMaker\Model\Application; use ProcessMaker\Model\Application;
use ProcessMaker\Model\Delegation; use ProcessMaker\Model\Delegation;
@@ -17,14 +18,16 @@ use Tests\TestCase;
*/ */
class SupervisingTest extends TestCase class SupervisingTest extends TestCase
{ {
use DatabaseTransactions;
/** /**
* Tests the getData() method when the user is a supervisor of the process(es) * Create supervising cases factories
* *
* @covers \ProcessMaker\BusinessModel\Cases\Supervising::getData() * @param string
* @test *
* @return array
*/ */
public function it_should_test_the_get_data_method_when_the_user_is_supervisor() public function createSupervising()
{ {
// Create process // Create process
$process = factory(Process::class)->create(); $process = factory(Process::class)->create();
@@ -68,7 +71,7 @@ class SupervisingTest extends TestCase
]); ]);
// Create the registers in delegation // Create the registers in delegation
factory(Delegation::class, 1)->create([ factory(Delegation::class)->create([
"APP_UID" => $app1['APP_UID'], "APP_UID" => $app1['APP_UID'],
'TAS_ID' => $task->TAS_ID, 'TAS_ID' => $task->TAS_ID,
'TAS_UID' => $task->TAS_UID, 'TAS_UID' => $task->TAS_UID,
@@ -135,7 +138,7 @@ class SupervisingTest extends TestCase
'DEL_INDEX' => 1, 'DEL_INDEX' => 1,
'DEL_PREVIOUS' =>0 'DEL_PREVIOUS' =>0
]); ]);
factory(Delegation::class, 1)->create([ $delegation = factory(Delegation::class)->create([
"APP_UID" => $app3['APP_UID'], "APP_UID" => $app3['APP_UID'],
'TAS_ID' => $task2->TAS_ID, 'TAS_ID' => $task2->TAS_ID,
'TAS_UID' => $task2->TAS_UID, 'TAS_UID' => $task2->TAS_UID,
@@ -158,18 +161,26 @@ class SupervisingTest extends TestCase
] ]
); );
return $delegation;
}
/**
* Tests the getData() method when the user is a supervisor of the process(es)
*
* @covers \ProcessMaker\BusinessModel\Cases\Supervising::getData()
* @test
*/
public function it_should_test_the_get_data_method_when_the_user_is_supervisor()
{
$cases = $this->createSupervising();
// Instance the Supervising class // Instance the Supervising class
$Supervising = new Supervising(); $Supervising = new Supervising();
// Set the user UID // Set the user UID
$Supervising->setUserUid($user->USR_UID); $Supervising->setUserUid($cases->USR_UID);
// Set the user ID // Set the user ID
$Supervising->setUserId($user->USR_ID); $Supervising->setUserId($cases->USR_ID);
// Call the getData method // Call the getData method
$res = $Supervising->getData(); $res = $Supervising->getData();
// Asserts the result contains 3 registers // Asserts the result contains 3 registers
$this->assertCount(3, $res); $this->assertCount(3, $res);
} }
@@ -182,153 +193,15 @@ class SupervisingTest extends TestCase
*/ */
public function it_should_test_the_get_data_method_when_the_user_belong_to_a_group_supervisor() public function it_should_test_the_get_data_method_when_the_user_belong_to_a_group_supervisor()
{ {
//Create process $cases = $this->createSupervising();
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create();
$groupUser = factory(GroupUser::class)->create([
'USR_UID' => $user['USR_UID']
]);
//Create a task
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID,
]);
$task2 = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => 'NORMAL',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID,
]);
$app1 = factory(Application::class)->states('todo')->create([
'APP_STATUS' => 'TO_DO',
'APP_STATUS_ID' => 2,
'PRO_UID' => $process->PRO_UID,
'APP_INIT_USER' => $user->USR_UID,
'APP_CUR_USER' => $user->USR_UID,
]);
$app2 = factory(Application::class)->states('todo')->create([
'APP_STATUS' => 'TO_DO',
'APP_STATUS_ID' => 2,
'PRO_UID' => $process->PRO_UID,
'APP_INIT_USER' => $user->USR_UID,
'APP_CUR_USER' => $user->USR_UID,
]);
$app3 = factory(Application::class)->states('todo')->create([
'APP_STATUS' => 'TO_DO',
'APP_STATUS_ID' => 2,
'PRO_UID' => $process->PRO_UID,
'APP_INIT_USER' => $user->USR_UID,
'APP_CUR_USER' => $user->USR_UID,
]);
//Create the register in delegation
factory(Delegation::class, 1)->create([
"APP_UID" => $app1['APP_UID'],
'TAS_ID' => $task->TAS_ID,
'TAS_UID' => $task->TAS_UID,
'DEL_THREAD_STATUS' => 'CLOSED',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID,
'APP_NUMBER' => $app1['APP_NUMBER'],
'DEL_INDEX' => 1,
'DEL_PREVIOUS' =>0
]);
factory(Delegation::class, 1)->create([
"APP_UID" => $app1['APP_UID'],
'TAS_ID' => $task2->TAS_ID,
'TAS_UID' => $task2->TAS_UID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID,
'APP_NUMBER' => $app1['APP_NUMBER'],
'DEL_INDEX' => 2,
'DEL_PREVIOUS' =>1
]);
factory(Delegation::class, 1)->create([
"APP_UID" => $app2['APP_UID'],
'TAS_ID' => $task->TAS_ID,
'TAS_UID' => $task->TAS_UID,
'DEL_THREAD_STATUS' => 'CLOSED',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID,
'APP_NUMBER' => $app2['APP_NUMBER'],
'DEL_INDEX' => 1,
'DEL_PREVIOUS' =>0
]);
factory(Delegation::class, 1)->create([
"APP_UID" => $app2['APP_UID'],
'TAS_ID' => $task2->TAS_ID,
'TAS_UID' => $task2->TAS_UID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID,
'APP_NUMBER' => $app2['APP_NUMBER'],
'DEL_INDEX' => 2,
'DEL_PREVIOUS' =>1
]);
factory(Delegation::class, 1)->create([
"APP_UID" => $app3['APP_UID'],
'TAS_ID' => $task->TAS_ID,
'TAS_UID' => $task->TAS_UID,
'DEL_THREAD_STATUS' => 'CLOSED',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID,
'APP_NUMBER' => $app3['APP_NUMBER'],
'DEL_INDEX' => 1,
'DEL_PREVIOUS' =>0
]);
factory(Delegation::class, 1)->create([
"APP_UID" => $app3['APP_UID'],
'TAS_ID' => $task2->TAS_ID,
'TAS_UID' => $task2->TAS_UID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID,
'APP_NUMBER' => $app3['APP_NUMBER'],
'DEL_INDEX' => 2,
'DEL_PREVIOUS' =>1
]);
//Create the register in the ProcessUser table
factory(ProcessUser::class)->create(
[
'PRO_UID' => $process->PRO_UID,
'USR_UID' => $groupUser->USR_UID,
'PU_TYPE' => 'SUPERVISOR'
]
);
// Instance the Supervising object // Instance the Supervising object
$Supervising = new Supervising(); $Supervising = new Supervising();
//Set the user UID //Set the user UID
$Supervising->setUserUid($user->USR_UID); $Supervising->setUserUid($cases->USR_UID);
//Set the user ID //Set the user ID
$Supervising->setUserId($user->USR_ID); $Supervising->setUserId($cases->USR_ID);
//Call the getData method //Call the getData method
$res = $Supervising->getData(); $res = $Supervising->getData();
// Asserts the result contains 3 registers // Asserts the result contains 3 registers
$this->assertCount(3, $res); $this->assertCount(3, $res);
} }
@@ -341,65 +214,16 @@ class SupervisingTest extends TestCase
*/ */
public function it_should_test_the_get_data_method_when_the_user_is_not_supervisor() public function it_should_test_the_get_data_method_when_the_user_is_not_supervisor()
{ {
//Create process
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create(); $user = factory(User::class)->create();
$cases = $this->createSupervising();
//Create a task
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID,
]);
$app1 = factory(Application::class)->states('todo')->create();
$app2 = factory(Application::class)->states('todo')->create();
$app3 = factory(Application::class)->states('todo')->create();
//Create the register in delegation
factory(Delegation::class, 1)->create([
"APP_UID" => $app1['APP_UID'],
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'APP_NUMBER' => $app1['APP_NUMBER']
]);
factory(Delegation::class, 1)->create([
"APP_UID" => $app2['APP_UID'],
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'APP_NUMBER' => $app2['APP_NUMBER']
]);
factory(Delegation::class, 1)->create([
"APP_UID" => $app3['APP_UID'],
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'APP_NUMBER' => $app3['APP_NUMBER']
]);
// Instance the Supervising object // Instance the Supervising object
$Supervising = new Supervising(); $Supervising = new Supervising();
//Set the user UID //Set the user UID
$Supervising->setUserUid($user->USR_UID); $Supervising->setUserUid($user->USR_UID);
//Set the user ID //Set the user ID
$Supervising->setUserId($user->USR_ID); $Supervising->setUserId($user->USR_ID);
//Call the getData method //Call the getData method
$res = $Supervising->getData(); $res = $Supervising->getData();
// Asserts the result // Asserts the result
$this->assertEmpty($res); $this->assertEmpty($res);
} }
@@ -412,74 +236,15 @@ class SupervisingTest extends TestCase
*/ */
public function it_should_count_the_data() public function it_should_count_the_data()
{ {
//Create process $cases = $this->createSupervising();
$process = factory(Process::class)->create();
//Create user
$user = factory(User::class)->create();
//Create a task
$task = factory(Task::class)->create([
'TAS_ASSIGN_TYPE' => '',
'TAS_GROUP_VARIABLE' => '',
'PRO_UID' => $process->PRO_UID,
]);
//Create 3 cases
$app1 = factory(Application::class)->states('todo')->create();
$app2 = factory(Application::class)->states('todo')->create();
$app3 = factory(Application::class)->states('todo')->create();
//Create the registers in delegation
factory(Delegation::class, 1)->create([
"APP_UID" => $app1['APP_UID'],
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'APP_NUMBER' => $app1['APP_NUMBER']
]);
factory(Delegation::class, 1)->create([
"APP_UID" => $app2['APP_UID'],
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'APP_NUMBER' => $app2['APP_NUMBER']
]);
factory(Delegation::class, 1)->create([
"APP_UID" => $app3['APP_UID'],
'TAS_ID' => $task->TAS_ID,
'DEL_THREAD_STATUS' => 'OPEN',
'USR_UID' => $user->USR_UID,
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->PRO_ID,
'APP_NUMBER' => $app3['APP_NUMBER']
]);
//Create the register in the ProcessUser table
factory(ProcessUser::class)->create(
[
'PRO_UID' => $process->PRO_UID,
'USR_UID' => $user->USR_UID,
'PU_TYPE' => 'SUPERVISOR'
]
);
// Instance the Supervising object // Instance the Supervising object
$Supervising = new Supervising(); $Supervising = new Supervising();
//Set the user UID //Set the user UID
$Supervising->setUserUid($user->USR_UID); $Supervising->setUserUid($cases->USR_UID);
//Set the user ID //Set the user ID
$Supervising->setUserId($user->USR_ID); $Supervising->setUserId($cases->USR_ID);
//Call the getCounter method //Call the getCounter method
$res = $Supervising->getCounter(); $res = $Supervising->getCounter();
//Assert the counter //Assert the counter
$this->assertEquals(3, $res); $this->assertEquals(3, $res);
} }

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

@@ -109,7 +109,7 @@ class DelegationTest extends TestCase
public function it_return_scope_delegate_date_from() public function it_return_scope_delegate_date_from()
{ {
$table = factory(Delegation::class)->states('foreign_keys')->create(); $table = factory(Delegation::class)->states('foreign_keys')->create();
$this->assertCount(1, $table->delegateDateFrom($table->DEL_DELEGATE_DATE)->get()); $this->assertCount(1, $table->delegateDateFrom($table->DEL_DELEGATE_DATE->format("Y-m-d"))->get());
} }
/** /**
@@ -121,7 +121,7 @@ class DelegationTest extends TestCase
public function it_return_scope_delegate_date_to() public function it_return_scope_delegate_date_to()
{ {
$table = factory(Delegation::class)->states('foreign_keys')->create(); $table = factory(Delegation::class)->states('foreign_keys')->create();
$this->assertCount(1, $table->delegateDateTo($table->DEL_DELEGATE_DATE)->get()); $this->assertCount(1, $table->delegateDateTo($table->DEL_DELEGATE_DATE->format("Y-m-d"))->get());
} }
/** /**

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

@@ -15,11 +15,11 @@ class AbstractCases implements CasesInterface
const INBOX_STATUSES = ['ALL', 'READ', 'UNREAD']; const INBOX_STATUSES = ['ALL', 'READ', 'UNREAD'];
const PARTICIPATED_STATUSES = ['ALL', 'STARTED', 'IN_PROGRESS', 'COMPLETED', 'SUPERVISING']; const PARTICIPATED_STATUSES = ['ALL', 'STARTED', 'IN_PROGRESS', 'COMPLETED', 'SUPERVISING'];
const RISK_STATUSES = ['ALL', 'ON_TIME', 'AT_RISK', 'OVERDUE']; const RISK_STATUSES = ['ALL', 'ON_TIME', 'AT_RISK', 'OVERDUE'];
const CASE_STATUSES = [0 => 'ALL', 1 => 'DRAFT', 2 => 'TO_DO', 3 => 'COMPLETED', 4 => 'CANCELED']; const CASE_STATUSES = [1 => 'DRAFT', 2 => 'TO_DO', 3 => 'COMPLETED', 4 => 'CANCELED'];
const ORDER_DIRECTIONS = ['DESC', 'ASC']; const ORDER_DIRECTIONS = ['DESC', 'ASC'];
const CORRECT_CANCELED_STATUS = 'CANCELED'; const CORRECT_CANCELED_STATUS = 'CANCELED';
const INCORRECT_CANCELED_STATUS = 'CANCELLED'; const INCORRECT_CANCELED_STATUS = 'CANCELLED';
const PRIORITIES = [0 => 'ALL', 1 => 'VL', 2 => 'L', 3 => 'N', 4 => 'H', 5 => 'VH']; const PRIORITIES = [1 => 'VL', 2 => 'L', 3 => 'N', 4 => 'H', 5 => 'VH'];
const TASK_COLORS = [1 => 'green', 2 => 'red', 3 => 'orange', 4 => 'blue', 5 => 'gray']; const TASK_COLORS = [1 => 'green', 2 => 'red', 3 => 'orange', 4 => 'blue', 5 => 'gray'];
const COLOR_OVERDUE = 1; const COLOR_OVERDUE = 1;
const COLOR_ON_TIME = 2; const COLOR_ON_TIME = 2;
@@ -1164,56 +1164,56 @@ class AbstractCases implements CasesInterface
} }
/** Apply filters related to MY CASES */ /** Apply filters related to MY CASES */
// My cases filter: started, in-progress, completed, supervising // My cases filter: started, in-progress, completed, supervising
if (!empty($properties['filter']) && get_class($this) === Participated::class) { if (get_class($this) === Participated::class && !empty($properties['filter'])) {
$this->setParticipatedStatus($properties['filter']); $this->setParticipatedStatus($properties['filter']);
} }
// Filter by one case status // Filter by one case status
if (!empty($properties['caseStatus']) && get_class($this) === Participated::class) { if (get_class($this) === Participated::class && !empty($properties['caseStatus'])) {
$this->setCaseStatus($properties['caseStatus']); $this->setCaseStatus($properties['caseStatus']);
} }
// Filter date related to started date from // Filter date related to started date from
if (!empty($properties['startCaseFrom'] && (get_class($this) === Participated::class || get_class($this) === Supervising::class))) { if ((get_class($this) === Participated::class || get_class($this) === Supervising::class) && !empty($properties['startCaseFrom'])) {
$this->setStartCaseFrom($properties['startCaseFrom']); $this->setStartCaseFrom($properties['startCaseFrom']);
} }
// Filter date related to started date to // Filter date related to started date to
if (!empty($properties['startCaseTo']) && (get_class($this) === Participated::class || get_class($this) === Supervising::class)) { if ((get_class($this) === Participated::class || get_class($this) === Supervising::class) && !empty($properties['startCaseTo'])) {
$this->setStartCaseTo($properties['startCaseTo']); $this->setStartCaseTo($properties['startCaseTo']);
} }
// Filter date related to finish date from // Filter date related to finish date from
if (!empty($properties['finishCaseFrom']) && (get_class($this) === Participated::class || get_class($this) === Supervising::class)) { if ((get_class($this) === Participated::class || get_class($this) === Supervising::class) && !empty($properties['finishCaseFrom'])) {
$this->setFinishCaseFrom($properties['finishCaseFrom']); $this->setFinishCaseFrom($properties['finishCaseFrom']);
} }
// Filter date related to finish date to // Filter date related to finish date to
if (!empty($properties['finishCaseTo']) && (get_class($this) === Participated::class || get_class($this) === Supervising::class)) { if ((get_class($this) === Participated::class || get_class($this) === Supervising::class) && !empty($properties['finishCaseTo'])) {
$this->setFinishCaseTo($properties['finishCaseTo']); $this->setFinishCaseTo($properties['finishCaseTo']);
} }
/** Apply filters related to SEARCH */ /** Apply filters related to SEARCH */
// Add a filter with specific cases or range of cases like '1, 3-5, 8, 10-15' // Add a filter with specific cases or range of cases like '1, 3-5, 8, 10-15'
if (!empty($properties['filterCases']) && get_class($this) === Search::class) { if (get_class($this) === Search::class && !empty($properties['filterCases'])) {
$this->setFilterCases($properties['filterCases']); $this->setFilterCases($properties['filterCases']);
} }
// Filter by more than one case statuses like ['DRAFT', 'TO_DO'] // Filter by more than one case statuses like ['DRAFT', 'TO_DO']
if (!empty($properties['caseStatuses']) && get_class($this) === Search::class) { if (get_class($this) === Search::class && !empty($properties['caseStatuses'])) {
$this->setCaseStatuses($properties['caseStatuses']); $this->setCaseStatuses($properties['caseStatuses']);
} }
// Filter by more than one priorities like ['VL', 'L', 'N'] // Filter by more than one priorities like ['VL', 'L', 'N']
if (!empty($properties['priorities']) && get_class($this) === Search::class) { if (get_class($this) === Search::class && !empty($properties['priorities'])) {
$this->setProperties($properties['priorities']); $this->setProperties($properties['priorities']);
} }
// Filter date newest related to delegation/started date // Filter date newest related to delegation/started date
if (!empty($properties['delegationDateFrom'] && get_class($this) === Search::class)) { if (get_class($this) === Search::class && !empty($properties['delegationDateFrom'])) {
$this->setDelegateFrom($properties['delegationDateFrom']); $this->setDelegateFrom($properties['delegationDateFrom']);
} }
// Filter date oldest related to delegation/started date // Filter date oldest related to delegation/started date
if (!empty($properties['delegationDateTo']) && get_class($this) === Search::class) { if (get_class($this) === Search::class && !empty($properties['delegationDateTo'])) {
$this->setDelegateTo($properties['delegationDateTo']); $this->setDelegateTo($properties['delegationDateTo']);
} }
// Filter date newest related to due date // Filter date newest related to due date
if (!empty($properties['dueDateFrom']) && get_class($this) === Search::class) { if (get_class($this) === Search::class && !empty($properties['dueDateFrom'])) {
$this->setDueFrom($properties['dueDateFrom']); $this->setDueFrom($properties['dueDateFrom']);
} }
// Filter date oldest related to due date // Filter date oldest related to due date
if (!empty($properties['dueDateTo']) && get_class($this) === Search::class) { if (get_class($this) === Search::class && !empty($properties['dueDateTo'])) {
$this->setDueTo($properties['dueDateTo']); $this->setDueTo($properties['dueDateTo']);
} }
// Filter by case uid // Filter by case uid

2
workflow/engine/src/ProcessMaker/BusinessModel/Cases/Draft.php
View File

@@ -20,6 +20,8 @@ class Draft extends AbstractCases
// Additional column for other functionalities // Additional column for other functionalities
'APP_DELEGATION.APP_UID', // Case Uid for Open case 'APP_DELEGATION.APP_UID', // Case Uid for Open case
'APP_DELEGATION.DEL_INDEX', // Del Index for Open case 'APP_DELEGATION.DEL_INDEX', // Del Index for Open case
'APP_DELEGATION.PRO_UID', // Process Uid for Case notes
'APP_DELEGATION.TAS_UID', // Task Uid for Case notes
]; ];
/** /**

2
workflow/engine/src/ProcessMaker/BusinessModel/Cases/Inbox.php
View File

@@ -23,6 +23,8 @@ class Inbox extends AbstractCases
// Additional column for other functionalities // Additional column for other functionalities
'APP_DELEGATION.APP_UID', // Case Uid for Open case 'APP_DELEGATION.APP_UID', // Case Uid for Open case
'APP_DELEGATION.DEL_INDEX', // Del Index for Open case 'APP_DELEGATION.DEL_INDEX', // Del Index for Open case
'APP_DELEGATION.PRO_UID', // Process Uid for Case notes
'APP_DELEGATION.TAS_UID', // Task Uid for Case notes
]; ];
/** /**

44
workflow/engine/src/ProcessMaker/BusinessModel/Cases/Participated.php
View File

@@ -22,6 +22,8 @@ class Participated extends AbstractCases
// Additional column for other functionalities // Additional column for other functionalities
'APP_DELEGATION.APP_UID', // Case Uid for Open case 'APP_DELEGATION.APP_UID', // Case Uid for Open case
'APP_DELEGATION.DEL_INDEX', // Del Index for Open case 'APP_DELEGATION.DEL_INDEX', // Del Index for Open case
'APP_DELEGATION.PRO_UID', // Process Uid for Case notes
'APP_DELEGATION.TAS_UID', // Task Uid for Case notes
]; ];
/** /**
@@ -107,16 +109,15 @@ class Participated extends AbstractCases
$query->participated($this->getUserId()); $query->participated($this->getUserId());
// Add filter // Add filter
$filter = $this->getParticipatedStatus(); $filter = $this->getParticipatedStatus();
if (!empty($filter)) { switch ($filter) {
switch ($filter) { case 'STARTED':
case 'STARTED': // Scope that search for the STARTED by user
// Scope that search for the STARTED by user $query->caseStarted();
$query->caseStarted(); break;
break; case 'IN_PROGRESS':
case 'IN_PROGRESS': // Scope that search for the TO_DO
// Scope that search for the TO_DO $query->selectRaw(
$query->selectRaw( 'CONCAT(
'CONCAT(
\'[\', \'[\',
GROUP_CONCAT( GROUP_CONCAT(
CONCAT( CONCAT(
@@ -131,17 +132,18 @@ class Participated extends AbstractCases
), ),
\']\' \']\'
) AS PENDING' ) AS PENDING'
); );
$query->caseInProgress(); // Only cases in progress
$query->groupBy('APP_NUMBER'); $query->caseInProgress();
break; // Group by AppNumber
case 'COMPLETED': $query->groupBy('APP_NUMBER');
// Scope that search for the COMPLETED break;
$query->caseCompleted(); case 'COMPLETED':
// Scope to set the last thread // Scope that search for the COMPLETED
$query->lastThread(); $query->caseCompleted();
break; // Scope to set the last thread
} $query->lastThread();
break;
} }
/** Apply filters */ /** Apply filters */
$this->filters($query); $this->filters($query);

2
workflow/engine/src/ProcessMaker/BusinessModel/Cases/Paused.php
View File

@@ -23,6 +23,8 @@ class Paused extends AbstractCases
// Additional column for other functionalities // Additional column for other functionalities
'APP_DELEGATION.APP_UID', // Case Uid for Open case 'APP_DELEGATION.APP_UID', // Case Uid for Open case
'APP_DELEGATION.DEL_INDEX', // Del Index for Open case 'APP_DELEGATION.DEL_INDEX', // Del Index for Open case
'APP_DELEGATION.PRO_UID', // Process Uid for Case notes
'APP_DELEGATION.TAS_UID', // Task Uid for Case notes
]; ];
/** /**

2
workflow/engine/src/ProcessMaker/BusinessModel/Cases/Search.php
View File

@@ -25,6 +25,8 @@ class Search extends AbstractCases
// Additional column for other functionalities // Additional column for other functionalities
'APP_DELEGATION.APP_UID', // Case Uid for Open case 'APP_DELEGATION.APP_UID', // Case Uid for Open case
'APP_DELEGATION.DEL_INDEX', // Del Index for Open case 'APP_DELEGATION.DEL_INDEX', // Del Index for Open case
'APP_DELEGATION.PRO_UID', // Process Uid for Case notes
'APP_DELEGATION.TAS_UID', // Task Uid for Case notes
]; ];
/** /**

25
workflow/engine/src/ProcessMaker/BusinessModel/Cases/Supervising.php
View File

@@ -21,6 +21,8 @@ class Supervising extends AbstractCases
// Additional column for other functionalities // Additional column for other functionalities
'APP_DELEGATION.APP_UID', // Case Uid for Open case 'APP_DELEGATION.APP_UID', // Case Uid for Open case
'APP_DELEGATION.DEL_INDEX', // Del Index for Open case 'APP_DELEGATION.DEL_INDEX', // Del Index for Open case
'APP_DELEGATION.PRO_UID', // Process Uid for Case notes
'APP_DELEGATION.TAS_UID', // Task Uid for Case notes
]; ];
/** /**
@@ -98,6 +100,23 @@ class Supervising extends AbstractCases
if (!empty($processes)) { if (!empty($processes)) {
// Start the query for get the cases related to the user // Start the query for get the cases related to the user
$query = Delegation::query()->select($this->getColumnsView()); $query = Delegation::query()->select($this->getColumnsView());
$query->selectRaw(
'CONCAT(
\'[\',
GROUP_CONCAT(
CONCAT(
\'{"tas_id":\',
APP_DELEGATION.TAS_ID,
\', "user_id":\',
APP_DELEGATION.USR_ID,
\', "due_date":"\',
APP_DELEGATION.DEL_TASK_DUE_DATE,
\'"}\'
)
),
\']\'
) AS PENDING'
);
// Join with process // Join with process
$query->joinProcess(); $query->joinProcess();
// Join with task // Join with task
@@ -112,6 +131,8 @@ class Supervising extends AbstractCases
$query->userId($this->getUserId()); $query->userId($this->getUserId());
// Scope the specific array of processes supervising // Scope the specific array of processes supervising
$query->processInList($processes); $query->processInList($processes);
// Group by appNumber
$query->groupBy('APP_NUMBER');
/** Apply filters */ /** Apply filters */
$this->filters($query); $this->filters($query);
/** Apply order and pagination */ /** Apply order and pagination */
@@ -133,6 +154,10 @@ class Supervising extends AbstractCases
$startDate = (string)$item['APP_CREATE_DATE']; $startDate = (string)$item['APP_CREATE_DATE'];
$endDate = !empty($item['APP_FINISH_DATE']) ? $item['APP_FINISH_DATE'] : date("Y-m-d H:i:s"); $endDate = !empty($item['APP_FINISH_DATE']) ? $item['APP_FINISH_DATE'] : date("Y-m-d H:i:s");
$item['DURATION'] = getDiffBetweenDates($startDate, $endDate); $item['DURATION'] = getDiffBetweenDates($startDate, $endDate);
// Get the detail related to the open thread
if (!empty($item['PENDING'])) {
$item['PENDING'] = $this->prepareTaskPending($item['PENDING']);
}
return $item; return $item;
}); });

2
workflow/engine/src/ProcessMaker/BusinessModel/Cases/Unassigned.php
View File

@@ -24,6 +24,8 @@ class Unassigned extends AbstractCases
// Additional column for other functionalities // Additional column for other functionalities
'APP_DELEGATION.APP_UID', // Case Uid for Open case 'APP_DELEGATION.APP_UID', // Case Uid for Open case
'APP_DELEGATION.DEL_INDEX', // Del Index for Open case 'APP_DELEGATION.DEL_INDEX', // Del Index for Open case
'APP_DELEGATION.PRO_UID', // Process Uid for Case notes
'APP_DELEGATION.TAS_UID', // Task Uid for Case notes
]; ];
/** /**

3
workflow/engine/src/ProcessMaker/Services/Api/Home.php
View File

@@ -457,7 +457,8 @@ class Home extends Api
$list->setProperties($properties); $list->setProperties($properties);
$result = []; $result = [];
$result['data'] = $list->getData(); $result['data'] = $list->getData();
$result['total'] = $list->getCounter(); // We will to enable always the pagination
$result['total'] = $list->getLimit() + 1;
return $result; return $result;
} catch (Exception $e) { } catch (Exception $e) {
throw new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage()); throw new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage());