{

use Dispatchable, InteractsWithQueue, Queueable, SerializesModels, PluginServiceProviderTrait;

/**

private $fileContents;

/**

protected $file;

/**

private $process;

/**

private $definitions;

private $assignable = [];

/**

protected $new = [];

/**

protected $status = [];

/**

private $backwardCompatiblePackageMap = [

'processmaker-communication-email-send' => 'processmaker-connector-send-email',

];

/**

public function __construct($fileContents)

{

$this->fileContents = $fileContents;

}

/**

protected function getParser()

{

$method = "parseFileV{$this->file->version}";

if (method_exists($this, $method)) {

return $method;

} else {

return false;

}

}

/**

private function currentUser()

{

if (!app()->runningInConsole()) {

return Auth::user();

} else {

return User::first();

}

}

/**

protected function formatDate($date)

{

if ($date) {

return new Carbon($date);

} else {

return null;

}

}

/**

protected function formatName($name, $field, $class)

{

//Create a new instance of this model

$model = new $class;

//Find duplicates of this item's name

$dupe = $model->where($field, 'like', $name . '%')

->orderBy(DB::raw("LENGTH($field), $field"))

->get();

//If we have duplicates...

if ($dupe->count()) {

//Get the last duplicate

$dupe = $dupe->last();

//Match the number at the end of the name

$doesMatch = preg_match('/(\d+)$/', $dupe->{$field}, $matches);

//If we have a match...

if ($doesMatch === 1) {

//Increment the number!

$number = intval($matches[1]) + 1;

} else {

//Start with 2

$number = 2;

}

//Return the name appended with the number

return $name . ' ' . $number;

} else {

//Return the original name (if there are no dupes)

return $name;

}

}

private function getElementById($id)

{

$x = new DOMXPath($this->definitions);

return $x->query("//*[@id='$id']")->item(0);

}

/**

private function parseAssignables()

{

$this->assignable = collect([]);

$this->parseAssignableStartEvent();

$this->parseAssignableTasks();

$this->parseAssignableCallActivity();

$this->parseAssignableScripts();

if (!$this->assignable->count()) {

$this->assignable = null;

}

}

/**

private function parseAssignableStartEvent()

{

$tasks = $this->definitions->getElementsByTagName('startEvent');

foreach ($tasks as $task) {

$assignment = $task->getAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'assignment');

$eventDefinition = $task->getElementsByTagName('timerEventDefinition');

if (!$assignment && $eventDefinition->count() === 0) {

$this->assignable->push((object)[

'type' => 'startEvent',

'id' => $task->getAttribute('id'),

'name' => $task->getAttribute('name'),

'prefix' => __('Assign Start Event'),

'suffix' => __('to'),

]);

}

}

}

/**

private function parseAssignableCallActivity()

{

$tasks = $this->definitions->getElementsByTagName('callActivity');

foreach ($tasks as $task) {

$assignment = $task->getAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'calledElement');

// Do not ask to assign a target if this CallActivity is a package wrapper

if ($this->isCallActivityFromPackage($task)) {

continue;

}

if (!$assignment) {

$this->assignable->push((object)[

'type' => 'callActivity',

'id' => $task->getAttribute('id'),

'name' => $task->getAttribute('name'),

'prefix' => __('Assign Call Activity'),

'suffix' => __('to'),

]);

}

}

}

/**

private function parseAssignableTasks()

{

//tasks that should always be assigned

$humanTasks = ['task', 'userTask', 'manualTask'];

foreach ($humanTasks as $humanTask) {

$tasks = $this->definitions->getElementsByTagName($humanTask);

foreach ($tasks as $task) {

$this->assignable->push((object)[

'type' => 'task',

'id' => $task->getAttribute('id'),

'name' => $task->getAttribute('name'),

'prefix' => __('Assign task'),

'suffix' => __('to'),

]);

}

}

}

/**

private function parseAssignableScripts()

{

foreach ($this->new[Script::class] as $script) {

$this->assignable->push((object)[

'type' => 'script',

'id' => $script->id,

'name' => $script->title,

'prefix' => __('Run script'),

'suffix' => __('as'),

]);

}

}

/**

private function removeAssignedEntities()

{

$humanTasks = ['task', 'userTask', 'manualTask'];

foreach ($humanTasks as $humanTask) {

$tasks = $this->definitions->getElementsByTagName($humanTask);

foreach ($tasks as $task) {

$assignment = $task->getAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'assignment');

if ($assignment == 'user' || $assignment == 'group') {

$task->removeAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'assignment');

$task->removeAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'assignedUsers');

$task->removeAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'assignedGroups');

}

}

}

}

/**

private function completeScreenRefs()

{

$humanTasks = ['task', 'userTask', 'endEvent', 'manualTask'];

foreach ($humanTasks as $humanTask) {

$tasks = $this->definitions->getElementsByTagName($humanTask);

foreach ($tasks as $task) {

$newScreenRef = $task->getAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'screenRefNew');

$task->removeAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'screenRefNew');

$task->setAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'screenRef', $newScreenRef);

}

}

}

/**

private function saveScreens($screens, $process)

{

try {

$this->new[Screen::class] = [];

$this->prepareStatus('screens', count($screens) > 0);

foreach ($screens as $screen) {

$new = $this->saveScreen($screen);

$this->new[Screen::class][$screen->id] = $new;

}

$this->finishStatus('screens');

} catch (\Exception $e) {

Log::info('*** Error: '. $e->getMessage());

$this->finishStatus('screens', true);

}

}

/**

protected function saveScreen($screen)

{

try {

$new = new Screen;

$new->computed = $screen->computed;

$new->config = $screen->config;

$new->created_at = $this->formatDate($screen->created_at);

$new->custom_css = $screen->custom_css;

$new->description = $screen->description;

$new->title = $this->formatName($screen->title, 'title', Screen::class);

$new->type = $screen->type;

$new->watchers = $this->watcherScriptsToSave($screen);

$new->save();

// save categories

if (isset($screen->categories)) {

foreach ($screen->categories as $categoryDef) {

$category = $this->saveCategory('screen', $categoryDef);

$new->categories()->save($category);

}

}

return $new;

} catch (\Exception $e) {

return false;

}

}

/**

private function updateScriptRefs($oldId, $newId)

{

$tasks = $this->definitions->getElementsByTagName('scriptTask');

foreach ($tasks as $task) {

$scriptRef = $task->getAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'scriptRef');

if ($scriptRef == $oldId) {

$task->setAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'scriptRefNew', $newId);

}

}

}

/**

private function completeScriptRefs()

{

$tasks = $this->definitions->getElementsByTagName('scriptTask');

foreach ($tasks as $task) {

$newScriptRef = $task->getAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'scriptRefNew');

$task->removeAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'scriptRefNew');

$task->setAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'scriptRef', $newScriptRef);

}

}

/**

private function saveScripts($scripts)

{

try {

$this->new[Script::class] = [];

$this->prepareStatus('scripts', count($scripts) > 0);

foreach ($scripts as $script) {

$new = $this->saveScript($script);

$this->new[Script::class][$script->id] = $new;

}

$this->finishStatus('scripts');

} catch (\Exception $e) {

$this->finishStatus('scripts', true);

}

}

/**

public function saveScript($script)

{

try {

$new = new Script;

$new->title = $this->formatName($script->title, 'title', Script::class);

$new->description = $script->description;

$new->language = $script->language;

$new->code = $script->code;

$new->created_at = $this->formatDate($script->created_at);

$new->save();

// save categories

if (isset($script->categories)) {

foreach ($script->categories as $categoryDef) {

$category = $this->saveCategory('script', $categoryDef);

$new->categories()->save($category);

}

}

return $new;

} catch (\Exception $e) {

return false;

}

}

/**

protected function saveCategory($type, $category)

{

if (!array_key_exists($type . '_categories', $this->new)) {

$this->new[$type . '_categories'] = [];

};

// use ProcessMaker\Models\ProcessCategory;

$class = '\\ProcessMaker\\Models\\' . ucfirst($type) . 'Category';

try {

$existing = $class::where('name', $category->name)->first();

$this->prepareStatus($type . '_categories', true);

if ($existing) {

$this->new[$type . '_categories'][] = $existing;

$new = $existing;

} else {

$new = new $class;

$new->name = $category->name;

$new->status = $category->status;

$new->created_at = $this->formatDate($category->created_at);

$new->save();

$this->new[$type . '_categories'][] = $new;

}

$this->finishStatus($type . '_categories');

return $new;

} catch (\Exception $e) {

$this->finishStatus($type . '_categories', true);

return null;

}

}

/**

private function saveProcess($process)

{

try {

$this->prepareStatus('process', true);

$new = new Process;

$new->process_category_id = array_shift($this->new['process_categories'])->id;

$new->user_id = $this->currentUser()->id;

$new->bpmn = $process->bpmn;

$new->description = $process->description;

$new->name = $this->formatName($process->name, 'name', Process::class);

$new->status = $process->status;

$new->created_at = $this->formatDate($process->created_at);

$new->deleted_at = $this->formatDate($process->deleted_at);

$new->save();

$new->categories()->saveMany($this->new['process_categories']);

if (property_exists($process, 'notifications')) {

foreach ($process->notifications as $notifiable => $notificationTypes) {

foreach ($notificationTypes as $notificationType => $wanted) {

if ($wanted === true) {

$newNotification = new ProcessNotificationSetting;

$newNotification->process_id = $new->id;

$newNotification->notifiable_type = $notifiable;

$newNotification->notification_type = $notificationType;

$newNotification->save();

}

}

}

}

if (property_exists($process, 'task_notifications')) {

foreach ($process->task_notifications as $elementId => $notifiables) {

foreach ($notifiables as $notifiable => $notificationTypes) {

foreach ($notificationTypes as $notificationType => $wanted) {

if ($wanted === true) {

$newNotification = new ProcessNotificationSetting;

$newNotification->process_id = $new->id;

$newNotification->element_id = $elementId;

$newNotification->notifiable_type = $notifiable;

$newNotification->notification_type = $notificationType;

$newNotification->save();

}

}

}

}

}

$this->definitions = $new->getDefinitions();

$this->new['process'] = $new;

$this->finishStatus('process');

} catch (\Exception $e) {

$this->finishStatus('process', true);

}

}

/**

private function isBackwardCompatiblePackage($package)

{

if (array_key_exists($package, $this->backwardCompatiblePackageMap)) {

return $this->isRegisteredPackage($this->backwardCompatiblePackageMap[$package]);

}

return false;

}

private function validatePackages($process)

{

try {

$response = true;

$new = new Process;

$new->bpmn = $process->bpmn;

$definitions = $new->getDefinitions();

$packages = [];

$tasks = $definitions->getElementsByTagName('serviceTask');

foreach ($tasks as $task) {

$implementation = $task->getAttribute('implementation');

if ($implementation) {

$implementation = explode('/', $implementation);

if (!in_array($implementation[0], $packages, true)) {

$packages[] = $implementation[0];

$exists = $this->isRegisteredPackage($implementation[0]);

if (!$exists) {

$exists = $this->isBackwardCompatiblePackage($implementation[0]);

}

$response = $exists === false ? false : $response;

$package = [];

$package['label'] = $implementation[0];

$package['success'] = $exists;

$package['message'] = $exists ? __('Package installed') : __('The package is not installed');

$this->status = array_merge([$implementation[0] => $package], $this->status);

}

}

}

return $response;

} catch (\Exception $e) {

return false;

}

}

/**

private function saveBpmn($process)

{

$this->new['process']->bpmn = $this->definitions->saveXML();

if (isset($process->cancel_screen_id)) {

$this->new['process']->cancel_screen_id = $process->cancel_screen_id;

}

if (isset($process->request_detail_screen_id)) {

$this->new['process']->request_detail_screen_id = $process->request_detail_screen_id;

}

$manager = app(ExportManager::class);

$manager->updateReferences($this->new);

$this->new['process']->save();

}

/**

private function parseFileV1()

{

if (!$this->validatePackages($this->file->process)) {

return (object)[

'status' => collect($this->status),

'assignable' => [],

'process' => []

];

}

if (isset($this->file->process_category)) {

$this->saveCategory('process', $this->file->process_category);

}

if (isset($this->file->process_categories)) {

foreach($this->file->process_categories as $category) {

$this->saveCategory('process', $category);

}

}

$this->saveProcess($this->file->process);

$this->saveScripts($this->file->scripts);

$this->saveScreens($this->file->screens, $this->file->process);

$this->parseAssignables();

$this->saveBpmn($this->file->process);

return (object)[

'status' => collect($this->status),

'assignable' => $this->assignable,

'process' => $this->new['process']

];

}

/**

protected function decodeFile()

{

if (substr($this->fileContents, 0, 1) === '{' && !!json_decode($this->fileContents)) {

$this->file = json_decode($this->fileContents);

} else {

$this->file = base64_decode($this->fileContents);

$this->file = json_decode($this->file);

}

}

/**

public function handle()

{

//First, decode the file

$this->decodeFile();

//Then, process it based on version number

if ($this->file->type == 'process_package') {

if ($method = $this->getParser()) {

$this->resetStatus();

return $this->{$method}();

}

}

//Return false by default

return false;

}

/**

protected function resetStatus()

{

$this->status = [];

$this->status['process_categories'] = [

'label' => __('Process Categories'),

'success' => false,

'message' => __('Starting')];

$this->status['process'] = [

'label' => __('Process'),

'success' => false,

'message' => __('Starting')];

$this->status['scripts'] = [

'label' => __('Scripts'),

'success' => false,

'message' => __('Starting')];

$this->status['screens'] = [

'label' => __('Screens'),

'success' => false,

'message' => __('Starting')];

}

/**

protected function prepareStatus($element, $data = false)

{

$this->status[$element]['message'] = __('Started import of');

if ($data) {

$this->status[$element]['message'] = __('Incomplete import of');

}

}

/**

protected function finishStatus($element, $error = false)

{

$this->status[$element]['success'] = true;

$this->status[$element]['message'] = __('Successfully imported');

if ($error) {

$this->status[$element]['success'] = false;

$this->status[$element]['message'] = __('Unable to import');

}

}

/**

protected function watcherScriptsToSave($screen)

{

if (empty($screen->watchers)) {

return null;

}

$watcherList =[];

foreach($screen->watchers as $watcher) {

$script = $watcher->script;

$watcher->script_id = $script->id;

$watcher->script->title = $script->title;

$watcherList[] = $watcher;

}

return $watcherList;

}

/**

private function isCallActivityFromPackage($task)

{

$configString = $task->getAttributeNS(WorkflowServiceProvider::PROCESS_MAKER_NS, 'config');

$config = json_decode($configString, true);

if (isset($config['calledElement'])) {

// calledElement only exists on call activities, not packages

return false;

}

return true;

}