Subversion Repositories bacoAlunos

<%@ taglib uri="/WEB-INF/tlds/struts-html.tld" prefix="html" %>

<%@ taglib uri="/WEB-INF/tlds/struts-nested.tld" prefix="nested" %>

<%@ taglib uri="/WEB-INF/tlds/struts-logic.tld" prefix="logic" %>

<%@ taglib uri="/WEB-INF/tlds/struts-bean.tld" prefix="bean" %>

<%@ taglib uri="/WEB-INF/tlds/struts-tiles.tld" prefix="tiles" %>

<%@ taglib uri="/WEB-INF/tlds/baco.tld" prefix="baco" %>

<%@ taglib uri="/WEB-INF/tlds/jomm.tld" prefix="jomm" %>

<%@ page import="jomm.dao.impl.AbstractDao" %>

<%@ page import="pt.estgp.estgweb.domain.*" %>

<%@ page import="pt.estgp.estgweb.domain.bpmn.*" %>

<%@ page import="pt.estgp.estgweb.domain.dao.DaoFactory" %>

<%@ page import="pt.estgp.estgweb.web.filters.UserRoleProxy" %>

<%@ page import="pt.estgp.estgweb.domain.bpmn.utils.TaskConstantVariablesUtils" %>

<%@ page import="pt.estgp.estgweb.domain.bpmn.utils.VariableTypeUtils" %>

<%@ page import="pt.estgp.estgweb.domain.typesgen.Todos" %>

<%@ page import="pt.estgp.estgweb.domain.typesgen.Argument" %>

<%@ page import="pt.estgp.estgweb.domain.typesgen.ConnectorSoa" %>

<%@ page import="pt.estgp.estgweb.domain.typesgen.OperationMethodCall" %>

<%@ taglib tagdir="/WEB-INF/tags" prefix="bacoTags" %>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%

    Long processId = Long.parseLong(request.getParameter("id"));

    AbstractDao.getCurrentSession().beginTransaction();

    BpmnProcessImpl process = (BpmnProcessImpl) DaoFactory.getBpmnProcessDaoImpl().get(processId);

%>

<style>

    div.dirty

    {

        border: 3px dashed orangered !important;

    }

</style>

<link rel="stylesheet" href="<%=request.getContextPath()%>/js/angularjs/angular-ui-tree/angular-ui-tree.min.css">

<script type="text/javascript" src="<%=request.getContextPath()%>/js/angularjs/angular-ui-tree/angular-ui-tree.js"></script>

<div class="container-fluid"

     id="processEditorModule"

     ng-app="processEditorModule"

     ng-controller="processEditorModuleController"

     ng-init="initBuilder()">

<style>

    .has-error .chosen-container

    {

        border: 1px solid #a94442 !important;

    }

</style>

<script>

//DECLARACAO DA APLICACAO LOCAL EM ANGULAR

var processEditorModule = angular.module('processEditorModule', ['ui.tree']);

GLOBAL_BacoAngularAppDependencies.push('processEditorModule');

/**Fim de directiva reutilizavel**/

processEditorModule.controller('processEditorModuleController', function($scope,$interval,$filter)

{

    $scope.callServiceSync = function(service,parameters,callback)

    {

        widgetCallWithActionParameters(

                "<%=request.getContextPath()%>/admin/bpmn/bpmnController.do",

                service,

                parameters,

                "#processEditorModule",

                function(jsonAnswer)

                {

                    callback(jsonAnswer);

                    $scope.$apply();

                }

        );

    }

    $scope.callService = function(service,parameters,callback)

    {

        widgetCallWithActionParameters(

                "<%=request.getContextPath()%>/admin/bpmn/bpmnController.do",

                service,

                parameters,

                "#processEditorModule",

                function(jsonAnswer)

                {

                    callback(jsonAnswer);

                    $scope.$apply();

                }

        );

    }

    $scope.callSimpleService = function(service,parameters,callback)

    {

        widgetSimpleCallWithActionParameters(

                "<%=request.getContextPath()%>/admin/bpmn/bpmnController.do",

                service,

                parameters,

                "#processEditorModule",

                function()

                {

                    callback();

                    $scope.$apply();

                }

        );

    }

    /*

    * Variaveis e metodos auxiliares

    * */

    $scope.allFlowComponents = [];

    $scope.autoSavesObjects = [];

    $scope.idTemp = -1;

    $scope.jsps = [];

    $scope.newSoa = {};

    $scope.servicesSoa = []; //Tem Servicos e metodos os metodos sao apanhados do servico selecionado, quando muda o serviço os metodos mudam automaticamente, como o existente antigo não faz match com os do selecionado lodo chama o setNewArguments que opera sobre um metodo que nao faz match logo não há argumentos e ficam vazi-os

    $scope.newMethodCall = {}; //Uma so classe escolhida em vez de um array como nos servicos

    $scope.methodsClassSelected = []; //Os metodos sao apanhados em tempo real e tem de estar aqui

    //TEM APENAS AS NORMAIS CONSTANTES

    $scope.constantVariables = <%=TaskConstantVariablesUtils.obtainConstantBpmnVariablesRegularTask().toString()%>

    //TEM TODAS, AS NORMAIS E AS DE TAREFA ATOR

    $scope.constantVariablesActorTask = <%=TaskConstantVariablesUtils.obtainConstantBpmnVariablesActorTask().toString()%>;

    $scope.processVariableTypes = <%=VariableTypeUtils.obtainProcessSerializableVariableTypes().toString()%>;

    $scope.localVariableTypes = <%=VariableTypeUtils.obtainAllVariableTypes().toString()%>;

    $scope.initBuilder = function()

    {

        $scope.initServicesSoa();

        $scope.initJsps();

        $scope.inicializarSaves();

        $scope.copiaFlowComponentsDasActorPools();

        setTimeout(function() { $(".angularChosen").chosen(); }, 500);

    }

    $scope.initJsps = function()

    {

        $scope.callService("loadJspsPlugins",{},function(interfaces)

        {

            $scope.jsps = interfaces.jsps;

            $scope.$apply();

        });

    }

    $scope.initServicesSoa = function()

    {

        $scope.callService("loadServicesSoa",{},function(servicesSoa)

        {

            $scope.servicesSoa = servicesSoa.services;

            $scope.$apply();

        });

    }

    $scope.showMethodSign = function(method)

    {

        return method.name + " => " + method.simpleReturnType;

    }

    $scope.inicializarSaves = function()

    {

        $interval($scope.autoSaves,2000);

    }

    $scope.copiaFlowComponentsDasActorPools = function()

    {

        for(x in $scope.process.actorPools)

        {

            var pool = $scope.process.actorPools[x];

            for(y in pool.flowComponents)

            {

                var flowComponent = pool.flowComponents[y];

                $scope.allFlowComponents.push(flowComponent);

            }

        }

    }

    $scope.autoSaves = function()

    {

        for(var v in $scope.process.processVariables)

        {

            var variable = $scope.process.processVariables[v];

            if(variable.dirty == true)

            {

                var variableCall = variable;

                $scope.callSimpleService("updateVariable",{"object":BacoJS.stringifyOrdered(variableCall)},function()

                {

                    variableCall.dirty = false;

                    $scope.$apply();

                });

            }

        }

        for(var x in $scope.process.actorPools)

        {

            var pool = $scope.process.actorPools[x];

            if(pool.dirty == true)

            {

                var poolCall = pool;

                $scope.callSimpleService("updatePool",{"object":BacoJS.stringifyOrdered(pool)},function()

                {

                    poolCall.dirty = false;

                    //alert("Apagando dirty");

                    $scope.$apply();

                });

            }

            for(var y in pool.flowComponents)

            {

                var flowComponent = pool.flowComponents[y];

                if(flowComponent.dirty == true)

                {

                    //flowComponent.dirty = false;

                    //todo if para ver se é task pode ser gateway ou event

                    //so estou a meter as tasks nos flow components não estou a meter os gateways nem os eventos

                    var flowComponentCall = flowComponent;

                    $scope.callSimpleService("updateTask",{"object":BacoJS.stringifyOrdered(flowComponent)},function()

                    {

                        flowComponentCall.dirty = false;

                        //alert("Apagando dirty");

                        $scope.$apply();

                    });

                }

                for(var z in flowComponent.flowConnectors)

                {

                    var flowConnector = flowComponent.flowConnectors[z];

                    if(flowConnector.dirty == true)

                    {

                        var flowConnectorCall = flowConnector;

                        $scope.callSimpleService("updateConnector",{"object":BacoJS.stringifyOrdered(flowConnector)},function()

                        {

                            flowConnectorCall.dirty = false;

                            $scope.$apply();

                        });

                    }

                }

                for(var v in flowComponent.localVariables)

                {

                    var variable = flowComponent.localVariables[v];

                    if(variable.dirty == true)

                    {

                        var variableCall = variable;

                        $scope.callSimpleService("updateVariable",{"object":BacoJS.stringifyOrdered(variableCall)},function()

                        {

                            variableCall.dirty = false;

                            $scope.$apply();

                        });

                    }

                }

            }

        }

        for(var x in $scope.process.actorPools)

        {

            var obj = $scope.process.actorPools[x];

            if(obj.dirty == true)

            {

            }

        }

    }

    /** Funções que interagem com directiva reutilizavel **/

    $scope.save = function() {

        $scope.$broadcast('show-errors-check-validity');

        if (!$scope.processoForm.$invalid) {

            alert('User saved');

            //$scope.reset();

        }

        else

        {

            alert("Existem erros no form");

        }

    };

    $scope.reset = function() {

        $scope.$broadcast('show-errors-reset');

        $scope.user = { name: '', email: '' };

    }

    /** Fim de Funções que interagem com directiva reutilizavel **/

    /*

    * Funcoes e variaveis especificas do Processo

    *

    * */

    $scope.process = <%=process.toJson()%>;

    $scope.removeActorPool = function(poolId,$index)

    {

        var pool = $filter('filter')($scope.process.actorPools, {id: poolId })[0];

        if(pool.flowComponents && pool.flowComponents.length > 0)

        {

            alert("Não pode apagar esta pool com atividades no seu interior");

        }

        else

        {

            $scope.callSimpleService("removeActorPool",{"poolId":pool.id},function()

            {

                $scope.process.actorPools.splice($index,1);

            });

        }

    }

    $scope.removeTask = function (poolId,taskId,$index)

    {

        $scope.callSimpleService("removeTask",{"poolId":poolId,"taskId":taskId},function()

        {

            var pool = $filter('filter')($scope.process.actorPools, {id: poolId })[0];

            pool.flowComponents.splice($index,1);

            var taskInAllFlows = $filter('filter')($scope.allFlowComponents, {id: taskId })[0];

            var index = $scope.allFlowComponents.indexOf(taskInAllFlows );

            $scope.allFlowComponents.splice(index,1);

        });

    }

    $scope.removeConnector = function (connectorId,taskId,poolId,$index)

    {

        $scope.callSimpleService("removeConnector",{"taskId":taskId,"connectorId":connectorId},function()

        {

            var pool = $filter('filter')($scope.process.actorPools, {id: poolId })[0];

            var task = $filter('filter')(pool.flowComponents, {id: taskId })[0];

            task.flowConnectors.splice($index,1);

        });

    }

    $scope.setDirty = function(obj)

    {

        obj.dirty = true;

        $scope.autoSavesObjects.push(obj);

    }

    $scope.selected = null;

    $scope.select = function(node)

    {

        if($scope.selected)

        {

            delete $scope.selected.selected;

        }

        $scope.selected = node;

        node.selected = true;

    }

    $scope.startTooltips = function()

    {

        $("[data-toggle='tooltip']").tooltip();

    }

    $scope.newActorPool = function()

    {

        $scope.callService("addActorPool",{"processId":$scope.process.id},function(actorPool)

        {

            if($scope.process.actorPools == null)

                $scope.process.actorPools = [];

            $scope.process.actorPools.push(actorPool);

            $scope.$apply();

            invokeChosenSelects("#bpmnPools");

        });

    }

    $scope.addTaskActor = function(pool)

    {

        $scope.callService("addTaskActor",{"poolId":pool.id},function(taskActor)

        {

            if(pool.flowComponents == null)

                pool.flowComponents = [];

            pool.flowComponents.push(taskActor);

            $scope.allFlowComponents.push(taskActor);

            $scope.$apply();

            //invokeChosenSelects("#bpmnPools");

        });

    }

    $scope.addConnector = function(task)

    {

        $scope.callService("addConnector",{"taskId":task.id},function(connector)

        {

            //connector = orderKeys(connector);

            if(task.flowConnectors == null)

                task.flowConnectors = [];

            task.flowConnectors.push(connector);

            $scope.$apply();

            //invokeChosenSelects("#bpmnPools");

        });

    }

    /**

     *

     *

     *

     * OPERACOES PARA MODAL PARA CRIAR/EDITAR TODOS

     * Operacoes Comuns a Operações Todos

     *

     *

     *

     * *******/

    $scope.createNewTodo = function(a_class)

    {

        var methodCallTarget =

        {

            "@class": a_class

        };

        $scope.newMethodCallTarget = methodCallTarget;

        if(!$scope.selected.todos)

            $scope.selected.todos = {

                "@class": "<%=Todos.class.getName()%>"

            };

        if(!$scope.selected.todos.todos)

            $scope.selected.todos.todos = [];

        $scope.selected.todos.todos.push(methodCallTarget);

        return methodCallTarget;

    }

    $scope.createNewTodoAtor = function(a_class){

        var methodCallTarget =

        {

            "@class": a_class

        };

        if(!$scope.selected.afterUserTodos)

            $scope.selected.afterUserTodos =

            {

                "@class": "<%=Todos.class.getName()%>"

            };

        if(!$scope.selected.afterUserTodos.todos)

            $scope.selected.afterUserTodos.todos = [];

        $scope.selected.afterUserTodos.todos.push(methodCallTarget);

        return methodCallTarget;

    }

    /**

     * Recebe uma Operação de chamada de metodo ou soa previamente selecionada

     * e coloca na variavel auxiliar methodChoosed o método que estava escolhido

     * a partir da lista de metodos disponiveis no servico/classe selecionada

     */

    $scope.prepareTodoToEdit = function(selectedTodo,methods)

    {

        for(var m in methods)

        {

            var method = methods[m];

            if(method.name == selectedTodo.methodName &&

                    method.returnType == selectedTodo.checkReturnType)

            {

                var hasMethodArguments = method.arguments && method.arguments.length > 0;

                var hasSoaMethodArguments =  selectedTodo.arguments &&  selectedTodo.arguments.length > 0;

                if(!hasMethodArguments && !hasSoaMethodArguments)

                {

                    selectedTodo.methodChoosed = method;

                    break;

                }

                else if(hasMethodArguments != hasSoaMethodArguments)

                {

                    continue;

                }

                else if(selectedTodo.arguments.length != method.arguments.length)

                {

                    continue;

                }

                else

                {

                    //Methods are equal in arguments

                    var found = true;

                    for(var a in method.arguments)

                    {

                        var argumentMethod = method.arguments[a].className;

                        var soaArgument = selectedTodo.arguments[a].className;

                        if(argumentMethod != soaArgument)

                        {

                            found = false;

                            break;

                        }

                    }

                    if(found)

                    {

                        selectedTodo.methodChoosed = method;

                        break;

                    }

                }

            }

        }

    }

    $scope.salvarTodoEdit = function(modalId)

    {

        var modal = $("#" + modalId);

        var task = $scope.selected;

        $scope.setDirty(task);

        modal.modal("hide");

    }

     /**

     *

     *

     * OPERACOES PARA MODAL DE CHAMADA DE METODO SOBRE VARIAVEL

     *

     *

     * **/

    /* chamadas para abrir modal*/

    $scope.openMethodCallModal = function(methodCallTarget)

    {

        if(!methodCallTarget)

        {

            methodCallTarget = $scope.createNewTodo("<%=OperationMethodCall.class.getName()%>");

            $scope.newMethodCall = methodCallTarget;

            methodCallTarget.usaDadosAtorDoFormulario = false;

            $("#methodCallModalSelector").modal("show");

        }

        else

        {

            $scope.newMethodCall = methodCallTarget;

            $scope.callService("loadClassMethods",

                    { "className" : methodCallTarget.className},

                    function(classDescription){

                        $scope.methodsClassSelected = classDescription.methods;

                        $scope.prepareTodoToEdit(methodCallTarget,classDescription.methods);

                        methodCallTarget.usaDadosAtorDoFormulario = false;

                        $("#methodCallModalSelector").modal("show");

                    });

        }

    }

    $scope.openMethodCallModalAtor = function(methodCallTarget)

    {

        if(!methodCallTarget)

        {

            methodCallTarget = $scope.createNewTodoAtor("<%=OperationMethodCall.class.getName()%>");

            $scope.newMethodCall = methodCallTarget;

            methodCallTarget.usaDadosAtorDoFormulario = true;

            $("#methodCallModalSelector").modal("show");

        }

        else

        {

            $scope.newMethodCall = methodCallTarget;

            $scope.callService("loadClassMethods",

                    { "className" : methodCallTarget.className},

                    function(classDescription){

                        $scope.methodsClassSelected = classDescription.methods;

                        $scope.prepareTodoToEdit(methodCallTarget,classDescription.methods);

                        methodCallTarget.usaDadosAtorDoFormulario = true;

                        $("#methodCallModalSelector").modal("show");

                    });

        }

    }

    /**

     * Chamada do ng-change da combo da classe da variavel escolhida

     * O ciclo repeat da modal de metodos difere do ciclo da dos soa

     * porque irá fazer as options dos metodos com base directa nos

     * methodsClassSelected.methods em vez de os obter desta função

     * que foi feita a partir do $scope.getServiceMethods

     * */

    $scope.changeMethodClassTarget = function()

    {

        var varSelected = $filter('filter')($scope.getAllVariables(), {"name": $scope.newMethodCall.name },true)[0];

        $scope.methodsClassSelected = [];

        $scope.newMethodCall.className = varSelected.type.className;

        $scope.newMethodCall.methodName = "";

        $scope.callService("loadClassMethods",

                { "className" : $scope.newMethodCall.className},

                function(classDescription){

                    $scope.methodsClassSelected = classDescription.methods;

                    //$scope.prepareTodoToEdit(classDescription,classDescription.methods);

                    //methodCallTarget.usaDadosAtorDoFormulario = true;

                    //$("#methodCallModalSelector").modal("show");

                });

    }

    /**

     * chamada de mudanca de metodo

     */

    $scope.setArgumentsNewMethodCallMethod = function()

    {

        var method = $scope.newMethodCall.methodChoosed;

        var arguments = [];

        for(var a in method.arguments)

        {

            var newArgument =

                    {

                        "@class" : "<%=Argument.class.getName()%>",

                        "name" : method.arguments[a].name,

                        "varName" : "",

                        "className" : method.arguments[a].className

                    };

            if( method.arguments[a].classNameSuperClasses)

                newArgument.classNameSuperClasses = method.arguments[a].classNameSuperClasses;

            arguments.push(newArgument);

        }

        $scope.newMethodCall.methodName = method.name;

        $scope.newMethodCall.arguments = arguments;

        $scope.newMethodCall.checkReturnType = method.returnType;

        if(method.returnTypeSuperClasses)

            $scope.newMethodCall.checkReturnTypeSuperClasses = method.returnTypeSuperClasses;

    }

    /**

     *

     *

     * OPERACOES PARA MODAL DE CONNECTOR SOA

     *

     *

     * **/

    $scope.openSoaModal = function(soaTarget)

    {

        if(!soaTarget)

        {

            soaTarget = $scope.createNewTodo("<%=ConnectorSoa.class.getName()%>");

            $scope.newSoa = soaTarget;

        }

        else

        {

            $scope.newSoa = soaTarget;

            $scope.prepareTodoToEdit(soaTarget,$scope.getServiceMethods(soaTarget.className));

        }

        soaTarget.usaDadosAtorDoFormulario = false;

        $("#soaModalSelector").modal("show");

    }

    $scope.openSoaModalAtor = function(soaTarget)

    {

        if(!soaTarget)

        {

            soaTarget = $scope.createNewTodoAtor("<%=ConnectorSoa.class.getName()%>");

            $scope.newSoa = soaTarget;

        }

        else

        {

            $scope.newSoa = soaTarget;

            $scope.prepareTodoToEdit(soaTarget,$scope.getServiceMethods(soaTarget.className));

        }

        soaTarget.usaDadosAtorDoFormulario = true;

        $("#soaModalSelector").modal("show");

    }

    $scope.getService = function(classname)

    {

        if(classname)

        {

            var service = $filter('filter')($scope.servicesSoa, {"className": classname },true)[0];

            return service;

        }

    }

    $scope.getServiceMethods = function(classname)

    {

        if(classname)

        {

            var service = $filter('filter')($scope.servicesSoa, {"className": classname },true)[0];

            return service.methods;

        }

    }

    $scope.deleteTodo = function(task,index)

    {

        task.todos.todos.splice(index,1);

        $scope.setDirty(task);

    }

    $scope.deleteAfterUserTodo = function(task,index)

    {

        task.afterUserTodos.todos.splice(index,1);

        $scope.setDirty(task);

    }

    $scope.getServiceMethod = function()

    {

       return $scope.newSoa.methodChoosed;

    }

    $scope.setArgumentsNewSoa = function()

    {

        var method = $scope.newSoa.methodChoosed;

        var arguments = [];

        for(var a in method.arguments)

        {

            var newArgument = {

                "@class" : "<%=Argument.class.getName()%>",

                    "name" : method.arguments[a].name,

                    "varName" : "",

                    "className" : method.arguments[a].className

            }

            if( method.arguments[a].classNameSuperClasses)

                newArgument.classNameSuperClasses = method.arguments[a].classNameSuperClasses;

            arguments.push(newArgument);

        }

        $scope.newSoa.methodName = method.name;

        $scope.newSoa.arguments = arguments;

        $scope.newSoa.checkReturnType = method.returnType;

        if(method.returnTypeSuperClasses)

            $scope.newSoa.checkReturnTypeSuperClasses = method.returnTypeSuperClasses;

    }

    /**

     *

     *

     *

     * */

     $scope.getSimpleClassName = function(classname)

    {

        if(classname && classname != "")

        {

            var lastDot = classname.lastIndexOf(".");

            if(lastDot >= 0)

                return classname.substring(lastDot + 1);

            return classname;

        }

        return "";

    }

    $scope.soaServiceSelector = function()

    {

        setTimeout(function() { $("#SoaServiceSelector").chosen(); }, 500);

     //   $("#SoaServiceSelector").chosen();

    }

    $scope.newRoleForPool = function(item)

    {

        $scope.idTemp--;

        if(item.roles == null)

        {

            item.roles = [];

        }

        item.roles.push(

                {

                    "role" : "",

                    "trans" : ""

                }

        );

        //O chosen está off para que na primeira interação nao actue sobre

        //o option padrão que está sempre presente para preenchimento pelo Angular

        setTimeout(function() { invokeChosenSelects("#bpmnPools"); }, 100);

    }

    $scope.newProcessVar = function()

    {

        $scope.callService("newProcessVar",{"processId":$scope.process.id},function(processVariable)

        {

            if(!$scope.process.processVariables)

                $scope.process.processVariables = [];

            $scope.process.processVariables.push(processVariable);

            $scope.$apply();

        });

    }

    $scope.removeProcessVar = function(variableId,$index)

    {

        $scope.callSimpleService("removeProcessVar",{"processId":$scope.process.id,"variableId":variableId},function()

        {

            $scope.process.processVariables.splice($index,1);

            $scope.$apply();

        });

    }

    $scope.newLocalVar = function(task)

    {

        $scope.callService("newLocalVar",{"taskId":task.id},function(taskVariable)

        {

            if(!task.localVariables)

                task.localVariables = [];

            task.localVariables.push(taskVariable);

            $scope.$apply();

        });

    }

    $scope.removeLocalVar = function(variableId,$index)

    {

        $scope.callSimpleService("removeLocalVar",{"variableId":variableId,"taskId":$scope.selected.id},function()

        {

            var task = $scope.selected;

            task.localVariables.splice($index,1);

            $scope.$apply();

        });

    }

    $scope.pushArray = function(arrayDestiny,arraySource)

    {

        for(var a in arraySource)

        {

            arrayDestiny.push(arraySource[a]);

        }

    }

    $scope.getAllVariables = function()

    {

        var allVariables = [];

        if($scope.process.processVariables)

            $scope.pushArray(allVariables,$scope.process.processVariables);

        var task = $scope.selected;

        if(task)

        {

            if(task.localVariables)

                $scope.pushArray(allVariables,task.localVariables);

            var isActorTask = task["@class"].startsWith("<%=pt.estgp.estgweb.domain.BpmnFlowComponentTaskActor.class.getName()%>");

            if(isActorTask)

                $scope.pushArray(allVariables,$scope.constantVariablesActorTask);

            else

                $scope.pushArray(allVariables,$scope.constantVariables);

        }

        return allVariables;

    }

    /**

     * @classe class to match

     * @superClasses array of strings

     * */

    $scope.contains = function(superClasses,classe)

    {

        if(superClasses)

        {

            for(var i in superClasses)

            {

                if(classe == superClasses[i])

                    return true;

            }

        }

        return false;

    }

    /**

     *   Return variables that match the given attribute className

     *   If attribution = true means that readonly process variables are not allowded

     *

         A verificação de variáveis possíveis de Atribuir considera duas situações

         Chamado em duas Situações,

         1) a escolha de variável para a atribuição

         2) a escolha de variável para argumento de um método

         1) Definição com Exemplo

         User  metodo(…);

         returnType = User

         returnTypeSuperClasses = [SigesUser,GenericUser,DomainObject]

         var1 Teacher

         className=Teacher

         classNameSuperTypes =  [User,SigesUser,GenericUser,DomainObject,Object]

         var2 DomainObject

         className= DomainObject

         classNameSuperTypes =  [DomainObject,Object]

         Para poder ser feita uma atribuição, ou seja para a variável var1 e/ou var2 ser uma das possíveis

         tem de respeitar a seguinte condição

         returnType instanceOf varN é possivel

         O que significa executar o seguinte algoritmo com resposta positiva

         varN.className == returnType || returnTypeSuperClasses contains varN.className

         neste sentido a var 2 pode ser usada na atribuição e a var 1 não

         2) Definição com Exemplo

            ... metodo(User);

             argument.className = User

             argument.classNameSuperClasses = [SigesUser,GenericUser,DomainObject]

             var1 Teacher

             className=Teacher

             classNameSuperTypes =  [User,SigesUser,GenericUser,DomainObject,Object]

             var2 DomainObject

             className= DomainObject

             classNameSuperTypes =  [DomainObject,Object]

             Para poder ser feita uma atribuição, ou seja para a variável var1 e/ou var2 ser uma das possíveis

             tem de respeitar a seguinte condição

             varN instanceOf argument.className é possivel (A condicao é ao contrario da anterior em 1)

             O que significa executar o seguinte algoritmo com resposta positiva

             varN.className == argument.className || varN.classNameSuperClasses contains argument.className

             neste sentido a var 1 pode ser usada na atribuição e a var 2 não

     * */

    $scope.getPossibleVariables = function(className,classNameSuperClasses,forAttribution,afterUserCalls)

    {

        if(!$scope.selected || !className)

            return;

        var isActorTask = $scope.selected["@class"].startsWith("<%=pt.estgp.estgweb.domain.BpmnFlowComponentTaskActor.class.getName()%>");

        var possibleVars = [];

        var task = $scope.selected;

        for(var v in $scope.process.processVariables)

        {

            var processVariable = $scope.process.processVariables[v];

            if(className == processVariable.type.className)

            {

                possibleVars.push(processVariable);

            }

            else if(forAttribution && $scope.contains(classNameSuperClasses,processVariable.type.className))

            {

                possibleVars.push(processVariable);

            }

            else if(!forAttribution && $scope.contains(processVariable.type.classNameSuperClasses,className))

            {

                possibleVars.push(processVariable);

            }

        }

        for(var v in task.localVariables)

        {

            var taskVariable = task.localVariables[v];

            if(className == taskVariable.type.className)

            {

                possibleVars.push(taskVariable);

            }

            else if(forAttribution && $scope.contains(classNameSuperClasses,taskVariable.type.className))

            {

                possibleVars.push(taskVariable);

            }

            else if(!forAttribution && $scope.contains(taskVariable.type.classNameSuperClasses,className))

            {

                possibleVars.push(taskVariable);

            }

        }

        //Estas variaveis só podem ser usadas, nunca alteradas

        if(!forAttribution)

        {

            /*

            Ator Antes

            Ator Depois

            Normal

            */

            var atorMasAntesDoForm = !afterUserCalls;  // ATOR ANTES NAO VAI SER USADO SE QUISERMOS EXECUTAR TAREFAS EM BACKGROUND DEVERA SER CRIADA UmA TAREFA SERVIÇO PARA O EFEITO

            var tarefaServicoNormal = !isActorTask; // NORMAL

                                    /*|| atorMasAntesDoForm */

            if(tarefaServicoNormal                             ) // ve vars constantes normais de processo

            {

                for(var v in $scope.constantVariables)

                {

                    var variable = $scope.constantVariables[v];

                    if(className == variable.type.className)

                    {

                        possibleVars.push(variable);

                    }

                    else if($scope.contains(variable.type.classNameSuperClasses,className))

                    {

                        possibleVars.push(variable);

                    }

                }

            }

            else //ATOR DEPOIS Pode usar tudo

            {

                for(var v in $scope.constantVariablesActorTask)

                {

                    var variable = $scope.constantVariablesActorTask[v];

                    if(className == variable.type.className)

                    {

                        possibleVars.push(variable);

                    }

                    else if($scope.contains(variable.type.classNameSuperClasses,className))

                    {

                        possibleVars.push(variable);

                    }

                }

            }

        }

        return possibleVars;

    }

});

/**

 Directiva showErrors reutilizavel para validação de forms groups

 Basta que um campo no form tenha a classe form-control*

 em cada campo onde quisermos validação é necessario colocar show-errors no container

 e dar um nome unico ao input a validar e também a directiva required

 é necessario dar o nome processoForm neste caso para o save atuar sobre a verificacao de validade da form

 é necessario definir a class .has-error .chosen-container com #a94442 e !important para se sobrebor nos selects do chosen

 */

/*

processEditorModule.directive('showErrors', function($timeout) {

    return {

        restrict: 'A',

        require:  '^form',

        link: function (scope, el, attrs, formCtrl)

        {

            scope.initOk = function(scope, el, attrs, formCtrl) {

                var inputEl   = el[0].querySelector("[name]");

                var inputNgEl = angular.element(inputEl);

                var inputName = inputNgEl.attr('name');

                var blurred = false;

                // only apply the has-error class after the user leaves the text box

                inputNgEl.bind('blur', function() {

                    blurred = true;

                    el.toggleClass('has-error', formCtrl[inputName].$invalid);

                });

                scope.$watch(function() {

                            return formCtrl[inputName].$invalid

                        },

                        function(invalid) {

                            // we only want to toggle the has-error class after the blur

                            // event or if the control becomes valid

                            if (!blurred && invalid) { return }

                            el.toggleClass('has-error', invalid);

                        });

                scope.$on('show-errors-check-validity', function() {

                    el.toggleClass('has-error', formCtrl[inputName].$invalid);

                });

                scope.$on('show-errors-reset', function() {

                    $timeout(function() {

                        el.removeClass('has-error');

                    }, 0, false);

                });

            }

            scope.initClean = function(scope, el, attrs, formCtrl) {

                var inputEl   = el[0].querySelector("[name]");

                var inputNgEl = angular.element(inputEl);

                //scope.$watch("processoForm", function( newValue, oldValue ) {

                if ( inputNgEl.attr('name').indexOf("{")>=0 ) {

                    console.log( "Sujo..." + inputNgEl.attr('name'));

                    $timeout(function() {

                                scope.initClean(scope, el, attrs, formCtrl);

                            }

                            , 100);

                    return;

                }

                else{

                    console.log("LIMPO..." + inputNgEl.attr('name'));

                    scope.initOk(scope, el, attrs, formCtrl);

                }

                //});

            };

            scope.initClean(scope, el, attrs, formCtrl);

        }

    }

});

*/

</script>

<%--#######################################################

    #######################################################

    MODAL PARA OPERACOES SOA

    #######################################################

    #######################################################

--%>

<div class="modal fade" id="soaModalSelector" role="dialog" >

    <div class="modal-dialog" data-width="1024" style="display: block; width: 1024px; margin-top: 50px;" aria-hidden="false">

        <!-- Modal content-->

        <div class="modal-content">

            <div class="modal-header clearfix">

                <h3 class="modal-title">

                    <label class="title-wrap">Selector de connector SOA</label>

                    <button type="button" class="btn btn-danger btn-xs pull-right" data-dismiss="modal"><span class="glyphicon glyphicon-remove small"></span></button>

                </h3>

            </div>

            <div class="modal-body">

                <div class="row">

                    <div class="col-md-5">

                        <div class="form-group">

                            <label class="control-label">Serviço SOA</label>

                            <div>

                                <select class="chosenOff form-control" ng-model="newSoa.className" ng-options="soa.className as soa.serviceRelativeName for soa in servicesSoa"></select>

                            </div>

                        </div>

                        <div ng-show="newSoa.className" class="form-group">

                            <label class="control-label">Método</label>

                            <div>

                                <select ng-change="setArgumentsNewSoa()" class="chosenOff form-control" ng-model="newSoa.methodChoosed" ng-options="m as showMethodSign(m) for m in getServiceMethods(newSoa.className)"></select>

                            </div>