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

Merged in feature/PMCORE-503 (pull request #7344)

Browse Source 
PMCORE-503

Approved-by: Julio Cesar Laura Avendaño <contact@julio-laura.com>
This commit is contained in:
Paula Quispe
2020-06-12 21:37:13 +00:00
committed by Julio Cesar Laura Avendaño
parent f75d407041 557f3634e5
commit 49e0ca6490
14 changed files with 2392 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
database/factories/ProcessVariablesFactory.php
View File

@@ -6,9 +6,37 @@ use ProcessMaker\Model\ProcessVariables;
$factory->define(ProcessVariables::class, function (Faker $faker) { $factory->define(ProcessVariables::class, function (Faker $faker) {
return [ return [
'VAR_UID' => G::generateUniqueID(), 'VAR_UID' => G::generateUniqueID(),
'PRO_ID' => G::generateUniqueID(),
'PRJ_UID' => G::generateUniqueID(), 'PRJ_UID' => G::generateUniqueID(),
'VAR_NAME' => $faker->word, 'VAR_NAME' => $faker->word,
'VAR_FIELD_TYPE' => G::generateUniqueID(), 'VAR_FIELD_TYPE' => G::generateUniqueID(),
'VAR_FIELD_TYPE_ID' => G::generateUniqueID(),
'VAR_FIELD_SIZE' => 10,
'VAR_LABEL' => 'string',
'VAR_DBCONNECTION' => 'workflow',
'VAR_SQL' => '',
'VAR_NULL' => 0,
'VAR_DEFAULT' => '',
'VAR_ACCEPTED_VALUES' => '[]',
'INP_DOC_UID' => ''
];
});
// Create a processVariables with the foreign keys
$factory->state(ProcessVariables::class, 'foreign_keys', function (Faker $faker) {
$types = ['string', 'integer', 'float', 'boolean', 'datetime', 'grid', 'array', 'file', 'multiplefile', 'object'];
$varType = $faker->randomElement($types);
$varTypeId = array_search($varType, $types) + 1;
// Create values in the foreign key relations
$process = factory(\ProcessMaker\Model\Process::class)->create();
return [
'VAR_UID' => G::generateUniqueID(),
'PRO_ID' => $process->PRO_ID,
'PRJ_UID' => $process->PRO_UID,
'VAR_NAME' => $faker->word,
'VAR_FIELD_TYPE' => $varType,
'VAR_FIELD_TYPE_ID' => $varTypeId,
'VAR_FIELD_SIZE' => 10, 'VAR_FIELD_SIZE' => 10,
'VAR_LABEL' => 'string', 'VAR_LABEL' => 'string',
'VAR_DBCONNECTION' => 'workflow', 'VAR_DBCONNECTION' => 'workflow',

6
gulliver/js/codemirror/addon/hint/php-hint.js vendored
View File

@@ -90,6 +90,10 @@
var evaluateFunctionFunction = [evaluateFunction+"($gridName,$Expression)"]; var evaluateFunctionFunction = [evaluateFunction+"($gridName,$Expression)"];
arrayFunctions[evaluateFunction] = evaluateFunctionFunction; arrayFunctions[evaluateFunction] = evaluateFunctionFunction;
var PMFTotalCalculation = "PMFTotalCalculation";
var PMFTotalCalculationFunction = [PMFTotalCalculation + "($gridName, $field, 'function')"];
arrayFunctions[PMFTotalCalculation] = PMFTotalCalculationFunction;
var PMFTaskCase = "PMFTaskCase"; var PMFTaskCase = "PMFTaskCase";
var PMFTaskCaseFunction = [PMFTaskCase+"($caseId)"]; var PMFTaskCaseFunction = [PMFTaskCase+"($caseId)"];
arrayFunctions[PMFTaskCase] = PMFTaskCaseFunction; arrayFunctions[PMFTaskCase] = PMFTaskCaseFunction;
@@ -219,7 +223,7 @@
arrayFunctions[PMFGetCaseNotes] = PMFGetCaseNotesFunction; arrayFunctions[PMFGetCaseNotes] = PMFGetCaseNotesFunction;
var phpPMFunctions = [formatDate,getCurrentDate,getCurrentTime,literalDate,capitalize,lowerCase,upperCase,userInfo,executeQuery,orderGrid, var phpPMFunctions = [formatDate,getCurrentDate,getCurrentTime,literalDate,capitalize,lowerCase,upperCase,userInfo,executeQuery,orderGrid,
evaluateFunction,PMFTaskCase,PMFTaskList,PMFUserList,PMFGroupList,PMFRoleList,PMFCaseList,PMFProcessList,PMFSendVariables,PMFDerivateCase, evaluateFunction, PMFTotalCalculation, PMFTaskCase,PMFTaskList,PMFUserList,PMFGroupList,PMFRoleList,PMFCaseList,PMFProcessList,PMFSendVariables,PMFDerivateCase,
PMFNewCaseImpersonate,PMFNewCase,PMFPauseCase,PMFUnpauseCase,PMFAssignUserToGroup,PMFCreateUser,PMFUpdateUser,PMFInformationUser, PMFNewCaseImpersonate,PMFNewCase,PMFPauseCase,PMFUnpauseCase,PMFAssignUserToGroup,PMFCreateUser,PMFUpdateUser,PMFInformationUser,
generateCode,setCaseTrackerCode,jumping,PMFRedirectToStep,pauseCase,PMFSendMessage,PMFgetLabelOption,PMFGenerateOutputDocument, generateCode,setCaseTrackerCode,jumping,PMFRedirectToStep,pauseCase,PMFSendMessage,PMFgetLabelOption,PMFGenerateOutputDocument,
PMFGetUserEmailAddress,PMFGetNextAssignedUser,PMFDeleteCase,PMFCancelCase,PMFAddInputDocument,PMFAddCaseNote,PMFGetCaseNotes]; PMFGetUserEmailAddress,PMFGetNextAssignedUser,PMFDeleteCase,PMFCancelCase,PMFAddInputDocument,PMFAddCaseNote,PMFGetCaseNotes];

1666
tests/resources/dynaform1.json Normal file
View File

File diff suppressed because it is too large Load Diff

58
tests/unit/workflow/engine/classes/PmDynaformTest.php
View File

@@ -984,6 +984,64 @@ class PmDynaformTest extends TestCase
// Compare the values // Compare the values
$this->assertEquals($dynaformTitle, $dynaform->DYN_TITLE); $this->assertEquals($dynaformTitle, $dynaform->DYN_TITLE);
} }
/**
* This test should verify the setDependentOptionsForDatetime() method, to
* add the dependentOptions property to the datetime control.
* @test
* @covers PmDynaform::jsonr()
* @covers PmDynaform::setDependentOptionsForDatetime()
*/
public function it_should_test_dependent_options_for_datetime_control()
{
$pathData = PATH_TRUNK . "/tests/resources/dynaform1.json";
$data = file_get_contents($pathData);
$json = json_decode($data);
//assert for not contain property: dependentOptions
$result = json_decode(json_encode($json), JSON_OBJECT_AS_ARRAY);
$fn = function($item) use(&$fn) {
if (is_array($item)) {
if (isset($item['type']) && $item['type'] === 'datetime') {
$this->assertArrayNotHasKey('dependentOptions', $item);
}
array_map($fn, $item);
}
};
array_map($fn, $result);
//assert new property: dependentOptions
$dynaform = new PmDynaform();
$dynaform->jsonr($json);
$result = json_decode(json_encode($json), JSON_OBJECT_AS_ARRAY);
$fn = function($item) use(&$fn) {
if (is_array($item)) {
if (isset($item['type']) && $item['type'] === 'datetime') {
$this->assertArrayHasKey('dependentOptions', $item);
$this->assertArrayHasKey('minDate', $item['dependentOptions']);
$this->assertArrayHasKey('maxDate', $item['dependentOptions']);
$this->assertArrayHasKey('defaultDate', $item['dependentOptions']);
}
array_map($fn, $item);
}
};
array_map($fn, $result);
$dynaform = new PmDynaform();
$reflection = new ReflectionClass($dynaform);
$reflectionMethod = $reflection->getMethod('setDependentOptionsForDatetime');
$reflectionMethod->setAccessible(true);
$a = new stdClass();
$reflectionMethod->invokeArgs($dynaform, [&$a]);
$this->assertInstanceOf('ReflectionMethod', $reflectionMethod);
$a = new stdClass();
$a->type = 'suggest';
$reflectionMethod->invokeArgs($dynaform, [&$a]);
$this->assertInstanceOf('ReflectionMethod', $reflectionMethod);
}
} }
// Dummy function used for the coverture // Dummy function used for the coverture

260
tests/unit/workflow/engine/classes/PmFunctions/PMFTotalCalculationTest.php Normal file
View File

@@ -0,0 +1,260 @@
<?php
namespace Tests\unit\workflow\engine\classes\PmFunctions;
use Faker\Factory;
use Tests\TestCase;
/**
* Test the PMFTotalCalculation() function
*
* @link https://wiki.processmaker.com/3.1/ProcessMaker_Functions#executeQuery.28.29
*/
class PMFTotalCalculationTest extends TestCase
{
/**
* This tests if the "PMFTotalCalculation" execute correctly the sum
* @test
*/
public function it_must_return_the_sum_of_the_method()
{
$grid = [
'1' => [
"field1" => "Value 1",
"field2" => 2
],
'2' => [
"field1" => "Value 2",
"field2" => 5
],
'3' => [
"field1" => "Value 3",
"field2" => 3
]
];
$field = "field2";
$this->assertEquals(10, PMFTotalCalculation($grid, $field, 'sum'));
}
/**
* This tests if the "PMFTotalCalculation" execute correctly the average
* @test
*/
public function it_must_return_the_average_of_the_method()
{
$grid = [
'1' => [
"field1" => "Value 1",
"field2" => 2
],
'2' => [
"field1" => "Value 2",
"field2" => 5
],
'3' => [
"field1" => "Value 3",
"field2" => 3
]
];
$this->assertEquals(3.3333333333, PMFTotalCalculation($grid, 'field2', 'average'));
}
/**
* This tests if the "PMFTotalCalculation" execute correctly the median
* @test
*/
public function it_must_return_the_median_of_the_method()
{
$grid1 = [
'1' => [
"field1" => "Value 1",
"field2" => 2
],
'2' => [
"field1" => "Value 2",
"field2" => 5
],
'3' => [
"field1" => "Value 3",
"field2" => 3
]
];
$grid2 = [
'1' => [
"field1" => "Value 1",
"field2" => 2
],
'2' => [
"field1" => "Value 2",
"field2" => 5
],
'3' => [
"field1" => "Value 3",
"field2" => 3
],
'4' => [
"field1" => "Value 3",
"field2" => 8
]
];
$this->assertEquals(3, PMFTotalCalculation($grid1, 'field2', 'median'));
$this->assertEquals(4, PMFTotalCalculation($grid2, 'field2', 'median'));
}
/**
* This tests if the "PMFTotalCalculation" execute correctly the minimum
* @test
*/
public function it_must_return_the_minimum_of_the_method()
{
$grid = [
'1' => [
"field1" => "Value 1",
"field2" => 5
],
'2' => [
"field1" => "Value 2",
"field2" => 2
],
'3' => [
"field1" => "Value 3",
"field2" => 3
]
];
$this->assertEquals(2, PMFTotalCalculation($grid, 'field2', 'minimum'));
}
/**
* This tests if the "PMFTotalCalculation" execute correctly the maximum
* @test
*/
public function it_must_return_the_maximum_of_the_method()
{
$grid = [
'1' => [
"field1" => "Value 1",
"field2" => 2
],
'2' => [
"field1" => "Value 2",
"field2" => 5
],
'3' => [
"field1" => "Value 3",
"field2" => 3
]
];
$this->assertEquals(5, PMFTotalCalculation($grid, 'field2', 'maximum'));
}
/**
* This tests if the "PMFTotalCalculation" execute correctly the standardDeviation
* @test
*/
public function it_must_return_the_standardDeviation_of_the_method()
{
$grid = [
'1' => [
"field1" => "Value 1",
"field2" => 25
],
'2' => [
"field1" => "Value 2",
"field2" => 40
],
'3' => [
"field1" => "Value 3",
"field2" => 10
]
];
$this->assertEquals(12.2474487139, PMFTotalCalculation($grid, 'field2', 'standardDeviation'));
}
/**
* This tests if the "PMFTotalCalculation" execute correctly the variance
* @test
*/
public function it_must_return_the_variance_of_the_method()
{
$grid = [
'1' => [
"field1" => "Value 1",
"field2" => 25
],
'2' => [
"field1" => "Value 2",
"field2" => 40
],
'3' => [
"field1" => "Value 3",
"field2" => 10
]
];
$this->assertEquals(150, PMFTotalCalculation($grid, 'field2', 'variance'));
}
/**
* This tests if the "PMFTotalCalculation" execute correctly the percentile
* @test
*/
public function it_must_return_the_percentile_of_the_method()
{
$grid = [
'1' => [
"field1" => "Value 1",
"field2" => 10
],
'2' => [
"field1" => "Value 2",
"field2" => 35
],
'3' => [
"field1" => "Value 3",
"field2" => 5
]
];
$expectedArray = [
"1" => 20,
"2" => 70,
"3" => 10,
];
$this->assertEquals($expectedArray, PMFTotalCalculation($grid, 'field2', 'percentile'));
}
/**
* This tests if the "PMFTotalCalculation" execute correctly the count
* @test
*/
public function it_must_return_the_count_of_the_method()
{
$grid = [
'1' => [
"field1" => "Value 1",
"field2" => 25
],
'2' => [
"field1" => "Value 2",
"field2" => 40
],
'3' => [
"field1" => "Value 3",
"field2" => 10
]
];
$this->assertEquals(3, PMFTotalCalculation($grid, 'field2', 'count'));
}
/**
* This tests if the "PMFTotalCalculation" execute correctly the count distinct
* @test
*/
public function it_must_return_the_count_distinct_of_the_method()
{
$grid = [
'1' => [
"field1" => "Value 1",
"field2" => 20
],
'2' => [
"field1" => "Value 2",
"field2" => 20
],
'3' => [
"field1" => "Value 3",
"field2" => 10
]
];
$this->assertEquals(2, PMFTotalCalculation($grid, 'field2', 'countDistinct'));
}
}

39
tests/unit/workflow/engine/src/ProcessMaker/BusinessModel/VariableTest.php
View File

@@ -188,4 +188,43 @@ class VariableTest extends TestCase
$this->assertArrayHasKey('var_accepted_values', $res, "The result does not contains 'var_accepted_values' as key"); $this->assertArrayHasKey('var_accepted_values', $res, "The result does not contains 'var_accepted_values' as key");
$this->assertArrayHasKey('inp_doc_uid', $res, "The result does not contains 'inp_doc_uid' as key"); $this->assertArrayHasKey('inp_doc_uid', $res, "The result does not contains 'inp_doc_uid' as key");
} }
/**
* Test it return the variables by type related to the PRO_UID
*
* @covers \ProcessMaker\BusinessModel\Variable::getVariablesByType()
* @test
*/
public function it_list_variables_by_type_related_a_process()
{
$process = factory(Process::class)->create();
$varType = 'integer';
$varTypeId = 2;
for ($x = 1; $x <= 5; $x++) {
$processVar = factory(ProcessVariables::class)->states('foreign_keys')->create([
'PRO_ID' => $process->PRO_ID,
'PRJ_UID' => $process->PRO_UID,
'VAR_FIELD_TYPE' => $varType,
'VAR_FIELD_TYPE_ID' => $varTypeId,
'VAR_NAME' => 'varTestName' . $x,
]);
}
$variable = new Variable();
// Get all results
$res = $variable->getVariablesByType($process->PRO_UID, 2);
$this->assertEquals(5, count($res));
$res = head($res);
$this->assertArrayHasKey('value', $res, "The result does not contains 'value' as key");
// Get a specific start and limit
$res = $variable->getVariablesByType($process->PRO_UID, 2, 0, 2);
$this->assertNotEmpty($res);
$this->assertEquals(2, count($res));
// Get a specific search
$res = $variable->getVariablesByType($process->PRO_UID, 2, 0, 4, 'varTest');
$this->assertNotEmpty($res);
$this->assertEquals(4, count($res));
// When the search does not match
$res = $variable->getVariablesByType($process->PRO_UID, 2, null, null, 'other');
$this->assertEmpty($res);
}
} }

37
tests/unit/workflow/engine/src/ProcessMaker/Model/ProcessVariablesTest.php
View File

@@ -70,4 +70,41 @@ class ProcessVariablesTest extends TestCase
$result = ProcessVariables::getVariables($process->PRO_ID); $result = ProcessVariables::getVariables($process->PRO_ID);
$this->assertNotEmpty($result); $this->assertNotEmpty($result);
} }
/**
* Test it return the variables by type related to the PRO_ID
*
* @covers \ProcessMaker\Model\ProcessVariables::getVariablesByType()
* @test
*/
public function it_list_variables_type_by_process()
{
$process = factory(Process::class)->create();
$varType = 'integer';
$varTypeId = 2;
for ($x = 1; $x <= 5; $x++) {
$processVar = factory(ProcessVariables::class)->states('foreign_keys')->create([
'PRO_ID' => $process->PRO_ID,
'PRJ_UID' => $process->PRO_UID,
'VAR_FIELD_TYPE' => $varType,
'VAR_FIELD_TYPE_ID' => $varTypeId,
'VAR_NAME' => 'varTestName' . $x,
]);
}
$res = ProcessVariables::getVariablesByType($processVar->PRO_ID, 2, null, null, null);
$this->assertNotEmpty($res);
$this->assertEquals(5, count($res));
// Get a specific start and limit
$res = ProcessVariables::getVariablesByType($process->PRO_ID, 2, 0, 2);
$this->assertNotEmpty($res);
$this->assertEquals(2, count($res));
// Get a specific search
$res = ProcessVariables::getVariablesByType($process->PRO_ID, 2, 0, 4, 'varTest');
$this->assertNotEmpty($res);
$this->assertEquals(4, count($res));
// When the search does not match
$res = ProcessVariables::getVariablesByType($process->PRO_ID, 2, null, null, 'other');
$this->assertEmpty($res);
}
} }

41
workflow/engine/classes/PmDynaform.php
View File

@@ -29,6 +29,7 @@ class PmDynaform
public $lang = SYS_LANG; public $lang = SYS_LANG;
public $translations = null; public $translations = null;
public $onPropertyRead = "onPropertyReadFormInstance"; public $onPropertyRead = "onPropertyReadFormInstance";
public $onAfterPropertyRead = "onAfterPropertyReadFormInstance";
public $pathRTLCss = ''; public $pathRTLCss = '';
public $record = null; public $record = null;
public $records = null; public $records = null;
@@ -545,6 +546,7 @@ class PmDynaform
if (isset($this->fields["APP_DATA"][$json->name . "_label"])) { if (isset($this->fields["APP_DATA"][$json->name . "_label"])) {
$json->data->label = $this->fields["APP_DATA"][$json->name . "_label"]; $json->data->label = $this->fields["APP_DATA"][$json->name . "_label"];
} }
$this->setDependentOptionsForDatetime($json, $this->fields);
} }
if ($key === "type" && ($value === "file") && isset($this->fields["APP_DATA"]["APPLICATION"])) { if ($key === "type" && ($value === "file") && isset($this->fields["APP_DATA"]["APPLICATION"])) {
$oCriteriaAppDocument = new Criteria("workflow"); $oCriteriaAppDocument = new Criteria("workflow");
@@ -771,6 +773,11 @@ class PmDynaform
} }
} }
} }
//read event after
$fn = $this->onAfterPropertyRead;
if (is_callable($fn) || function_exists($fn)) {
$fn($json, $key, $value);
}
} }
} }
} }
@@ -2489,4 +2496,38 @@ class PmDynaform
$json->dataSchema[$key] = $columnsData; $json->dataSchema[$key] = $columnsData;
} }
} }
/**
* Sets the dependentOptions property for datetime control, if it contains dependent fields.
* @param stdClass $json
* @param array $fields
* @return void
*/
private function setDependentOptionsForDatetime(stdClass &$json, array $fields = []): void
{
if (!isset($json->type)) {
return;
}
if ($json->type !== 'datetime') {
return;
}
$json->dependentOptions = '';
$backup = $this->onAfterPropertyRead;
$properties = [
'defaultDate' => $json->defaultDate,
'minDate' => $json->minDate,
'maxDate' => $json->maxDate
];
$this->onAfterPropertyRead = function(stdClass &$json, $key, $value) use($backup, $properties) {
if (isset($json->type) && $json->type === 'datetime' && $key === "dependentOptions") {
$json->dependentOptions = new stdClass();
foreach ($properties as $property => $value) {
if (is_string($value) && in_array(substr($value, 0, 2), self::$prefixs)) {
$json->dependentOptions->{$property} = $value;
}
}
$this->onAfterPropertyRead = $backup;
}
};
}
} }

117
workflow/engine/classes/class.pmFunctions.php
View File

@@ -459,6 +459,123 @@ function evaluateFunction($aGrid, $sExpresion)
return $aGrid; return $aGrid;
} }
/**
*
* @method
*
* Executes operations in the grid fields, such as sum, average, median, minimum, maximun,
* stantard deviation, variance, percentile, count, count distinct
*
* @name PMFTotalCalculation
* @label PMFTotalCalculation Function
* @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFTotalCalculation.28.29
* @param array | $grid | Grid | The input grid.
* @param string (32) | $field | Name of field | The name of the field.
* @param string (32) | $function | Operation.
* @return int|float|array | $result | Result | Result according of the function
*
*/
function PMFTotalCalculation($grid, $field, $function)
{
$systemConfiguration = Bootstrap::getSystemConfiguration();
$floatPointNumber = $systemConfiguration['PMFTOTALCALCULATION_FLOATING_POINT_NUMBER'];
$function = strtolower($function);
$totalRows = count($grid);
$result = 0;
$sum = 0;
switch ($function) {
case "sum":
for ($i = 1; $i <= $totalRows; $i += 1) {
$result += $grid[$i][$field];
}
break;
case "average":
for ($i = 1; $i <= $totalRows; $i += 1) {
$result += $grid[$i][$field];
}
$result = $result / $totalRows;
break;
case "median":
$arrayAux = [];
for ($i = 1; $i <= $totalRows; $i += 1) {
$arrayAux[] = $grid[$i][$field];
}
sort($arrayAux);
$term = ($totalRows + 1) / 2;
if ($totalRows % 2 === 0) {
$term = floor($term);
$result = ($arrayAux[$term - 1] + $arrayAux[$term]) / 2;
} else {
$result = $arrayAux[$term - 1];
}
break;
case "minimum":
$result = $grid[1][$field];
for ($i = 2; $i <= $totalRows; $i += 1) {
if ($grid[$i][$field] < $result) {
$result = $grid[$i][$field];
}
}
break;
case "maximum":
$result = $grid[1][$field];
for ($i = 2; $i <= $totalRows; $i += 1) {
if ($grid[$i][$field] > $result) {
$result = $grid[$i][$field];
}
}
break;
case "standarddeviation":
$mean = 0;
for ($i = 1; $i <= $totalRows; $i += 1) {
$mean += $grid[$i][$field];
}
$mean = $mean / $totalRows;
for ($i = 1; $i <= $totalRows; $i += 1) {
$result += pow($grid[$i][$field] - $mean, 2);
}
$result = sqrt($result / $totalRows);
break;
case "variance":
$mean = 0;
for ($i = 1; $i <= $totalRows; $i += 1) {
$mean += $grid[$i][$field];
}
$mean = $mean / $totalRows;
for ($i = 1; $i <= $totalRows; $i += 1) {
$result += pow($grid[$i][$field] - $mean, 2);
}
$result = $result / $totalRows;
break;
case "percentile":
$result = [];
$arrayAux = [];
for ($i = 1; $i <= $totalRows; $i += 1) {
$sum += $grid[$i][$field];
$arrayAux[$i] = $grid[$i][$field];
}
for ($i = 1; $i <= count($arrayAux); $i += 1) {
$result[$i] = round(($arrayAux[$i] * 100) / $sum, $floatPointNumber);
}
break;
case "count":
$result = $totalRows;
break;
case "countdistinct":
$arrayAux = [];
for ($i = 1; $i <= $totalRows; $i += 1) {
$arrayAux[] = $grid[$i][$field];
}
$result = count(array_count_values($arrayAux));
break;
}
if ($function !== "percentile") {
return round($result, $floatPointNumber);
}
return $result;
}
/** /**
* Web Services Functions * * Web Services Functions *
*/ */

4
workflow/engine/src/ProcessMaker/BusinessModel/DynaForm.php
View File

@@ -1178,7 +1178,9 @@ class DynaForm
} }
foreach ($oldColumns as $oldColumn) { foreach ($oldColumns as $oldColumn) {
if (strtolower(AdditionalTables::getPHPName($column->id)) === strtolower(AdditionalTables::getPHPName($oldColumn->id))) { if (strtolower(AdditionalTables::getPHPName($column->id)) === strtolower(AdditionalTables::getPHPName($oldColumn->id))) {
$identicals[] = "'" . $column->id . "' - '" . $oldColumn->id . "'"; if (strtolower(AdditionalTables::getPHPName($column->var_name)) === strtolower(AdditionalTables::getPHPName($oldColumn->var_name))) {
$identicals[] = "'" . $column->id . "' - '" . $oldColumn->id . "'";
}
} }
} }
} }

37
workflow/engine/src/ProcessMaker/BusinessModel/Variable.php
View File

@@ -26,6 +26,16 @@ class Variable
'object' => 10 'object' => 10
]; ];
/**
* Get the variables types accepted
*
* @return array
*/
public function getVariableTypes()
{
return $this->variableTypes;
}
/** /**
* Create Variable for a Process * Create Variable for a Process
* *
@@ -355,6 +365,33 @@ class Variable
return $arrayVariables; return $arrayVariables;
} }
/**
* Get data of Variables related to the specific type
*
* @param string $processUid Unique id of Process
* @param int $typeVarId
* @param int $start
* @param int $limit
* @param string $search
* @param string $prefix
*
* @return array, return an array with varaibles filter by type
*/
public function getVariablesByType($processUid, $typeVarId = 0, $start = null, $limit = null, $search = null, $prefix = null)
{
//Verify data
$proId = Validator::proUid($processUid, '$prj_uid');
$variables = ProcessVariables::getVariablesByType($proId, $typeVarId, $start, $limit, $search);
$arrayVariables = [];
foreach ($variables as $var) {
$arrayVariables[] = [
'value' => is_null($prefix) ? $var['VAR_NAME'] : $prefix . $var['VAR_NAME'],
];
}
return $arrayVariables;
}
/** /**
* Verify field definition * Verify field definition
* *

3
workflow/engine/src/ProcessMaker/Core/System.php
View File

@@ -77,7 +77,8 @@ class System
'highlight_home_folder_enable' => 0, 'highlight_home_folder_enable' => 0,
'highlight_home_folder_refresh_time' => 10, 'highlight_home_folder_refresh_time' => 10,
'highlight_home_folder_scope' => 'unassigned', // For now only this list is supported 'highlight_home_folder_scope' => 'unassigned', // For now only this list is supported
'disable_advanced_search_case_title_fulltext' => 0 'disable_advanced_search_case_title_fulltext' => 0,
'PMFTOTALCALCULATION_FLOATING_POINT_NUMBER' => 10
]; ];
/** /**

57
workflow/engine/src/ProcessMaker/Model/ProcessVariables.php
View File

@@ -72,8 +72,21 @@ class ProcessVariables extends Model
*/ */
public function scopeProcessId($query, int $proId) public function scopeProcessId($query, int $proId)
{ {
return $query->where('PRO_ID', $proId); return $query->where('PROCESS_VARIABLES.PRO_ID', $proId);
} }
/**
* Scope a query to filter a specific type for variable
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param int $typeId
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeTypeId($query, int $typeId)
{
return $query->where('VAR_FIELD_TYPE_ID', $typeId);
}
/** /**
* Return the variables list * Return the variables list
* *
@@ -96,4 +109,46 @@ class ProcessVariables extends Model
return $variablesList; return $variablesList;
} }
/**
* Return the variables list
*
* @param int $proId
* @param int $typeId
* @param int $start
* @param int $limit
* @param string $search
*
* @return array
*/
public static function getVariablesByType(int $proId, int $typeId = 0, $start = null, $limit = null, $search = null)
{
$query = ProcessVariables::query()->select();
$query->leftJoin('DB_SOURCE', function ($join) {
$join->on('DB_SOURCE.PRO_ID', '=', 'PROCESS_VARIABLES.PRO_ID');
});
$query->processId($proId);
// Check if we need to filter the type of variables
if ($typeId > 0) {
$query->typeId($typeId);
}
// search a specific variable name
if (!empty($search)) {
$query->where('VAR_NAME', 'LIKE', "${search}%");
}
// order by varNane
$query->orderBy('VAR_NAME', 'ASC');
// Check if we need to add a pagination
if(!is_null($start) && !is_null($limit)) {
$query->offset($start)->limit($limit);
}
// Get records
$results = $query->get();
$variablesList = [];
$results->each(function ($item, $key) use (&$variablesList) {
$variablesList[] = $item->toArray();
});
return $variablesList;
}
} }

45
workflow/engine/src/ProcessMaker/Services/Api/Project/Variable.php
View File

@@ -1,8 +1,12 @@
<?php <?php
namespace ProcessMaker\Services\Api\Project; namespace ProcessMaker\Services\Api\Project;
use \ProcessMaker\Services\Api; use Exception;
use \Luracast\Restler\RestException; use G;
use Luracast\Restler\RestException;
use ProcessMaker\BusinessModel\Variable as BmVariable;
use ProcessMaker\Services\Api;
/** /**
* Project\Variable Api Controller * Project\Variable Api Controller
* *
@@ -28,6 +32,43 @@ class Variable extends Api
} }
} }
/**
* Get variables by type
*
* @url GET /:prj_uid/process-variables/:typeVariable/paged
*
* @param string $prj_uid {@min 32}{@max 32}
* @param string $typeVariable {@from path}
* @param int $start {@from path}
* @param int $limit {@from path}
* @param string $search {@from path}
*/
public function doGetVariablesByType($prj_uid, $typeVariable, $start = null, $limit = null, $search = null)
{
try {
$variable = new BmVariable();
$typesAccepted = $variable::$varTypesValues;
if (!empty($typesAccepted[$typeVariable])) {
$typeVatId = $typesAccepted[$typeVariable];
} else {
throw new Exception(G::LoadTranslation("ID_INVALID_VALUE_ONLY_ACCEPTS_VALUES", ['$typeVariable', implode(',', $variable->getVariableTypes())]));
}
// Review if the word has the prefix
$count = preg_match_all('/\@(?:([\@\%\#\?\$\=\&Qq\!])|([a-zA-Z\_][\w\-\>\:]*)\(((?:[^\\\\\)]*(?:[\\\\][\w\W])?)*)\))((?:\s*\[[\'"]?\w+[\'"]?\])+|\-\>([a-zA-Z\_]\w*))?/', $search, $match, PREG_PATTERN_ORDER | PREG_OFFSET_CAPTURE);
// Check if the search has some prefix
$prefix = '';
if ($count) {
$prefix = substr($search,0,2);
$search = substr($search,2);
}
$response = $variable->getVariablesByType($prj_uid, $typeVatId, $start, $limit, $search, $prefix);
return $response;
} catch (Exception $e) {
throw (new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage()));
}
}
/** /**
* @url GET /:prj_uid/process-variable/:var_uid * @url GET /:prj_uid/process-variable/:var_uid
* *