| 1 | == Classe: wf_engine == |
| 2 | Esta classe tem a finalidade de prover informações/ações relacionadas à engine do Workflow. |
| 3 | |
| 4 | |
| 5 | |
| 6 | === Métodos === |
| 7 | |
| 8 | |
| 9 | |
| 10 | ==== getProcess ==== |
| 11 | |
| 12 | '''Descrição:''' Busca informações de um (ou mais) processo(s). |
| 13 | |
| 14 | '''Parâmetros:''' |
| 15 | |
| 16 | :$pids: uma array de IDs de processo ou um inteiro representando o ID de um processo. |
| 17 | |
| 18 | '''Retorno''': uma array de arrays associativas contento informações sobre os processos. |
| 19 | |
| 20 | '''Exemplo de uso 01:''' |
| 21 | |
| 22 | {{{ |
| 23 | |
| 24 | $engine = wf_create_object("wf_engine"); |
| 25 | |
| 26 | $engine->getProcess(1); |
| 27 | |
| 28 | }}} |
| 29 | |
| 30 | Este exemplo geraria uma saída do tipo (supondo que o processo de Ligações Telefônicas seja o de pid igual a 1): |
| 31 | |
| 32 | {{{ |
| 33 | |
| 34 | Array |
| 35 | |
| 36 | ( |
| 37 | |
| 38 | [0] => Array |
| 39 | |
| 40 | ( |
| 41 | |
| 42 | [wf_p_id] => 1 |
| 43 | |
| 44 | [wf_name] => Ligações Telefônicas |
| 45 | |
| 46 | [wf_is_valid] => y |
| 47 | |
| 48 | [wf_is_active] => y |
| 49 | |
| 50 | [wf_version] => 1.0 |
| 51 | |
| 52 | [wf_description] => Processo de gerenciamento das ligações telefônicas efetuadas pelos funcionários da Celepar. |
| 53 | |
| 54 | [wf_last_modif] => 1164750629 |
| 55 | |
| 56 | [wf_normalized_name] => Ligaes_Telefnicas_10 |
| 57 | |
| 58 | ) |
| 59 | |
| 60 | ) |
| 61 | |
| 62 | }}} |
| 63 | |
| 64 | |
| 65 | |
| 66 | '''Exemplo de uso 02:''' |
| 67 | |
| 68 | {{{ |
| 69 | |
| 70 | $pids = array(4, 8, 15, 16, 23, 42); |
| 71 | |
| 72 | $engine = wf_create_object("wf_engine"); |
| 73 | |
| 74 | $processos = $engine->getProcess($pids); |
| 75 | |
| 76 | }}} |
| 77 | |
| 78 | ---- |
| 79 | |
| 80 | ==== continueInstance ==== |
| 81 | |
| 82 | '''Descrição:''' Dá seqüência ao fluxo de execução de uma instância, simulando uma ação do usuário. A instância deve pertencer ao processo que está utilizando o método. |
| 83 | |
| 84 | '''Parâmetros:''' |
| 85 | |
| 86 | :$activityID: ID da atividade da instância que se quer executar. |
| 87 | |
| 88 | :$instanceID: ID da instância que se quer executar. |
| 89 | |
| 90 | '''Retorno''': <nenhum> |
| 91 | |
| 92 | '''Exemplo de uso:''' |
| 93 | |
| 94 | Supondo que a instância de número 108 que está na atividade de número 15 está parada aguardando uma ação do usuário. E, também supondo que na referida atividade existem dois caminhos diferentes que a instância pode seguir. A escolha de qual caminho a instância vai seguir, é feita pelo usuário e é tratada no código por dois if's (ou alguma outra estrutura de controle), como abaixo: |
| 95 | |
| 96 | {{{ |
| 97 | |
| 98 | / ** código da atividade de número 15 (PHP) **/ |
| 99 | |
| 100 | /* caminho 01 */ |
| 101 | |
| 102 | if (isset($_REQUEST['autorizar'])) |
| 103 | |
| 104 | { |
| 105 | |
| 106 | $instance->setNextActivity('Conceder Empréstimo'); |
| 107 | |
| 108 | $instance->complete(); |
| 109 | |
| 110 | } |
| 111 | |
| 112 | |
| 113 | |
| 114 | /* caminho 02 */ |
| 115 | |
| 116 | if (isset($_REQUEST['rejeitar'])) |
| 117 | |
| 118 | { |
| 119 | |
| 120 | $instance->setNextActivity('Informar Rejeição'); |
| 121 | |
| 122 | $instance->complete(); |
| 123 | |
| 124 | } |
| 125 | |
| 126 | }}} |
| 127 | |
| 128 | Se quisermos, por exemplo, simular uma ação do usuário que leva ao caminho 02 ("Informar Rejeição") para a instância em questão, podemos proceder da seguinte maneira: |
| 129 | |
| 130 | {{{ |
| 131 | |
| 132 | $_REQUEST['rejeitar'] = true; |
| 133 | |
| 134 | $engine = wf_create_object("wf_engine"); |
| 135 | |
| 136 | $engine->continueInstance(15, 108); |
| 137 | |
| 138 | }}} |
| 139 | |
| 140 | Assim, o código desta atividade (para aquela instância) seria executado simulando uma ação do usuário que levaria a instância para o caminho 02. |
| 141 | |
| 142 | ---- |
| 143 | |
| 144 | ==== abortInstance ==== |
| 145 | |
| 146 | '''Descrição:''' Aborta uma instância a partir de seu ID. Caso uma instância tenha sido dividida em duas (atividade split) ambas as instâncias serão abortadas. Só é possível abortar instâncias que pertencem ao processo que está utilizando o método. |
| 147 | |
| 148 | '''Parâmetros:''' |
| 149 | |
| 150 | :$instanceID: ID da instância que se quer abortar. |
| 151 | |
| 152 | '''Retorno''': TRUE se foi possível abortar a instância ou FALSE caso contrário. |
| 153 | |
| 154 | '''Exemplo de uso:''' |
| 155 | |
| 156 | Supondo que se quer abortar a instância de ID 42: |
| 157 | |
| 158 | {{{ |
| 159 | |
| 160 | $engine = wf_create_object("wf_engine"); |
| 161 | |
| 162 | $engine->abortInstance(42); |
| 163 | |
| 164 | }}} |
| 165 | |
| 166 | ---- |
| 167 | |
| 168 | ==== setInstanceName ==== |
| 169 | |
| 170 | '''Descrição:''' Define o nome (o campo identificador da Caixa de Entrada) de uma instância. Só é possível definir o nome de instâncias que pertencem ao processo que está utilizando o método. |
| 171 | |
| 172 | '''Parâmetros:''' |
| 173 | |
| 174 | :$instanceID: ID da instância cujo nome se quer mudar. |
| 175 | |
| 176 | :$name: O novo nome da instância. |
| 177 | |
| 178 | '''Retorno''': TRUE se foi possível mudar o nome da instância ou FALSE caso contrário. |
| 179 | |
| 180 | '''Exemplo de uso:''' |
| 181 | |
| 182 | Supondo que se quer mudar para "Novo Nome" o nome da instância cujo ID é 54: |
| 183 | |
| 184 | {{{ |
| 185 | |
| 186 | $engine = wf_create_object("wf_engine"); |
| 187 | |
| 188 | $engine->setInstanceName(54, "Novo Nome"); |
| 189 | |
| 190 | }}} |
| 191 | |
| 192 | ---- |
| 193 | |
| 194 | ==== getIdleInstances ==== |
| 195 | |
| 196 | '''Descrição:''' Busca instâncias abandonadas (que estão paradas há um determinado número de dias) do processo que está utilizando este método. |
| 197 | |
| 198 | '''Parâmetros:''' |
| 199 | |
| 200 | :$numberOfDays: o tempo (em dias) em que a instância está parada. |
| 201 | |
| 202 | :$activities: (opcional) uma array com os IDs das atividades das quais se quer as instâncias abandonadas (caso se queira restringir a uma única atividade, também pode ser utilizado um valor inteiro referente ao ID desta atividade). |
| 203 | |
| 204 | '''Retorno''': uma array de arrays associativas contendo informações sobre as instâncias abandonadas. |
| 205 | |
| 206 | As informações trazidas para cada elemento desse array são: wf_instance_id, wf_activity_id, wf_started, wf_name, wf_status e wf_user. |
| 207 | |
| 208 | '''Exemplo de uso 01:''' |
| 209 | |
| 210 | Supondo que queremos encontrar instâncias paradas há mais de 4 dias e que estão nas atividades 8 e 15: |
| 211 | |
| 212 | {{{ |
| 213 | |
| 214 | $atividades = array(8, 15) |
| 215 | |
| 216 | $engine = wf_create_object("wf_engine"); |
| 217 | |
| 218 | $instancias = $engine->getIdleInstances(4, $atividades); |
| 219 | |
| 220 | }}} |
| 221 | |
| 222 | |
| 223 | |
| 224 | '''Exemplo de uso 02:''' |
| 225 | |
| 226 | Supondo que queremos todas as instâncias paradas há mais de 16 dias: |
| 227 | |
| 228 | {{{ |
| 229 | |
| 230 | $engine = wf_create_object("wf_engine"); |
| 231 | |
| 232 | $instancias = $engine->getIdleInstances(16); |
| 233 | |
| 234 | }}} |
| 235 | |
| 236 | ---- |
| 237 | |
| 238 | ==== getInstances ==== |
| 239 | |
| 240 | '''Descrição:''' Busca instâncias do processo que está utilizando este método. |
| 241 | |
| 242 | '''Parâmetros:''' |
| 243 | |
| 244 | :$activities: (opcional) uma array com os IDs das atividades das quais se quer as instâncias (caso se queira restringir a uma única atividade, também pode ser utilizado um valor inteiro referente ao ID desta atividade). |
| 245 | |
| 246 | '''Retorno''': uma array de arrays associativas contendo informações sobre as instâncias. |
| 247 | |
| 248 | As informações trazidas para cada elemento desse array são: wf_instance_id, wf_activity_id, wf_started, wf_name, wf_status e wf_user. |
| 249 | |
| 250 | '''Exemplo de uso 01:''' |
| 251 | |
| 252 | Supondo que queremos encontrar instâncias que estão nas atividades 8 e 15: |
| 253 | |
| 254 | {{{ |
| 255 | |
| 256 | $atividades = array(8, 15) |
| 257 | |
| 258 | $engine = wf_create_object("wf_engine"); |
| 259 | |
| 260 | $instancias = $engine->getInstances($atividades); |
| 261 | |
| 262 | }}} |
| 263 | |
| 264 | |
| 265 | |
| 266 | '''Exemplo de uso 02:''' |
| 267 | |
| 268 | Supondo que queremos todas as instâncias do prcesso: |
| 269 | |
| 270 | {{{ |
| 271 | |
| 272 | $engine = wf_create_object("wf_engine"); |
| 273 | |
| 274 | $instancias = $engine->getInstances(); |
| 275 | |
| 276 | }}} |
| 277 | |
| 278 | ---- |
| 279 | |
| 280 | ==== getInstancesByName ==== |
| 281 | |
| 282 | '''Descrição:''' Busca todas as instâncias que possuem um determinado nome (o campo identificador da Caixa de Entrada). |
| 283 | |
| 284 | '''Parâmetros:''' |
| 285 | |
| 286 | :$name: O nome da(s) instância(s) desejada(s). |
| 287 | |
| 288 | '''Retorno''': uma array de arrays associativas contendo informações sobre as instâncias que possuem o nome informado. |
| 289 | |
| 290 | As informações trazidas para cada elemento desse array são: wf_instance_id, wf_activity_id, wf_started, wf_name, wf_status e wf_user. |
| 291 | |
| 292 | '''Exemplo de uso:''' |
| 293 | |
| 294 | Supondo que queremos encontrar instâncias que possuem o nome "Urgente": |
| 295 | |
| 296 | {{{ |
| 297 | |
| 298 | $engine = wf_create_object("wf_engine"); |
| 299 | |
| 300 | $instancias = $engine->getInstancesByName("Urgente"); |
| 301 | |
| 302 | }}} |
| 303 | |
| 304 | ---- |
| 305 | |
| 306 | ==== getChildInstances ==== |
| 307 | |
| 308 | '''Descrição:''' Busca as instâncias filhas da instância (considerando ID da instância e ID da atvidade) que está utilizando o método. |
| 309 | |
| 310 | '''Parâmetros:''' <nenhum> |
| 311 | |
| 312 | '''Retorno''': uma array de arrays associativas contendo informações sobre as instâncias filhas da instância atual. |
| 313 | |
| 314 | As informações trazidas para cada elemento desse array são: wf_instance_id, wf_activity_id, wf_started, wf_name, wf_status e wf_user. |
| 315 | |
| 316 | '''Exemplo de uso:''' |
| 317 | |
| 318 | {{{ |
| 319 | |
| 320 | $engine = wf_create_object("wf_engine"); |
| 321 | |
| 322 | $instancias = $engine->getChildInstances(); |
| 323 | |
| 324 | }}} |
| 325 | |
| 326 | ---- |
| 327 | |
| 328 | ==== getChildInstanceProperties ==== |
| 329 | |
| 330 | '''Descrição:''' Busca as propriedades de uma instância filha. A instância que chama o método tem que ser mãe da instância da qual se quer as propriedades. |
| 331 | |
| 332 | '''Parâmetros:''' |
| 333 | |
| 334 | :$instanceID: ID da instância filha (da qual se quer as propriedades). |
| 335 | |
| 336 | '''Retorno''': uma array associativa contendo as propriedades da instância filha. Esta array está no formato: "nome_da_propriedade" => "valor_da_propriedade". |
| 337 | |
| 338 | '''Exemplo de uso:''' |
| 339 | |
| 340 | Supondo que se quer as propriedades da instância (que no caso é filha da atual) de número 815: |
| 341 | |
| 342 | {{{ |
| 343 | |
| 344 | $engine = wf_create_object("wf_engine"); |
| 345 | |
| 346 | $propriedades = $engine->getChildInstanceProperties(815); |
| 347 | |
| 348 | }}} |
| 349 | |
| 350 | ---- |
| 351 | |
| 352 | ==== getUserPermissions ==== |
| 353 | |
| 354 | '''Descrição:''' Informa os recursos que um usuário pode administrar. Para isto, utiliza a tabela "admin_access" (na base de dados do Workflow). |
| 355 | |
| 356 | '''Parâmetros:''' |
| 357 | |
| 358 | :$type: tipo do recurso ("PRO" para administração de processos, "MON" para monitoramento, "ORG" para organograma, etc.). |
| 359 | |
| 360 | :$uid: o usuário do qual se quer obter informações sobre a administração de recursos. |
| 361 | |
| 362 | '''Retorno''': uma array contendo os IDs dos recursos que o usuário tem acesso. |
| 363 | |
| 364 | '''Exemplo de uso:''' |
| 365 | |
| 366 | Supondo que queremos saber quais organogramas (IDs dos organogramas) o usuário 1516 pode administrar: |
| 367 | |
| 368 | {{{ |
| 369 | |
| 370 | $engine = wf_create_object("wf_engine"); |
| 371 | |
| 372 | $propriedades = $engine->getUserPermissions('ORG', 1516); |
| 373 | |
| 374 | }}} |