CA Service Management

WORKFLOW CLÁSSICO: Biblioteca de funções SPEL - 2016-08-23 

WORKFLOW CLÁSSICO: Biblioteca de funções SPEL
Preparei uma coletânea de funções SPEL desenvolvidas por mim (Daniel Bighelini) que podem ser muito úteis em ações e condições de macro em tarefas de fluxo de trabalho para todos os objetos na ferramenta SDM.

Todas estas funções estão bem documentadas, são funções inteligentes pois se adaptam ao tipo de objeto envolvido e possuem exemplos de utilização no próprio código.
Todas elas podem ser utilizadas para qualquer tipo de objeto (Incidentes, Problemas, Solicitações, Ocorrências e Requisições de mudança).

I have prepared a collection of SPEL functions developed by me (Daniel Bighelini) that can be very useful in macro actions and conditions in workflow tasks for all objects in the SDM tool.

All these functions are well documented, they are intelligent functions because they adapt to the type of object involved and have examples of use in the code itself.
All of them can be used for any type of object (Incidents, Problems, Requests, Occurrences and Requests for change).

z_armazena_propriedade
z_consulta_propriedade
z_altera_valor
z_consulta_valor
z_randomize
z_consulta_producer
z_consulta_tipo_atributo
z_identifica_usuario_logado
z_consulta_factory_info
z_notifica_contato
z_replace_doublebyte
z_replace_doublebyte_utf8
z_contain_doublebyte
z_contain_doublebyte_utf8
z_bloco_fim
z_bloco_inicio

Se alguém achar algum bug, ganha um prêmio.
Divirtam-se!

////////////////////////////////////////////////////////////////////////////
// Modulo: z_functions.spl
// Modificado por: Daniel Becker Bighelini
// Modificado em: 23/08/2016
////////////////////////////////////////////////////////////////////////////

z_bloco_fim(int zi_depurar, string zs_metodo)
{
////////////////////////////////////////////////////////////////////////
// Metodo: z_bloco_fim
// Autor: Henrique Grammelsbacher
// Modificado em: 20/05/2016
// Descricao: Grava em log o fim de bloco de depuracao   -   Record the end of the debug block
// Parametros:
// zi_depurar Nivel de depuracao da funcao 0-nenhum / 1-resumido / 2-detalhado)
// zs_metodo Nome do metodo que sera identificado no bloco
//
// Exemplos:
// z_bloco_fim(1, "z_calcula_data")
//
////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
if (zi_depurar > 0) {
logf(SIGNIFICANT, "=============================================================");
logf(SIGNIFICANT, "%s Fim : %s", zs_metodo, now());
logf(SIGNIFICANT, "=============================================================");
}
// Fim do codigo
/////////////////////////////////// 
}

z_bloco_inicio(int zi_depurar, string zs_metodo)
{
////////////////////////////////////////////////////////////////////////////
// Metodo: z_bloco_inicio
// Autor: Daniel Becker Bighelini
// Modificado em: 20/05/2016
// Descricao: Grava em log o inicio de bloco de depuracao - Logs the debug block start
// Parametros:
// zi_depurar Nivel de depuracao da funcao 0-nenhum / 1-resumido / 2-detalhado)
// zs_metodo Nome do metodo que sera identificado no bloco
//
// Exemplos:
// z_bloco_inicio(1, "z_calcula_data")
////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
if (zi_depurar > 0) { 
logf(SIGNIFICANT, "=============================================================");
logf(SIGNIFICANT, "%s Inicio : %s", zs_metodo, now());
logf(SIGNIFICANT, "%s Usuario: '%s'", zs_metodo, thread_userid());
if (!is_empty(event())) logf(SIGNIFICANT, "%s Evento : '%s'", zs_metodo, event());
if (!is_empty(class())) logf(SIGNIFICANT, "%s Classe : '%s'", zs_metodo, class());
logf(SIGNIFICANT, "=============================================================");
}
// Fim do codigo
/////////////////////////////////// 
}

string z_armazena_propriedade(string zs_persid, int zi_depurar, string zs_metodo, int zi_sequencia, string zs_rotulo, string zs_valor)
{
////////////////////////////////////////////////////////////////////////////
// Metodo: z_armazena_propriedade
// Autor: Daniel Becker Bighelini
// Criado em: 19/05/2013
// Modificado por: Daniel Becker Bighelini
// Modificado em: 10/04/2015
// Descricao: Armazena valor em propriedade especifica informando a sequencia ou rotulo  -  Stores value in property specifies the sequence or label
// Parametros:
// zs_persid string do persistent_id do ticket
// zi_depurar inteiro Nivel de depuracao da funcao 0-nenhum / 1-resumido / 2-detalhado)  -  Level of function debugging
// zs_metodo string que identifica o nome do metodo que chamou este metodo  -   Identifies the name of the method that called this method
// zi_sequencia inteiro que identifica a propriedade que sera alterada. Se for informado '0', sera utilizado o rotulo da propriedade  - Identifies the property that will be changed. If '0' is entered, the property

// zs_rotulo string do rotulo da propriedade que sera armazenada caso o numero de sequencia nao seja informado - String of the property label that will be stored if the sequence number is not reported
// zs_valor string do valor que sera armazenado na propriedade - String of the value that will be stored in the property
//
// Exemplos:
// z_armazena_propriedade('iss:999999', 1, 'nome do metodo', 0, 'Sistemas afetados:', 'USD')
// z_armazena_propriedade('iss:999999', 1, 'nome do metodo', 70, '', 'USD')
////////////////////////////////////////////////////////////////////////////
// Variaveis utilizadas pelos parametros do metodo

// Variaveis globais do metodo - Global variables of the method
int zi_i;
string zs_msg;
// Atribuindo variaveis -  Assigning Variables
zs_metodo += ' z_armazena_propriedade - ';

// Entrada para debug mode - Input for debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i+=1) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
logf(SIGNIFICANT, "%s '%s'", zs_metodo, zs_persid);
}
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo - Start of code
// Identificando o producer do objeto - Identifying the object's producer
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Identificando 'producer' do objeto '%s'...", zs_metodo, zs_persid);
string zs_producer;
zs_producer = substr(zs_persid, 0, sindex(zs_persid,":"));
if (sindex(zs_persid, ":") == -1) {
zs_msg = format("%s ERRO ao identificar o producer do objeto '%s': %s", zs_metodo, zs_persid, sindex(zs_persid,":"));
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Producer do objeto '%s': '%s'", zs_metodo, zs_persid, zs_producer);
// Identificando o id do objeto
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Identificando 'id' do objeto '%s'...", zs_metodo, zs_persid);
int zi_id;
zi_id = (int) substr(zs_persid, sindex(zs_persid,":") + 1);
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s ID do objeto '%s': '%s'", zs_metodo, zs_persid, zi_id);
// Define qual atributo que se relaciona com o id/persid do ticket para ser utilizado na clausula de procura
string zs_obj_id, zs_prp_factory;
if (zs_producer == "chg") {
zs_prp_factory = "prp";
zs_obj_id = format("object_id=%s", zi_id);
} else if (zs_producer == "iss") {
zs_prp_factory = "iss_prp";
zs_obj_id = format("owning_iss='iss:%s'", zi_id);
} else if (zs_producer == "cr") {
zs_prp_factory = "cr_prp";
zs_obj_id = format("owning_cr='cr:%s", zi_id);
} else {
zs_msg = format("%s ERRO ao identificar o objeto '%s'.", zs_metodo, zs_persid);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}

// Define qual atributo sera utilizado para procurar a propriedade na clausula de procura - Defines which attribute will be used to search the property in the search clause
string zs_obj_prp;
if (is_null(zi_sequencia) || zi_sequencia == 0) {
zs_obj_prp = format("label='%s'", zs_rotulo); // se o valor de sequencia estiver vazio, utiliza o rotulo da propriedade - If the sequence value is empty, use the property label
} else {
zs_obj_prp = format("sequence=%s", zi_sequencia); // se o valor de rotulo estiver vazio, utiliza a sequencia da propriedade - If the label value is empty, use the sequence of the property
}
// Monta clausula where
string zs_clausula;
zs_clausula = format("%s AND %s", zs_obj_id, zs_obj_prp);
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Clausula where utilizada: '%s'", zs_metodo, zs_clausula);

// Executa o SQL
send_wait(0, top_object(), "call_attr", zs_prp_factory, "sync_fetch", "STATIC", zs_clausula, -1, 0);
if (msg_error()) {
zs_msg = format("%s ERRO ao definir a lista de valores: %s", zs_metodo, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
object zo_list_prp;
int zi_count_list;
zo_list_prp = msg[0]; // armazena resultado do sql em matriz - Stores sql result in array
zi_count_list = msg[1]; // totaliza a quantidade de ocorrencias do sql
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Armazenando propriedade '%s' no objeto '%s'...", zs_metodo, zs_obj_prp, zs_persid);
// Armazenando valor na propriedade
if(zi_count_list>0) {
// Seleciona o objeto
send_wait(0, zo_list_prp, "dob_by_index", "DEFAULT", 0 , 0);
if (msg_error()) {
zs_msg = format("%s ERRO ao instanciar objeto: '%s'", zs_metodo, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
object zo_prp;
zo_prp = msg[0];

// Altera a propriedade
string zs_resultado;
zs_resultado = z_altera_valor(zo_prp.persistent_id, zi_depurar, zs_metodo, 'value', zs_valor);
if (sindex(zs_resultado, " ERRO ") >= 0) {
zs_msg = format("%s %s", zs_metodo, zs_resultado);
logf(ERROR, "%s", zs_msg);
}
z_bloco_fim(zi_depurar, zs_metodo);
return "OK";

} else { // Caso nenhuma propriedade seja localizada
zs_msg = format("%s AVISO: Nenhuma propriedade foi localizada no objeto '%s' com a clausula de procura '%s'.", zs_metodo, zs_persid, zs_clausula);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
z_bloco_fim(zi_depurar, zs_metodo);
return;
// Fim do codigo
/////////////////////////////////// 
}

string z_consulta_propriedade(string zs_persid, int zi_depurar, string zs_metodo, int zi_sequencia, string zs_rotulo)
{
////////////////////////////////////////////////////////////////////////////
// Metodo: z_consulta_propriedade
// Autor: Daniel Becker Bighelini
// Criado em: 20/06/2013
// Modificado por: Daniel Becker Bighelini
// Modificado em: 02/12/2013
// Descricao: Retorna o valor armazenado em uma propriedade especifica informando a sequencia ou rotulo
// Parametros:
// zs_persid string do persistent_id do ticket
// zi_depurar inteiro Nivel de depuracao da funcao 0-nenhum / 1-resumido / 2-detalhado)
// zs_metodo string que identifica o nome do metodo que chamou este metodo
// zi_sequencia inteiro que identifica a propriedade que sera consultada. Se for informado '0', sera utilizado o rotulo da propriedade
// zs_rotulo string do rotulo da propriedade que sera consultada caso o numero de sequencia nao seja informado
//
// Exemplos:
// z_consulta_propriedade('chg:999999', 0, 'nome do metodo', 0, 'Sistemas afetados:')
// z_consulta_propriedade('iss:999999', 0, 'nome do metodo', 20, '')
////////////////////////////////////////////////////////////////////////////
// Variaveis utilizadas pelos parametros do metodo

// Variaveis globais do metodo
int zi_i;
string zs_msg;
// Atribuindo variaveis
zs_metodo = zs_metodo + ' z_consulta_propriedade - ';
// Entrada para debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i+=1) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
logf(SIGNIFICANT, "%s '%s'", zs_metodo, zs_persid);
}

///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
// Identificando o producer do objeto
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Identificando 'producer' do objeto '%s'...", zs_metodo, zs_persid);
string zs_producer;
zs_producer = substr(zs_persid, 0, sindex(zs_persid,":"));
if (sindex(zs_persid, ":") == -1) {
zs_msg = format("%s ERRO ao identificar o producer do objeto '%s': %s", zs_metodo, zs_persid, sindex(zs_persid,":"));
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Producer do objeto '%s': '%s'", zs_metodo, zs_persid, zs_producer);
// Identificando o id do objeto
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Identificando 'id' do objeto '%s'...", zs_metodo, zs_persid);
int zi_id;
zi_id = (int) substr(zs_persid, sindex(zs_persid,":") + 1);
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s ID do objeto '%s': '%s'", zs_metodo, zs_persid, zi_id);

// Define qual atributo que se relaciona com o id/persid do ticket para ser utilizado na clausula de procura
string zs_obj_id, zs_prp_factory;
if (zs_producer == "chg") {
zs_prp_factory = "prp";
zs_obj_id = format("object_id=%s", zi_id);
} else if (zs_producer == "iss") {
zs_prp_factory = "iss_prp";
zs_obj_id = format("owning_iss='iss:%s'", zi_id);
} else if (zs_producer == "cr") {
zs_prp_factory = "cr_prp";
zs_obj_id = format("owning_cr='cr:%s", zi_id);
} else {
zs_msg = format("%s ERRO ao identificar o objeto '%s'.", zs_metodo, zs_persid);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}

// Define qual atributo sera utilizado para procurar a propriedade na clausula de procura
string zs_obj_prp;
if (is_null(zi_sequencia) || zi_sequencia == 0) {
zs_obj_prp = format("label='%s'", zs_rotulo); // se o valor de sequencia estiver vazio, utiliza o rotulo da propriedade
} else {
zs_obj_prp = format("sequence=%s", zi_sequencia); // se o valor de rotulo estiver vazio, utiliza a sequencia da propriedade
}
// Monta clausula where
string zs_clausula;
zs_clausula = format("%s AND %s", zs_obj_id, zs_obj_prp);
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Clausula where utilizada: '%s'", zs_metodo, zs_clausula);

// Executa a consulta
string zs_resultado;
zs_resultado = z_consulta_registro(zs_prp_factory, zi_depurar, zs_metodo, zs_clausula, "value");
if (sindex(zs_resultado, " ERRO ") >= 0) {
zs_msg = format("%s %s", zs_metodo, zs_resultado);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return;
}
z_bloco_fim(zi_depurar, zs_metodo);
return zs_resultado;
// Fim do codigo
/////////////////////////////////// 
}

string z_altera_valor(...)
{
////////////////////////////////////////////////////////////////////////////////
// Metodo: z_altera_valor
// Criado em: 03/07/2013
// Autor: Daniel Becker Bighelini
// Modificado em: 01/06/2016
// Modificado por: Daniel Becker Bighelini
////////////////////////////////////////////////////////////////////////////////
// Parametros:
// arg[0] : string zs_persid = Define o atributo persistent_id do objeto que sera alterado.
// arg[1] : int zi_depurar = Define o nivel de depuracao da funcao (0=Desligado, 1=Log resumido, 2=Log detalhado). Se omitido, valor sera 0.
// arg[2] : string zs_metodo = Define o nome do metodo que esta chamando este metodo.
// arg[3] : string atributo1 = Define o nome do atributo do objeto que sera alterado.
// arg[4] : variant valor atributo1 = Define o novo valor do atributo que sera definido no objeto.
// arg[5] : string atributo2 = Define o nome do atributo do objeto que sera alterado.
// arg[6] : variant valor atributo2 = Define o novo valor do atributo que sera definido no objeto.
// Pode qualquer quantidade de atributos que precisam ser alterados
// Se for utilizado o parametro "SUPPRESS_TRIGGERS" com o valor "TRUE" o execucao de triggers
// sera suprimida. Caso contrario, por padrao, sera utilizado o metodo "SURE_SET".
//
// Descricao:
//
// Altera o valor de um atributo de um objeto.
//
// Exemplo:
// z_altera_valor('chg:999999', 1, 'nome do metodo', 'status', 'CL', 'summary', 'teste', ... e assim sucessivamente)
// z_altera_valor('chg:999999', 1, 'nome do metodo', 'status', 'CL', 'summary', 'teste', 'SUPPRESS_TRIGGERS', 'TRUE')
////////////////////////////////////////////////////////////////////////////////
// Variaveis utilizadas pelos parametros do metodo
string zs_persid, zs_metodo;
int zi_depurar;
// Variaveis globais do metodo
int zi_h, zi_i, zi_tempo_atraso, zi_tempo_atraso_padrao, zi_tempo_limite, zi_tentativas_limite, zi_tentativas, zi_fator, zi_errors;
string zs_msg, zs_msg_return;
// Atribuindo variaveis
zs_persid = (string) argv[0];
zi_depurar = (int) argv[1];
zs_metodo = (string) argv[2] + ' z_altera_valor - ';
zi_tempo_atraso_padrao = 10; // tempo de atraso inicial padrao para reexecutar rotinas que deram erro
zi_tempo_atraso = zi_tempo_atraso_padrao; // tempo de atraso para reexecutar rotinas que deram erro
zi_tempo_limite = 5120; // tempo limite de reexecucao em cima do tempo de atraso para reexecutar rotinas que deram erro
zi_tentativas_limite = 10; // numero maximo de novas tentativas de executar uma rotina que tenha acusado erro
zi_tentativas = 0; // valor inicial para o numero de tentativas
zi_fator = 2; // valor utilizado para calculo do tempo de atraso
zi_errors = 0; // valor para contabilizar os erros durante o processo

// Entrada para debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i++) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
logf(SIGNIFICANT, "%s '%s'", zs_metodo, zs_persid);
}
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
////////////////////////////////////////////////////
// IDENTIFICANDO o usuario logado
////////////////////////////////////////////////////
// uuid zu_who;
// zu_who = (uuid) expand(format("&{%s = cnt.last_name->id}", "servicedesk"));
// if (zi_depurar >= 1) logf(SIGNIFICANT, "%s ID identificada: '%s'", zs_metodo, zu_who);
////////////////////////////////////////////////////
// IDENTIFICANDO o producer do objeto
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Identificando 'producer' do objeto '%s'...", zs_metodo, zs_persid);
string zs_producer;
zs_producer = substr(zs_persid, 0, sindex(zs_persid, ":"));
if (sindex(zs_persid, ":") == -1) {
zs_msg = format("%s ERRO ao identificar o producer do objeto '%s': %s", zs_metodo, zs_persid, sindex(zs_persid,":"));
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Producer do objeto '%s': '%s'", zs_metodo, zs_persid, zs_producer);
////////////////////////////////////////////////////
// INSTANCIANDO o objeto que sera consultado
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s INSTANCIANDO objeto '%s'...", zs_metodo, zs_persid);
send_wait(0, top_object(), "call_attr", zs_producer, "dob_by_persid", 0, zs_persid);
if (msg_error()) { 
zs_msg = format("%s ERRO ao instanciar o objeto '%s': %s", zs_metodo, zs_persid, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
object zo_objeto;
zo_objeto = msg[0];
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Objeto '%s' instanciado: '%s'", zs_metodo, zs_persid, (string) zo_objeto);
////////////////////////////////////////////////////
// PERCORRENDO todos os atributos e valores que devem ser alterados
////////////////////////////////////////////////////
int zi_atributos_alterados;
zi_atributos_alterados = 0;
int zi_count_atributos;
zi_count_atributos = argc;
string zs_method_triggers, zs_value;
zs_method_triggers = "SURE_SET";

for (zi_h=3; zi_h<zi_count_atributos; zi_h+=2) {
if (argv[zi_h] == "SUPPRESS_TRIGGERS" && argv[zi_h+1] == "TRUE") {
zs_method_triggers = "SUPPRESS_TRIGGERS";
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Metodo '%s' ATIVADO.", zs_metodo, zs_method_triggers);

} else {
////////////////////////////////////////////////////
// VERIFICANDO VALOR ATUAL do atributo consultado
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s CONSULTANDO o valor atual do atributo '%s' no objeto '%s'...", zs_metodo, argv[zi_h], zs_persid);
send_wait(0, zo_objeto, "call_attr", argv[zi_h], "get_val"); 
if (msg_error()) {
zs_msg = format("%s ERRO ao consultar o atributo '%s' do objeto '%s': %s", zs_metodo, argv[zi_h], zs_persid, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
zs_value = (string) msg[0];
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Valor atual do atributo '%s' do objeto '%s': '%s'", zs_metodo, argv[zi_h], zs_persid, msg[0]);
////////////////////////////////////////////////////
// COMPARANDO o valor atual com o novo valor
////////////////////////////////////////////////////
if (msg[0] != argv[zi_h+1] || (is_null(msg[0]) && !is_null(argv[zi_h+1])) || (!is_null(msg[0]) && is_null(argv[zi_h+1]))) {
// Se o valor atual eh DIFERENTE do novo valor, continua execucao
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s O valor atual do atributo '%s' ('%s') no objeto '%s' eh DIFERENTE do novo valor informado ('%s'). Continuando...", zs_metodo, argv[zi_h], msg[0], zs_persid, argv[zi_h+1]);
zi_atributos_alterados++; // Sinaliza que serao feitas modificacoes no objeto

// So obtem GL e faz checkout na primeira vez que um atributo for alterado
if (zi_atributos_alterados == 1) {
////////////////////////////////////////////////////
// Instanciando GROUP LEADER
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Instanciando Group leader...", zs_metodo);
send_wait(0, top_object(), "get_co_group");
if (msg_error()) {
zs_msg = format("%s ERRO ao instanciar GL: '%s'", zs_metodo, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
object zo_group_leader; 
zo_group_leader = msg[0];
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Group leader: '%s'", zs_metodo, (string) msg[0]);
////////////////////////////////////////////////////
// Fazendo CHECKOUT no objeto
////////////////////////////////////////////////////
while(zi_tentativas < zi_tentativas_limite && zi_tempo_atraso <= zi_tempo_limite) {
zi_tentativas++;
zi_tempo_atraso = zi_tempo_atraso * zi_fator;
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s BLOQUEANDO o objeto '%s'...", zs_metodo, zs_persid);
send_wait(0, zo_group_leader, "checkout", zo_objeto);
zs_msg_return = msg[0];
if (msg_error()) {
zi_errors++;
// Trata a mensagem de retorno do metodo send_wait
for (zi_i=0, zs_msg_return=""; zi_i<msg_length(); zi_i++) { if (zi_i==0) { zs_msg_return = format("%s", msg[zi_i]); } else if (!is_null(msg[zi_i])) { zs_msg_return += format(": %s", msg[zi_i]); } }
zs_msg = format("%s ERRO na %da tentativa de bloquear o objeto '%s': '%s'", zs_metodo, zi_tentativas, zs_persid, zs_msg_return);
logf(ERROR, "%s", zs_msg);
if (zi_tentativas == zi_tentativas_limite) {
return zs_msg;
}
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Aguardando %d segundos para tentar bloquear o objeto '%s' novamente...", zs_metodo, zi_tempo_atraso, zs_persid);
sleep(zi_tempo_atraso);

} else {
if (zi_depurar >= 1 || zi_errors > 0) logf(SIGNIFICANT, "%s Resultado do CHECKOUT no objeto '%s': '%s'", zs_metodo, zs_persid, zs_msg_return);
// reseta contadores de tentativas e tempo de atraso
zi_tentativas = 0;
zi_tempo_atraso = zi_tempo_atraso_padrao;
break;
}
} // Fim do WHILE
} // Fim do IF

// Verifica se o TEMPO LIMITE nao foi atingido
if (zi_tempo_atraso > zi_tempo_limite) {
zs_msg = format("%s ERRO na %da tentativa de bloquear o objeto '%s': TEMPO LIMITE atingido (%d).", zs_metodo, zi_tentativas, zs_persid, zi_tempo_limite);
logf(FATAL, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}

// Caso tenham ocorrido erros durante o processo
// E o valor de algum atributo tenha mudado desde a ultima verificacao
if (zi_errors > 0) {
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s AVISO: Ocorreram %d erros. Realizando verificacoes adicionais...", zs_metodo, zi_errors);
////////////////////////////////////////////////////
// VERIFICANDO VALOR ATUAL do atributo consultado
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s CONSULTANDO o valor atual do atributo '%s' no objeto '%s'...", zs_metodo, argv[zi_h], zs_persid);
send_wait(0, zo_objeto, "call_attr", argv[zi_h], "get_val"); 
if (msg_error()) {
zs_msg = format("%s ERRO ao consultar o atributo '%s' do objeto '%s': %s", zs_metodo, argv[zi_h], zs_persid, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
if ((string) msg[0] != zs_value) {
logf(ERROR, "%s ERRO: O valor atual do atributo '%s' do objeto '%s' nao coincide com o valor inicial '%s' consultado anteriormente: Encerrando metodo...", zs_metodo, argv[zi_h], zs_persid, zs_value);
logf(ERROR, "%s DESBLOQUEANDO o objeto '%s' devido a %d erros ocorridos...", zs_metodo, zs_persid, zi_errors);
send_wait(0, zo_group_leader, "uncheck", zo_objeto);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
}
////////////////////////////////////////////////////
// PERSISTINDO valores nos atributos
////////////////////////////////////////////////////
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s PERSISTINDO valor '%s' no atributo '%s' do objeto '%s'...", zs_metodo, argv[zi_h+1], argv[zi_h], zs_persid);
send_wait(0, zo_objeto, "call_attr", argv[zi_h], "set_val", argv[zi_h+1], zs_method_triggers);
//send_wait(0, top_object(), "call_attr", "api", "update_object", zu_who, "", zo_objeto, zo_group_leader, 0, argv[zi_h], argv[zi_h+1]);
if (msg_error()) {
zs_msg = format("%s ERRO ao persistir o valor '%s' no atributo '%s' do objeto '%s': '%s'", zs_metodo, argv[zi_h+1], argv[zi_h], zs_persid, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Resultado da alteracao do atributo '%s' no objeto '%s': '%s'", zs_metodo, argv[zi_h], zs_persid, (string) msg[0]);
} else {
// Se o valor atual eh IGUAL ao novo valor, ignora alteracao do atributo
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s O valor atual do atributo '%s' ('%s') no objeto '%s' eh IGUAL ao novo valor informado ('%s'). Ignorando alteracao...", zs_metodo, argv[zi_h], msg[0], zs_persid, argv[zi_h+1]);
}
} // Fim do IF
} // Fim do for
////////////////////////////////////////////////////
// Fazendo CHECKIN no objeto
////////////////////////////////////////////////////
if (zi_atributos_alterados > 0) { // So faz checkin se algum atributo foi alterado
while(zi_tentativas < zi_tentativas_limite && zi_tempo_atraso <= zi_tempo_limite) {
zi_tentativas++;
zi_tempo_atraso = zi_tempo_atraso * zi_fator;
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s DESBLOQUEANDO o objeto '%s'...", zs_metodo, zs_persid);
send_wait(0, zo_group_leader, "checkin", zo_objeto);
zs_msg_return = msg[0];
if (msg_error()) {
zi_errors++;
// Trata a mensagem de retorno do metodo send_wait
for (zi_i=0, zs_msg_return=""; zi_i<msg_length(); zi_i++) { if (zi_i==0) { zs_msg_return = format("%s", msg[zi_i]); } else if (!is_null(msg[zi_i])) { zs_msg_return += format(": %s", msg[zi_i]); } }
zs_msg = format("%s ERRO na %da tentativa de desbloquear o objeto '%s': '%s'", zs_metodo, zi_tentativas, zs_persid, zs_msg_return);
logf(ERROR, "%s", zs_msg);
if (zi_tentativas == zi_tentativas_limite) {
logf(ERROR, "%s DESBLOQUEANDO o objeto '%s' devido a %d erros ocorridos...", zs_metodo, zs_persid, zi_errors);
send_wait(0, zo_group_leader, "uncheck", zo_objeto);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Aguardando %d segundos para tentar desbloquear o objeto '%s' novamente...", zs_metodo, zi_tempo_atraso, zs_persid);
sleep(zi_tempo_atraso);

} else {
if (zi_depurar >= 1 || zi_errors > 0) logf(SIGNIFICANT, "%s Resultado do CHECKIN no objeto '%s': '%s'", zs_metodo, zs_persid, zs_msg_return);
// reseta contadores de tentativas e tempo de atraso
zi_tentativas = 0;
zi_tempo_atraso = zi_tempo_atraso_padrao;
break;
}
} // Fim do WHILE
} else {
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s AVISO: Nao foi necessario nenhuma alteracao de atributo no objeto '%s'. Encerrando metodo...", zs_metodo, zs_persid);
}
////////////////////////////////////////////////////
// RESUMO DA EXECUCAO
////////////////////////////////////////////////////
if (zi_depurar >= 1) {
if (zs_method_triggers == "SURE_SET") {
logf(SIGNIFICANT, "%s Quantidade de atributos INFORMADOS: %d", zs_metodo, (zi_count_atributos-3)/2);
} else {
logf(SIGNIFICANT, "%s Quantidade de atributos INFORMADOS: %d", zs_metodo, (zi_count_atributos-5)/2);
}
logf(SIGNIFICANT, "%s Quantidade de atributos ALTERADOS : %d", zs_metodo, zi_atributos_alterados);
if (zi_errors > 0) {
logf(SIGNIFICANT, "%s Quantidade de ERROS ocorridos : %d", zs_metodo, zi_errors);
}
}
z_bloco_fim(zi_depurar, zs_metodo);
return "OK";
// Fim do codigo
/////////////////////////////////// 
}

int z_randomize(...) {
////////////////////////////////////////////////////////////////////////////////
// Metodo: z_randomize
// Criado em: 27/02/2015
// Autor: Daniel Becker Bighelini
// Modificado em: 22/04/2015
// Modificado por: Daniel Becker Bighelini
////////////////////////////////////////////////////////////////////////////////
// Parametros:
// arg[0] : (int) zi_size = Define a quantidade de digitos do numero que sera gerado.
// arg[1] : (int) zi_depurar = Define o nivel de depuracao da funcao (0=Desligado, 1=Log resumido, 2=Log detalhado, 3=Super detalhado). Se omitido, valor sera 0.
// arg[2] : (string) zs_metodo = Define o nome do metodo que esta chamando este metodo.
//
// Descricao:
// Gera um numero de um tamanho especifico baseado em um numero aleatoria gerado.
//
// Exemplo:
// z_randomize(2, 1, 'nome do metodo')
////////////////////////////////////////////////////////////////////////////////
// Variaveis utilizadas pelos parametros do metodo
string zs_metodo;
int zi_size, zi_i, zi_depurar;

// Atribuindo variaveis
if (argc>0) zi_size = (int) argv[0];
if (argc>1) zi_depurar = (int) argv[1];
if (argc>2) zs_metodo = (string) argv[2];
// Define os valores default das variaveis caso nao sejam informadas
if (is_null(zi_size) || zi_size == 0) zi_size = 1; // Define o valor default do tamanho do numero caso nao informado
if (is_null(zi_depurar)) zi_depurar = 0; // Define o valor default da depuracao caso nao informado
if (is_null(zs_metodo)) { zs_metodo = 'z_randomize - '; } else { zs_metodo += ' z_randomize - '; }

// Entrada para debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i+=1) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
//logf(SIGNIFICANT, "%s '%s'", zs_metodo, zi_size);
}
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo

/////////////////////////////////
// Atribuindo VARIAVEIS iniciais
/////////////////////////////////
int zi_number_in, zi_number_out, zi_number_compl;
int zi_start, zi_count, zi_limit_loop, zi_limit_int, zi_limit_size;
string zs_number_in;
zi_count = 0;
zi_limit_loop = 500;
zi_limit_int = 2147483647; // Maior numero possivel em variaveis 'int'
zi_limit_size = 10; // Quantidade maxima de digitos em relacao ao maior numero possivel
zi_number_in = (int) thread_object_ptr(); // Captura o numero do ponteiro do objeto
zi_number_out = 0;

// Verifica se a quantidade de digitos informada nao ultrapassa o limite maximo
if (zi_size > zi_limit_size) {
if ( zi_depurar>=1 ) logf(SIGNIFICANT, format("%s AVISO: A quantidade de digitos informada (%d) NAO eh permitida. Redefinindo o parametro para o valor %d...", zs_metodo, zi_size, zi_limit_size));
zi_size = 10;
}

// Verifica se a quantidade de digitos informada nao ultrapassa o tamanho do numero gerado
if (zi_size > strlen((string) zi_number_in)) {
if ( zi_depurar>=1 ) logf(SIGNIFICANT, format("%s AVISO: A quantidade de digitos informada (%d) nao eh possivel em relacao ao numero gerado (%d). Complementando numero...", zs_metodo, zi_size, zi_number_in));
zi_number_compl = (int) substr((string) zi_number_in, 0, zi_size - strlen((string) zi_number_in));
if ( zi_depurar>=1 ) logf(SIGNIFICANT, format("%s AVISO: Complemento: %d", zs_metodo, zi_number_compl));
zi_number_in = (int) format("%d%d", zi_number_in, zi_number_compl);
if ( zi_depurar>=1 ) logf(SIGNIFICANT, format("%s AVISO: Numero inicial complementado: %d", zs_metodo, zi_number_in));
}

/////////////////////////////////
// GERA O NUMERO com a quantidade de digitos solicitadas ate encontrar
/////////////////////////////////
while (strlen((string) zi_number_out) != zi_size && zi_count <= zi_limit_loop || zi_number_out == 0) {
if ( zi_depurar>=1 ) logf(SIGNIFICANT, format("%s Calculando...", zs_metodo));
zi_count += 1;
zi_number_in += zi_count; // Soma o numero gerado com o contador
zs_number_in = (string) zi_number_in; // Converte a numero em string
zi_start = strlen(zs_number_in) - zi_size; // Define em que posicao da string sera iniciada a captura dos digitos
zi_number_out = (int) substr(zs_number_in, zi_start, zi_size); // Armazena o numero gerado
}

// Caso o numero gerado nao possua o numero de digitos solicitado, complementa o numero com o primeiro digito de entrada
if (strlen((string) zi_number_out) != zi_size) {
if ( zi_depurar>=1 ) logf(SIGNIFICANT, format("%s AVISO: O limite de tentativas foi ultrapassado (%d). Complementando o numero com o primeiro digito...", zs_metodo, zi_limit_loop));
zi_number_out = (int) format("%d%d", zi_number_in, (int) substr(zs_number_in, 0, 1));
}

// Caso o numero gerado nao possua o numero de digitos solicitado, complementa o numero com o primeiro digito de entrada
if (zi_number_out < 0) {
if ( zi_depurar>=1 ) logf(SIGNIFICANT, format("%s AVISO: O numero eh invalido pois ultrapassou o limite da variavel (%d). Redefinindo...", zs_metodo, zi_limit_int));
zi_number_out = zi_limit_int - zi_number_compl;
}

/////////////////////////////////
// Exibe o RESUMO da execucao
/////////////////////////////////
if ( zi_depurar>=1 ) {
logf(SIGNIFICANT, format("%s Tentativas necessarias : %d", zs_metodo, zi_count));
logf(SIGNIFICANT, format("%s Numero de entrada : %d", zs_metodo, zi_number_in));
logf(SIGNIFICANT, format("%s Quantidade de digitos : %s", zs_metodo, zi_size));
logf(SIGNIFICANT, format("%s Numero de saida : %s", zs_metodo, zi_number_out));
}

z_bloco_fim(zi_depurar, zs_metodo);
return zi_number_out;
// Fim do codigo
/////////////////////////////////// 
}

string z_consulta_producer(string zs_persid, int zi_depurar, string zs_metodo)
{
////////////////////////////////////////////////////////////////////////
// Metodo: z_consulta_producer
// Autor: Daniel Becker Bighelini
// Criado em: 04/04/2014
// Modificado por: Daniel Becker Bighelini
// Modificado em: 17/04/2015
//
// Descricao: Consulta o producer de um objeto
//
// Parametros:
// zs_persid Persid do objeto
// zi_depurar Nivel de depuracao da funcao 0-nenhum / 1-resumido / 2-detalhado)
// zs_metodo Nome do metodo que sera identificado no bloco
//
// Exemplos:
// z_consulta_producer("chg:999999", 1, "nome do metodo")
//
////////////////////////////////////////////////////////////////////////
int zi_i;
// Atribuindo variaveis
zs_metodo += ' z_consulta_producer - ';
// Entrada para debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i+=1) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
//logf(SIGNIFICANT, "%s '%s'", zs_metodo, zs_persid);
}
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
////////////////////////////////////////////////////
// IDENTIFICANDO o producer do objeto
////////////////////////////////////////////////////
if (zi_depurar >= 3) logf(SIGNIFICANT, "%s Identificando 'producer' do objeto '%s'...", zs_metodo, zs_persid);
string zs_producer;
zs_producer = substr(zs_persid, 0, sindex(zs_persid, ":"));
if (sindex(zs_persid, ":") == -1) {
string zs_msg;
zs_msg = format("%s ERRO ao identificar o producer do objeto '%s': %s", zs_metodo, zs_persid, sindex(zs_persid, ":"));
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
if (zi_depurar >= 3) logf(SIGNIFICANT, "%s Producer do objeto '%s': '%s'", zs_metodo, zs_persid, zs_producer);
return zs_producer;
// Fim do codigo
/////////////////////////////////// 
}

string z_consulta_tipo_atributo(string zs_producer, string zs_attribute, int zi_depurar, string zs_metodo)
{
////////////////////////////////////////////////////////////////////////
// Metodo: z_consulta_tipo_atributo
// Autor: Daniel Becker Bighelini
// Criado em: 31/03/2015
// Modificado por: Daniel Becker Bighelini
// Modificado em: 22/04/2015
//
// Descricao: Consulta o tipo de dado de um atributo.
//
// Parametros:
// zs_producer Nome da factory do atributo
// zs_attribute Nome do atributo que sera consultado
// zi_depurar Nivel de depuracao da funcao 0-nenhum / 1-resumido / 2-detalhado)
// zs_metodo Nome do metodo que sera identificado no bloco
//
// Exemplos:
// z_consulta_tipo_atributo("chg", "status", 1, "nome do metodo")
//
////////////////////////////////////////////////////////////////////////
int zi_i;

// Atribuindo variaveis
zs_metodo += ' z_consulta_tipo_atributo - ';
// Entrada para debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i+=1) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
//logf(SIGNIFICANT, "%s '%s'", zs_metodo, zs_producer);
}
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
////////////////////////////////////////////////////
// Consultando o TIPO DE DADO da LISTA DE ATRIBUTOS do producer
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Consultando o tipo de dado do atributo '%s' do producer '%s'...", zs_metodo, zs_attribute, zs_producer);
send_wait(0, top_object(), "call_attr", zs_producer, "dob_attr_type_info", zs_attribute);
if (msg_error()) { 
string zs_msg;
zs_msg = format("%s ERRO ao consultar o tipo de dado armazenado no atributo '%s' do producer '%s': %s", zs_metodo, zs_attribute, zs_producer, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
int zi_count_list;
zi_count_list = msg_length();
string zs_attribute_type;
zs_attribute_type = "";
for (zi_i=0; zi_i<zi_count_list; zi_i++) {
if (zi_depurar >= 3) logf(SIGNIFICANT, "%s msg[%s] = %s", zs_metodo, zi_i, msg[zi_i]);
zs_attribute_type += (string) msg[zi_i] + "@;@";
}
z_bloco_fim(zi_depurar, zs_metodo);
return zs_attribute_type;
// Fim do codigo
/////////////////////////////////// 
}

string z_consulta_valor(string zs_persid, string zs_attribute, int zi_depurar, string zs_metodo)
{
////////////////////////////////////////////////////////////////////////
// Metodo: z_consulta_producer
// Autor: Daniel Becker Bighelini
// Criado em: 01/04/2014
// Modificado por: Daniel Becker Bighelini
// Modificado em: 10/04/2015
//
// Descricao: Consulta o valor de um atributo atraves do persid.
//
// Parametros:
// zs_persid Persid do objeto
// zs_attribute Atributo que sera consultado
// zi_depurar Nivel de depuracao da funcao 0-nenhum / 1-resumido / 2-detalhado)
// zs_metodo Nome do metodo que sera identificado no bloco
//
// Exemplos:
// z_consulta_valor("chg:999999", "description", 1, "nome do metodo")
//
////////////////////////////////////////////////////////////////////////
int zi_i;
// Atribuindo variaveis
zs_metodo += ' z_consulta_valor - ';

// Entrada para debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i+=1) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
logf(SIGNIFICANT, "%s '%s'", zs_metodo, zs_persid);
}
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
////////////////////////////////////////////////////
// Identificando o PRODUCER
////////////////////////////////////////////////////
if (zi_depurar >= 3) logf(SIGNIFICANT, "%s Identificando 'producer' do objeto '%s'...", zs_metodo, zs_persid);
string zs_producer;
zs_producer = z_consulta_producer(zs_persid, zi_depurar, zs_metodo);
////////////////////////////////////////////////////
// CONSULTANDO o valor do atributo
////////////////////////////////////////////////////
if (zi_depurar >= 3) logf(SIGNIFICANT, "%s Consultando o atributo '%s' do objeto '%s' do producer '%s'...", zs_metodo, zs_attribute, zs_persid, zs_producer);
send_wait(0, top_object(), "call_attr", zs_producer, "val_by_key", "persistent_id", zs_persid, (int) 1, zs_attribute);
if (msg_error()) {
string zs_msg;
zs_msg = format("%s ERRO ao consultar o atributo '%s' do objeto '%s' do producer '%s': %s", zs_metodo, zs_attribute, zs_persid, zs_producer, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Valor do atributo '%s' do objeto '%s': '%s'", zs_metodo, zs_attribute, zs_persid, msg[1]);
return (string) msg[1];
// Fim do codigo
/////////////////////////////////// 
}

uuid z_identifica_usuario_logado(int zi_depurar, string zs_metodo)
{
////////////////////////////////////////////////////////////////////////
// Metodo: z_identifica_usuario_logado
// Autor: Daniel Becker Bighelini
// Criado em: 17/04/2015
// Modificado por: Daniel Becker Bighelini
// Modificado em: 26/04/2016
//
// Descricao: Identifica o id do usuario logado.
//
// Parametros:
// arg[0] : (int) zi_depurar = Define o nivel de depuracao da funcao (0=Desligado, 1=Log resumido, 2=Log detalhado, 3=Super detalhado).
// arg[1] : (string) zs_metodo = Define o nome do metodo que esta chamando este metodo.
//
// Exemplos:
// z_identifica_usuario_logado(1, "metodo chamador")
//
////////////////////////////////////////////////////////////////////////
// Variaveis globais do metodo
int zi_i;

// Atribuindo variaveis
zs_metodo += ' z_identifica_usuario_logado - ';
// Entrada para debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i+=1) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
//logf(SIGNIFICANT, "%s", zs_metodo);
}
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
////////////////////////////////////////////////////
// CONSULTANDO usuario logado
////////////////////////////////////////////////////
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Identificando usuario logado...", zs_metodo);
send_wait(0, top_object(), "call_attr", "cnt", "current_user_id");
if (msg_error()) {
logf(ERROR, "%s ERRO ao identificar usuario logado: '%s'", msg[0]);
z_bloco_fim(zi_depurar, zs_metodo);
return;
}
uuid zu_login_userid;
zu_login_userid = msg[0];
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Usuario logado: %s", zs_metodo, zu_login_userid);
z_bloco_fim(zi_depurar, zs_metodo);
return zu_login_userid;
// Fim do codigo
/////////////////////////////////// 
}

string z_consulta_factory_info(string zs_factory, string zs_info, int zi_depurar, string zs_metodo)
{
////////////////////////////////////////////////////////////////////////
// Metodo: z_consulta_factory_info
// Autor: Daniel Becker Bighelini
// Criado em: 27/05/2015
// Modificado por: Daniel Becker Bighelini
// Modificado em: 29/05/2015
//
// Descricao: Consulta uma informacao da factory dos tipos Producers, Rel Attr,
// Common Name, Func Group, Display Name, UI_INFO, Display Group,
// REST Operations, Triggers, Methods, Schema Name, DBMS Name,
// Tenancy, Base Object, Attributes==ALL, Attributes==REQUIRED.
//
// Parametros:
// zs_factory Nome da factory
// zs_info Informacao da factory
// zi_depurar Nivel de depuracao da funcao 0-nenhum / 1-resumido / 2-detalhado)
// zs_metodo Nome do metodo que sera identificado no bloco
//
// Exemplos:
// z_consulta_factory_info("chg", "Common Name", 1, "nome do metodo")
//
////////////////////////////////////////////////////////////////////////
int zi_i;
string zs_msg;
// Atribuindo variaveis
zs_metodo += ' z_consulta_factory_info - ';
// Entrada para debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i+=1) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
//logf(SIGNIFICANT, "%s '%s'", zs_metodo, zs_persid);
}
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
////////////////////////////////////////////////////
// IDENTIFICANDO as informacoes da factory
////////////////////////////////////////////////////
string zs_info_value, zs_factory_attributes;
zs_factory_attributes = '';

if (zs_info == "Attributes==ALL") { // Todos atributos
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Identificando a lista de atributos da factory '%s'...", zs_metodo, zs_factory);
send_wait(0, top_object(), "call_attr", zs_factory, "dob_attr_list");
if (msg_error()) {
zs_msg = format("%s ERRO ao obter a lista de atributos da factory '%s': '%s'", zs_metodo, zs_factory, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}

if (msg_length() > 1) {
for (zi_i=1; zi_i<msg_length(); zi_i++) {
zs_factory_attributes += msg[zi_i] + '; ';
}
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Lista de atributos da factory '%s': %s", zs_metodo, zs_factory, zs_factory_attributes);
}
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Numero de atributos encontrados na factory '%s': %s", zs_metodo, zs_factory, msg_length()-1);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_factory_attributes;

} else if (zs_info == "Attributes==REQUIRED") { // Todos atributos OBRIGATORIOS
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Identificando a lista de atributos OBRIGATORIOS da factory '%s'...", zs_metodo, zs_factory);
send_wait(0, top_object(), "call_attr", zs_factory, "dob_attr_list", "type_info", "extended");
if (msg_error()) {
zs_msg = format("%s ERRO ao obter a lista de atributos OBRIGATORIOS da factory '%s': '%s'", zs_metodo, zs_factory, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}

zi_i = 1;
string zs_attr_name, zs_attr_type, zs_attr_required, zs_attr_on_new;

while (zi_i < msg_length()) {
zs_attr_name = msg[zi_i];
zs_attr_type = msg[zi_i+1];
zs_attr_required = "";
zs_attr_on_new = "";

if (zs_attr_type == "VALUE") {
zs_attr_required = msg[zi_i+5];
zs_attr_on_new = msg[zi_i+9];
zi_i += 19;
} else if (zs_attr_type == "SREL") {
zs_attr_required = msg[zi_i+5];
zs_attr_on_new = msg[zi_i+10];
zi_i += 20;
} else if (zs_attr_type == "QREL") {
zi_i += 13;
} else if (zs_attr_type == "LREL") {
zi_i += 7;
}
if (zs_attr_required == "Required" && strlen(zs_attr_on_new) == 0) zs_factory_attributes += zs_attr_name + '; ';
}
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Lista de atributos OBRIGATORIOS da factory '%s': %s", zs_metodo, zs_factory, zs_factory_attributes);

z_bloco_fim(zi_depurar, zs_metodo);
return zs_factory_attributes;
}
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Consultando factory '%s'...", zs_metodo, zs_factory);
send_wait(0, top_object(), "attr_type_info", zs_factory, "extended");
if (msg_error() || msg_length() < 15) {
zs_msg = format("%s ERRO ao consultar a factory '%s': %s", zs_metodo, zs_factory, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
if (zs_info == "ALL") { // Todas informacoes
for (zi_i = 0; zi_i < msg_length(); zi_i++) {
zs_info_value += (string) msg[zi_i] + "@;@";
}
} else if (zs_info == "Producers") { // msg[0]
send_wait(0, top_object(), "call_attr", zs_factory, "attr_list");
int zi_count;
zi_count = msg[0];
for (zi_i = 0; zi_i < zi_count; zi_i++) {
zs_info_value += (string) msg[zi_i+1] + " ";
}
} else if (zs_info == "Rel Attr") { // msg[3]
zs_info_value = msg[3];
} else if (zs_info == "Common Name") { // msg[4]
zs_info_value = msg[4];
} else if (zs_info == "Func Group") { // msg[5]
zs_info_value = msg[5];
} else if (zs_info == "Display Name") { // msg[6]
zs_info_value = msg[6];
} else if (zs_info == "UI_INFO") { // msg[7]
zs_info_value = msg[7];
} else if (zs_info == "Display Group") { // msg[9]
zs_info_value = msg[9];
} else if (zs_info == "REST Operations") { // msg[10]
zs_info_value = msg[10];
} else if (zs_info == "Triggers") { // msg[11]
zs_info_value = msg[11];
} else if (zs_info == "Methods") { // msg[12]
zs_info_value = msg[12];
} else if (zs_info == "Schema Name") { // msg[13]
zs_info_value = msg[13];
} else if (zs_info == "DBMS Name") { // msg[14]
zs_info_value = msg[14];
} else if (zs_info == "Tenancy") { // msg[16]
zs_info_value = msg[16];
} else if (zs_info == "Base Object") { // msg[17]
zs_info_value = msg[17];
} else {
zs_msg = format("%s ERRO ao identificar a informacao da factory '%s'. O parametro '%s' NAO existe.", zs_metodo, zs_factory, zs_info);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}

if (zi_depurar >= 1) logf(SIGNIFICANT, "%s '%s' da factory '%s': '%s'", zs_metodo, zs_info, zs_factory, zs_info_value);

z_bloco_fim(zi_depurar, zs_metodo);
return zs_info_value;
// Fim do codigo
/////////////////////////////////// 
}

string z_notifica_contato(int zi_depurar, string zs_metodo, string zs_rcpt, int zi_evt_level, string zs_subject, string zs_body, string zs_persid, string zs_body_html)
{
////////////////////////////////////////////////////////////////////////
// Metodo: z_notifica_contato
// Autor: Daniel Becker Bighelini
// Criado em: 14/03/2016
// Modificado por: Daniel Becker Bighelini
// Modificado em: 20/05/2016
//
// Parametros de entrada:
// ARG #0 : (int) zi_depurar
// ARG #1 : (string) zs_metodo
// ARG #2 : (string) zs_rcpt
// ARG #3 : (int) zi_evt_level
// ARG #4 : (string) zs_subject
// ARG #5 : (string) zs_body
// ARG #6 : (string) zs_persid
// ARG #7 : (string) zs_body_html
// 
// Resultado:
// Notifica contatos.
////////////////////////////////////////////////////////////////////////
// Atribuindo variaveis globais
string zs_msg;
int zi_i;
zs_metodo = 'z_notifica_contato - ';
// Entrada para debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i+=1) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
logf(SIGNIFICANT, "%s '%s'", zs_metodo, zs_rcpt);
}
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo

////////////////////////////////////////////////////
// Definindo o TIPO DE NOTIFICACAO
////////////////////////////////////////////////////
int zi_trans_pt;
if (sindex(zs_persid, "chg:") > -1 || sindex(zs_persid, "iss:") > -1) {
zi_trans_pt = 29;
} else if (sindex(zs_persid, "cr:") > -1 || sindex(zs_persid, "iss:") > -1) {
zi_trans_pt = 28;
} else {
zi_trans_pt = 0;
}

////////////////////////////////////////////////////
// Definindo o NIVEL DE NOTIFICACAO da mensagem
////////////////////////////////////////////////////
if (is_empty(zi_evt_level)) {
zi_evt_level = 2; // Normal
}

////////////////////////////////////////////////////
// Definindo se a mensagem eh INTERNA
////////////////////////////////////////////////////
int zi_is_internal;
zi_is_internal = 0;
////////////////////////////////////////////////////
// Definindo DESTINATARIOS da mensagem
////////////////////////////////////////////////////
if (is_empty(zs_rcpt)) { // se estiver VAZIO
zs_msg = format("%s ERRO ao identificar contato. O destinatario NAO foi informado e esta VAZIO.", zs_metodo);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return;

} else if (sindex(zs_rcpt, ":") == -1) { // senao for informado um persid
string zs_rcpt_persid;
zs_rcpt_persid = expand(format("&{%s = cnt.last_name->persistent_id}", zs_rcpt));
if (is_empty(zs_rcpt_persid)) {
zs_msg = format("%s ERRO ao identificar persistent_id do contato '%s'.", zs_metodo, zs_rcpt);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return;
}
zs_rcpt = zs_rcpt_persid;
} else {
zs_rcpt = zs_rcpt;
}

////////////////////////////////////////////////////
// CONSOLIDANDO DESTINATARIOS
////////////////////////////////////////////////////
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Destinatarios: '%s'", zs_metodo, zs_rcpt);

////////////////////////////////////////////////////
// NOTIFICA o grupo ou responsavel pela categoria
////////////////////////////////////////////////////
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Enviando mensagem para os destinatarios '%s'...", zs_metodo, zs_rcpt);
send_wait(0, top_object(), "call_attr", "cnt", "notify_list", zs_rcpt, zi_evt_level, zs_subject, zs_body, "", zi_trans_pt, zs_persid, zi_is_internal, 0, zs_body_html);
if (msg_error()) { 
zs_msg = format("%s ERRO ao enviar mensagem: %s", zs_metodo, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}

z_bloco_fim(zi_depurar, zs_metodo);
// Fim do codigo
/////////////////////////////////// 
}

string z_replace_doublebyte (string str, string zs_metodo, int zi_depurar)
{
////////////////////////////////////////////////////////////////////////
// Metodo: z_replace_doublebyte
// Autor: Daniel Becker Bighelini
// Criado em: 25/07/2016
// Modificado por: Daniel Becker Bighelini
// Modificado em: 25/07/2016
//
// Parametros de entrada:
// ARG #0 : (string) str String que deve ser convertida
// ARG #1 : (string) zs_metodo Nome do metodo que chamou este metodo
// ARG #1 : (int) zi_depurar Nivel de depuracao da funcao 0-nenhum / 1-resumido / 2-detalhado
//
// Descri?:
// Substitui todos os caracteres especiais da string por caracteres nao estendidos.
//
// Exemplo:
// z_replace_doublebyte('dániel', 'metodo', 1) // daniel
////////////////////////////////////////////////////////////////////////
int zi_i;
zs_metodo += " z_replace_doublebyte";
// Entrada para debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i+=1) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
// logf(SIGNIFICANT, "%s", zs_metodo);
}
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
if (zi_depurar > 0) logf(SIGNIFICANT, "%s ENTRADA = '%s'", zs_metodo, str);
string n;
n = str;
n = gsub(n, '[\164-\191]', '?'); // outros simbolos
n = gsub(n, '[\192-\198]', 'A');
n = gsub(n, '[\199]', 'C');
n = gsub(n, '[\200-\203]', 'E');
n = gsub(n, '[\204-\207]', 'I');
n = gsub(n, '[\208]', 'D');
n = gsub(n, '[\209]', 'N');
n = gsub(n, '[\210-\214]', 'O');
n = gsub(n, '[\215]', 'x');
n = gsub(n, '[\216]', '0');
n = gsub(n, '[\217-\220]', 'U');
n = gsub(n, '[\221]', 'Y');
n = gsub(n, '[\222|\254]', 'p');
n = gsub(n, '[\223]', 'B');
n = gsub(n, '[\224-\230]', 'a');
n = gsub(n, '[\231]', 'c');
n = gsub(n, '[\232-\235]', 'e');
n = gsub(n, '[\236-\239]', 'i');
n = gsub(n, '[\241]', 'n');
n = gsub(n, '[\240|\242-\246]', 'o');
n = gsub(n, '[\247]', '/');
n = gsub(n, '[\248]', '0');
n = gsub(n, '[\249-\252]', 'u');
n = gsub(n, '[\253|\255]', 'y');

if (zi_depurar > 0) logf(SIGNIFICANT, "%s SAIDA = '%s'", zs_metodo, n);
return n;
// Fim do codigo
/////////////////////////////////// 
}

string z_replace_doublebyte_utf8 (string str, string zs_metodo, int zi_depurar)
{
////////////////////////////////////////////////////////////////////////
// Metodo: z_replace_doublebyte_utf8
// Autor: Daniel Becker Bighelini
// Criado em: 25/07/2016
// Modificado por: Daniel Becker Bighelini
// Modificado em: 25/07/2016
//
// Parametros de entrada:
// ARG #0 : (string) str String que deve ser convertida
// ARG #1 : (string) zs_metodo Nome do metodo que chamou este metodo
// ARG #1 : (int) zi_depurar Nivel de depuracao da funcao 0-nenhum / 1-resumido / 2-detalhado
//
// Descri?:
// Substitui todos os caracteres especiais da string por caracteres nao estendidos no modo UTF8.
//
// Exemplo:
// z_replace_doublebyte_utf8('dániel', 'metodo', 1) // daniel
////////////////////////////////////////////////////////////////////////
int zi_i;
zs_metodo += " z_replace_doublebyte_utf8";

// Entrada para debug mode
if ( zi_depurar>=1 ) {
z_bloco_inicio(zi_depurar, zs_metodo);
logf(SIGNIFICANT, "%s Quant. de argumentos : %d", zs_metodo, argc);
for (zi_i=0; zi_i<argc; zi_i+=1) {
logf(SIGNIFICANT, "%s ARG #%s : %s", zs_metodo, zi_i, argv[zi_i]);
}
} else {
// logf(SIGNIFICANT, "%s", zs_metodo);
}
///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
if (zi_depurar > 0) logf(SIGNIFICANT, "%s ENTRADA = '%s'", zs_metodo, str);
string n;
n = str;
n = gsub(n, '\194[\1-\255]', '?'); // outros simbolos
n = gsub(n, '\198[\1-\255]', '?'); // outros simbolos
n = gsub(n, '\195[\1-\127]', '?'); // outros simbolos
n = gsub(n, '\195[\128-\134]', 'A');
n = gsub(n, '\195[\135]', 'C');
n = gsub(n, '\195[\136-\139]', 'E');
n = gsub(n, '\195[\140-\143]', 'I');
n = gsub(n, '\195[\144]', 'D');
n = gsub(n, '\195[\145]', 'N');
n = gsub(n, '\195[\146-\150]', 'O');
n = gsub(n, '\195[\151]', 'X');
n = gsub(n, '\195[\152]', '0');
n = gsub(n, '\195[\153-\156]', 'U');
n = gsub(n, '\195[\157]', 'Y');
n = gsub(n, '\195[\158|\190]', 'p');
n = gsub(n, '\195[\159]', 'B');
n = gsub(n, '\195[\160-\166]', 'a');
n = gsub(n, '\195[\167]', 'c');
n = gsub(n, '\195[\168-\171]', 'e');
n = gsub(n, '\195[\172-\175]', 'i');
n = gsub(n, '\195[\177]', 'n');
n = gsub(n, '\195[\176|\178-\182]', 'o');
n = gsub(n, '\195[\183]', '/');
n = gsub(n, '\195[\184]', '0');
n = gsub(n, '\195[\185-\188]', 'u');
n = gsub(n, '\195[\189|\191]', 'y');

if (zi_depurar > 0) logf(SIGNIFICANT, "%s SAIDA = '%s'", zs_metodo, n);
return n;
// Fim do codigo
/////////////////////////////////// 
}

int z_contain_doublebyte (string str) {
string zs_metodo;
int zi_depurar;
zi_depurar = 0;
zs_metodo = "z_contain_doublebyte";

///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
if (zi_depurar > 0) logf(SIGNIFICANT, "%s %d", zs_metodo, sindex(str, '[\160-\255]') > -1 ? 1 : 0);
if (sindex(str, '[\160-\255]') > -1) {
return 1;
} else {
return 0;
}
// Fim do codigo
/////////////////////////////////// 
}

int z_contain_doublebyte_utf8 (string str) {
string zs_metodo;
int zi_depurar;
zi_depurar = 0;
zs_metodo = "z_contain_doublebyte_utf8";

///////////////////////////////////////////////////////////////////////////////////////
// Inicio do codigo
if (zi_depurar > 0) logf(SIGNIFICANT, "%s %d", zs_metodo, sindex(str, '\195[\1|\191]') > -1 ? 1 : 0);
if (sindex(str, '\195[\1|\191]') > -1) {
return 1;
} else {
return 0;
}
// Fim do codigo
/////////////////////////////////// 
}