CA SDM Brasil z_inclui_registro.spl

File uploaded by TMACUL Champion on Jan 30, 2017
Version 1Show Document
  • View in full screen mode

 

////////////////////////////////////////////////////////////////////////////
// Modulo: z_inclui_registro.spl
// Autor: Daniel Becker Bighelini
// Criado em: 19/05/2016
// Modificado por: Daniel Becker Bighelini
// Modificado em: 19/05/2016
////////////////////////////////////////////////////////////////////////////

string z_inclui_registro(...)
{
////////////////////////////////////////////////////////////////////////////////
// Metodo: z_inclui_registro
// Criado em: 19/07/2013
// Autor: Daniel Becker Bighelini
// Modificado em: 19/05/2016
// Modificado por: Daniel Becker Bighelini
////////////////////////////////////////////////////////////////////////////////
// Parametros:
// arg[0] : string zs_producer = Define o nome do objeto que sera criado.
// 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.
// arg[3] : string atributo1 = Define o nome do atributo do objeto que sera incluido.
// 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 incluido.
// arg[6] : variant valor atributo2 = Define o novo valor do atributo que sera definido no objeto.
// ... e assim sucessivamente de acordo com o numero de atributos informados.
//
// Descricao:
// Inclui um novo registro em qualquer objeto.
//
// Observacoes:
// - Inclua o atributo 'act_log' para personalizar a mensagem exibida no log de atividades quando
// o objeto criado for um ticket;
// - Inclua diversos atributos 'asset' para incluir um ou mais IC's nas mudancas ou ocorrencias;
// - Inclua o atributo 'template_name' para criar um ticket baseado em um template;
// - Para preencher propriedades em um ticket, utilize o atributo 'properties.0', 'properties.1'
// e assim sucessivamente de acordo com o numero de propriedades;
// - Tambem eh possivel preencher propriedades informando-as no formato "chave-valor" sendo que
// a chave é o 'label' da propriedade. Deve ser utilizado o separador '@;@' entre as propriedades
// e o sinal de igualdade (=) para atribuir os valores. Ex.: "Nome:=Daniel@;@Telefone:=999999"
// - Nao eh necessario informar os parametros em uma ordem mas o nome dos atributos deve ser
// informado de acordo com o padrao do objeto, isto eh, eh 'case-sensitive';
// - Este metodo pode ser utilizado para criar qualquer objeto na USD desde que o utilizador
// conheca o modelo de objeto em quaestao;
// - Em caso de sucesso, este metodo retorna o atributo persistent_id do objeto criado ou a
// mensagem de erro correspondente a falha encontrada;
// - Quanto mais alto o nivel de depuracao informado no parametro zi_depurar, maior sera o
// detalhamento exibido no log.
//
// Exemplos:
// z_inclui_registro('chg', 1, 'mudanca', 'category', 'zpro997', 'log_agent', 'F0B84DAE789F7C43A1A26BBCC46855AF', 'requestor', 'F0B84DAE789F7C43A1A26BBCC46855AF', 'group', 'EAA206766F102946A8396063C49CDB70', 'summary', 'Mudanca evolutiva na USD', 'description', 'Atualizar o sistema.', 'properties.0', 'PREENCHER', 'asset', '4DB85A585C97DA438AE1D0BDBB2D77E9', 'sched_start_date', '12/31/2013 12:30:00', 'sched_duration', 600)
// z_inclui_registro('in', 1, 'incidente', 'category', 'pcat:400010', 'log_agent', 'F0B84DAE789F7C43A1A26BBCC46855AF', 'customer', 'F0B84DAE789F7C43A1A26BBCC46855AF', 'z_srl_Organization', '5BB77A7D4E46F045A28CDA13D4E751A2', 'affected_resource', '4DB85A585C97DA438AE1D0BDBB2D77E9', 'urgency', 3, 'impact', 3, 'group', 'EAA206766F102946A8396063C49CDB70', 'summary', 'Problemas de acesso a USD', 'description', 'Os usuarios nao conseguem acessar o sistema', 'properties.0', '1.Sim', 'properties.1', '1.Sim')
// z_inclui_registro('iss', 1, 'ocorrencia', 'category', 'zpro0037', 'log_agent', 'ED4D469F18BC4943B940AB934D020C6D', 'requestor', 'ED4D469F18BC4943B940AB934D020C6D', 'properties.0', 'Cria?', 'properties.3', '192.168.0.1', 'properties.4', 'diogo.procergs.rs.gov.br', 'organization', 'EC6FEA1C754E01469D618B64DEB3F560', 'z_srl_task_parent', 421422)
// z_inclui_registro('cnt', 1, 'contato', 'last_name', 'Fulano da Silva', 'userid', 'fulano-silva')
// z_inclui_registro('iss', 1, 'ocorrencia', 'category', 'zpro9999', 'log_agent', 'ED4D469F18BC4943B940AB934D020C6D', 'requestor', 'ED4D469F18BC4943B940AB934D020C6D', 'organization', 'EC6FEA1C754E01469D618B64DEB3F560', 'properties', 'Nome:=Daniel Bighelini@;@Telefone:=99999999')
////////////////////////////////////////////////////////////////////////////////
// Variaveis utilizadas pelos parametros do metodo
string zs_metodo, zs_producer, zs_activity_log, zs_template;
int zi_depurar, zi_count_atributos;

// Variaveis globais do metodo
string zs_msg, zs_msg_return;
int zi_h, zi_i, zi_j;

// Atribuindo variaveis
zs_producer = (string) argv[0];
zi_depurar = (int) argv[1];
zs_metodo = (string) argv[2] + ' z_inclui_registro - ';
zi_count_atributos = argc;

// 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

////////////////////////////////////////////////////
// Identificando o ID do USUARIO LOGADO
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Identificando usuario logado...", zs_metodo);
uuid zu_login_userid;
zu_login_userid = z_identifica_usuario_logado(zi_depurar, zs_metodo);
if (is_null(zu_login_userid)) {
zs_msg = format("%s ERRO ao identificar o usuario logado.", zs_metodo);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s ID do usuario logado: %s", zs_metodo, zu_login_userid);

////////////////////////////////////////////////////
// Identificando se o registro sera um TICKET
////////////////////////////////////////////////////
int zi_is_ticket;
if (zs_producer == 'cr' || zs_producer == 'in' || zs_producer == 'pr' || zs_producer == 'iss' || zs_producer == 'chg') {
zi_is_ticket = 1;
} else {
zi_is_ticket = 0;
}

////////////////////////////////////////////////////
// Identificando a LISTA DE ATRIBUTOS do producer
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Identificando a lista de atributos do producer '%s'...", zs_metodo, zs_producer);
send_wait( 0, top_object(), "call_attr", zs_producer, "dob_attr_list");
if (msg_error()) {
zs_msg = format("%s ERRO ao obter a lista de atributos do producer '%s': '%s'", zs_metodo, zs_producer, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
int zi_count_list_atr;
zi_count_list_atr = msg_length();
string zs_atributos_producer_lista[300], zs_atributos_producer;
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Numero de atributos encontrados no producer '%s': %s", zs_metodo, zs_producer, zi_count_list_atr-1);
for (zi_i=1; zi_i<zi_count_list_atr; zi_i++) {
if (zi_depurar >= 3) logf(SIGNIFICANT, "%s msg[%s] = %s", zs_metodo, zi_i, msg[zi_i]);
zs_atributos_producer_lista[zi_i] = msg[zi_i];
zs_atributos_producer = zs_atributos_producer + zs_atributos_producer_lista[zi_i] + ';';
}
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Lista de atributos do producer '%s': %s", zs_metodo, zs_producer, zs_atributos_producer);

////////////////////////////////////////////////////
// Identificando QUAIS ATRIBUTOS SAO OBRIGATORIOS
// no novo registro do producer
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Identificando quais atributos sao obrigatorios no producer '%s'...", zs_metodo, zs_producer);
string zs_atributos_requeridos_producer;
int zi_atributos_requeridos_producer, zi_count_list;
zi_atributos_requeridos_producer = 0;
for (zi_h=1; zi_h<zi_count_list_atr; zi_h++) {
////////////////////////////////////////////////////
// Consultando o TIPO DE DADO de cada atributo
////////////////////////////////////////////////////
if (zi_depurar >= 3) logf(SIGNIFICANT, "%s Consultando o tipo de dado do atributo '%s' do producer '%s'...", zs_metodo, zs_atributos_producer_lista[zi_h], zs_producer);
send_wait( 0, top_object(), "call_attr", zs_producer, "dob_attr_type_info", zs_atributos_producer_lista[zi_h]);
if (msg_error()) {
zs_msg = format("%s ERRO ao consultar o tipo de dado armazenado no atributo '%s' do producer '%s': %s", zs_metodo, zs_atributos_producer_lista[zi_h], zs_producer, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
zi_count_list = msg_length();
if (zi_depurar >= 3) {
for (zi_i=0; zi_i<zi_count_list; zi_i++) {
logf(SIGNIFICANT, "%s msg[%s] = %s", zs_metodo, zi_i, msg[zi_i]);
}
}

////////////////////////////////////////////////////
// Identificando PRODUCER DAS PROPRIEDADES que
// deve ser utilizada com o producer do objeto
////////////////////////////////////////////////////
if (zs_atributos_producer_lista[zi_h] == 'properties') {
string zs_producer_prp;
zs_producer_prp = msg[2];
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Producer do atributo '%s': '%s'.", zs_metodo, zs_atributos_producer_lista[zi_h], zs_producer_prp);
}

////////////////////////////////////////////////////
// Identificando o PRODUCER DA CATEGORIA
////////////////////////////////////////////////////
if (zs_atributos_producer_lista[zi_h] == 'category') {
string zs_producer_cat;
zs_producer_cat = msg[2];
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Producer do atributo '%s': '%s'.", zs_metodo, zs_atributos_producer_lista[zi_h], zs_producer_cat);
}

////////////////////////////////////////////////////
// Identificando o PRODUCER DO IC
////////////////////////////////////////////////////
if (zs_atributos_producer_lista[zi_h] == "asset") {
string zs_producer_asset;
zs_producer_asset = msg[2];
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Producer do atributo '%s': '%s'.", zs_metodo, zs_atributos_producer_lista[zi_h], zs_producer_asset);
}

////////////////////////////////////////////////////
// Identificando quais atributos sao OBRIGATORIOS
////////////////////////////////////////////////////
if (msg[5] == 'Required') {
zs_atributos_requeridos_producer += ' ' + zs_atributos_producer_lista[zi_h] + ';';
zi_atributos_requeridos_producer += 1;
}
}

// Informando sobre os atributos obrigatorios do producer
if (zi_atributos_requeridos_producer == 0) {
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Nenhum atributo eh obrigatorio no producer '%s'.", zs_metodo, zs_producer);
} else {
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Atributos obrigatorios do producer '%s' (%d): '%s'", zs_metodo, zs_producer, zi_atributos_requeridos_producer, zs_atributos_requeridos_producer);
}

////////////////////////////////////////////////////
// Verificando os ATRIBUTOS INFORMADOS
////////////////////////////////////////////////////
for (zi_h=3; zi_h<zi_count_atributos; zi_h+=2) {
////////////////////////////////////////////////////
// Verificando se os ATRIBUTOS OBRIGATORIOS foram
// INFORMADOS no metodo
////////////////////////////////////////////////////
zs_atributos_requeridos_producer = gsub(zs_atributos_requeridos_producer, ' ' + argv[zi_h] + ';', '');

////////////////////////////////////////////////////
// Identificando se o parametro TEMPLATE_NAME foi
// informado para que seja gerado o ticket conforme
// um ticket modelo
////////////////////////////////////////////////////
if (sindex(argv[zi_h], "template_name") != -1) {
zs_template = argv[zi_h+1];
////////////////////////////////////////////////////
// Identificando o PERSID DO MODELO DE TICKET utilizado
////////////////////////////////////////////////////
if (!is_null(zs_template)) {
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Localizando o modelo '%s' do producer '%s'...", zs_metodo, zs_template, zs_producer);
send_wait(0, top_object(), "call_attr", zs_producer, "val_by_key", "template_name", zs_template, (int) 1, "persistent_id");
if (msg_error()) {
zs_msg = format("%s ERRO ao localizar o ticket modelo '%s': '%s'", zs_metodo, zs_template, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
string zs_template_persid;
zs_template_persid = msg[1];
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Persid do modelo '%s': '%s'", zs_metodo, zs_template, zs_template_persid);

// Instanciando o objeto de template
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Instanciando o modelo '%s' do producer '%s'...", zs_metodo, zs_template, zs_producer);
send_wait(0, top_object(), "call_attr", zs_producer, "dob_by_persid", 0, zs_template_persid);
if (msg_error()) {
zs_msg = format("%s ERRO ao instanciar o modelo '%s': '%s'", zs_metodo, zs_template, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
object zo_template;
zo_template = msg[0];
}
}

////////////////////////////////////////////////////
// Identificando o ACT_LOG que sera registrado
////////////////////////////////////////////////////
if (sindex(argv[zi_h], "act_log") != -1) {
zs_activity_log = argv[zi_h+1];
}
}
// Exibindo AVISO caso algum atributo obrigatorio nao seja informado
if (is_empty(zs_atributos_requeridos_producer)) {
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Todos atributos obrigatorios do producer '%s' foram informados para o novo objeto. Continuando...", zs_metodo, zs_producer);
} else {
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s AVISO: Alguns atributos obrigatorios do producer '%s' nao foram informados para o novo objeto: '%s'", zs_metodo, zs_producer, zs_atributos_requeridos_producer);
}

////////////////////////////////////////////////////
// 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]);

////////////////////////////////////////////////////
// Cria NOVO registro
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Criando novo registro no producer '%s'...", zs_metodo, zs_producer);
send_wait( 0, top_object(), "call_attr", zs_producer, "get_new_dob", NULL, NULL, zo_group_leader);
if (msg_error()) {
zs_msg = format("%s ERRO ao submeter novo dob: '%s'", zs_metodo, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
object zo_objeto;
zo_objeto = msg[0];

////////////////////////////////////////////////////
// GERANDO REGISTRO com base no MODELO
////////////////////////////////////////////////////
if (!is_null(zo_template)) {
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Gerando o registro com base no modelo '%s'...", zs_metodo, zs_template);
send_wait(0, zo_template, "make_from_template", zo_group_leader, zo_objeto, zu_login_userid);
if (msg_error()) {
zs_msg = format("%s ERRO ao gerar registro com base no template '%s': '%s'", zs_metodo, zs_template, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
}

////////////////////////////////////////////////////
// Define MENSAGEM PADRAO no ACTIVITY LOG do ticket
// caso a mensagem nao tenha sido definida pelo
// parametro act_log
////////////////////////////////////////////////////
if (is_null(zs_activity_log)) {
zs_activity_log = format("Criar ticket (%s)", argv[2]);
}

////////////////////////////////////////////////////
// Definindo o METODO DE CRIACAO que sera utilizado
// caso o registro seja um ticket
////////////////////////////////////////////////////
if (zi_is_ticket == 1) {
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Instanciando metodo...", zs_metodo);
string zs_init;
if (zs_producer == 'cr' || zs_producer == 'in' || zs_producer == 'pr') {
if (zs_producer == 'cr') {
zs_init = 'init_call_request';
} else if (zs_producer == 'in') {
zs_init = 'init_incident';
} else if (zs_producer == 'pr') {
zs_init = 'init_problem';
}
send_wait(0, zo_objeto, zs_init, (uuid) NULL, zu_login_userid, zs_activity_log);

} else if (zs_producer == 'chg') {
zs_init = 'init_change_request';
send_wait(0, zo_objeto, zs_init, zu_login_userid, NULL, zs_activity_log);

} else if (zs_producer == 'iss') {
zs_init = 'init_issue';
send_wait(0, zo_objeto, zs_init, zu_login_userid, zs_activity_log);
}

if (msg_error()) {
zs_msg = format("%s ERRO ao inicializar o metodo '%s': '%s'", zs_metodo, zs_init, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
}

////////////////////////////////////////////////////
// Persistindo VALORES DE ATRIBUTO no objeto
////////////////////////////////////////////////////
// Monta matriz para armazenar as propriedades informadas
if (zs_producer_prp) string zs_properties[50];
int zi_pos_prp; // define a posicao da propriedade na matriz
string zs_persid;
zs_persid = zo_objeto.persistent_id;
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Persistindo valores no novo objeto '%s'...", zs_metodo, zs_persid);
for (zi_h=3; zi_h<zi_count_atributos; zi_h+=2) {
if (sindex(argv[zi_h], "properties") == -1) {
if (sindex(argv[zi_h], "template_name") == -1 && sindex(argv[zi_h], "act_log") == -1 && sindex(argv[zi_h], "asset") == -1) {
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Persistindo '%s' no atributo '%s' no 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], "SURE_SET");
if (msg_error()) {
zs_msg = format("%s ERRO ao persistir o valor '%s' no atributo '%s' no 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;
}
}
////////////////////////////////////////////////////
// Identificando PERSID DA CATEGORIA que sera
// utilizada para popular as propriedades
////////////////////////////////////////////////////
if (argv[zi_h] == 'category' && !is_null(zs_producer_cat)) {
string zs_category;
zs_category = argv[zi_h+1];
string zs_category_persid;
if (zs_producer == "chg" || zs_producer == "iss") {
zs_category_persid = expand(format("&{%s = %s.code->persistent_id}", zs_category, zs_producer_cat));
} else if (zs_producer == "cr" || zs_producer == "in" || zs_producer == "pr") {
zs_category_persid = zs_category;
}
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Persid da categoria '%s': '%s'", zs_metodo, argv[zi_h+1], zs_category_persid);
}

} else {
if (sindex(argv[zi_h], "properties.") == 0) {
////////////////////////////////////////////////////
// Identificando as PROPRIEDADES INFORMADAS e
// populando a matriz que sera utilizada para
// persistir os valores
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Mapeando propriedades (Modo ARRAY)... ('%s')", zs_metodo, argv[zi_h]);
zi_pos_prp = (int) (substr(argv[zi_h], sindex(argv[zi_h], 's.') + 2));
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Valor da propriedade '%s' ('%s'): '%s'", zs_metodo, zi_pos_prp, argv[zi_h], argv[zi_h+1]);
zs_properties[zi_pos_prp] = argv[zi_h+1];

} else if (argv[zi_h] == "properties") {
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Mapeando propriedades (Modo LABEL)... ('%s')", zs_metodo, argv[zi_h]);
// 'properties', 'Nome:=Daniel@;@Endereço:=Rua A"
if (!is_empty(zs_category_persid)) {
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Localizando posicao das propriedades no template da categoria '%s' ('%s')...", zs_metodo, zs_category, zs_category_persid);

// Armazenando as propriedades informadas em um array
string zs_propertie_label[50], zs_propertie_value[50];
int zi_properties_temp_count;
string zs_properties_temp_array[50];
zi_properties_temp_count = split(zs_properties_temp_array, argv[zi_h+1], "@;@");
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Quantidade de propriedades informadas: %d", zs_metodo, zi_properties_temp_count);

// Armazenando propriedades do template de propriedades em um array
string zs_properties_tpl_array[50];
send_wait(0, top_object(), "call_attr", "api", "get_prptpl_list_for_category", zs_category_persid);
if (msg_error()) {
zs_msg = format("%s ERRO ao consultar as propriedades do template de categoria '%s': '%s'", zs_metodo, zs_category_persid, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
zi_pos_prp = msg[1];

int zi_properties_tpl_count;
zi_properties_tpl_count = 0;
send_wait(0, top_object(), "call_attr", "api", "get_list_values", zu_login_userid, msg[0], 0, zi_pos_prp, 0, "label", "required");
if (msg_error()) {
zs_msg = format("%s ERRO ao consultar os atributos 'label' e 'required' das propriedades do template de categoria '%s': '%s'", zs_metodo, zs_category_persid, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}

for (zi_i = 2; zi_i < msg_length(); zi_i+=5) {
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Propriedade %d do template: '%s' / Obrigatoriedade '%d'", zs_metodo, zi_properties_tpl_count, msg[zi_i], msg[zi_i+2]);
zs_properties_tpl_array[zi_properties_tpl_count] = msg[zi_i];

for (zi_j = 0; zi_j < zi_properties_temp_count; zi_j++) {
zs_propertie_label[zi_j] = substr(zs_properties_temp_array[zi_j], 0, sindex(zs_properties_temp_array[zi_j], "="));

if (msg[zi_i] == zs_propertie_label[zi_j]) {
zs_propertie_value[zi_j] = substr(zs_properties_temp_array[zi_j], sindex(zs_properties_temp_array[zi_j], "=")+1);
zs_properties[zi_properties_tpl_count] = zs_propertie_value[zi_j];
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Valor definido da propriedade '%s': '%s'", zs_metodo, msg[zi_i], zs_propertie_value[zi_j]);
break;
}
}

// Verifica se a obrigatoriedade da propriedade foi respeitada
if (msg[zi_i+2] == 1 && is_empty(zs_properties[zi_properties_tpl_count])) {
zs_msg = format("%s ERRO ao criar objeto '%s' . A propriedade '%s' eh OBRIGATORIA.", zs_metodo, zs_persid, msg[zi_i]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
zi_properties_tpl_count++;
}

} else {
zs_msg = format("%s ERRO ao localizar a posicao das propriedades no objeto '%s'. O atributo 'category' precisa ser informado antes do atributo 'properties' na passagem de parametros.", zs_persid, zs_metodo);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}

} else { // Formato incorreto do atributo 'properties'
zs_msg = format("%s ERRO ao identificar as propriedades no atributo '%s' do objeto '%s'.", zs_metodo, argv[zi_h], zs_persid);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
}

////////////////////////////////////////////////////
// Persistindo IC's
////////////////////////////////////////////////////
if (argv[zi_h] == "asset" && !is_null(zs_producer_asset)) {
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Criando novo registro no producer '%s'...", zs_metodo, zs_producer_asset);
send_wait(0, top_object(), "call_attr", zs_producer_asset, "get_new_dob", NULL, NULL, zo_group_leader);
if (msg_error()) {
zs_msg = format("%s ERRO ao submeter novo dob: '%s'", zs_metodo, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
object zo_objeto_asset;
zo_objeto_asset = msg[0];
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Persistindo IC '%s' na tabela '%s'...", zs_metodo, argv[zi_h+1], zs_producer_asset);
zo_objeto_asset.nr = argv[zi_h+1];
if (zs_producer == "iss") {
zo_objeto_asset.iss = zo_objeto.persistent_id;
} else if (zs_producer == "chg") {
zo_objeto_asset.chg = zo_objeto.id;
}
}
}

////////////////////////////////////////////////////
// Persistindo atributo CREATED_VIA no objeto
////////////////////////////////////////////////////
if (zi_is_ticket == 1) {
int zi_intfc;
zi_intfc = 3553; // Linha de comando criada
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Persistindo '%d' no atributo 'created_via' no objeto '%s'...", zs_metodo, zi_intfc, zs_persid);
send_wait(0, zo_objeto, "call_attr", "created_via", "set_val", zi_intfc, "SURE_SET");
if ( msg_error() ) {
zs_msg = format("%s ERRO ao persistir o valor '%d' no atributo 'created_via' no objeto '%s': '%s'", zs_metodo, zi_intfc, zs_persid, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
}

////////////////////////////////////////////////////
// PERSISTINDO PROPRIEDADES no objeto
////////////////////////////////////////////////////
if (!is_null(zi_pos_prp)) {
if (!is_null(zs_category_persid)) {
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Consultando persids de propriedades...", zs_metodo);
send_wait(0, zo_objeto, "call_attr", "add_property_persids", "get_val");
if ( msg_error() ) {
zs_msg = format("%s ERRO ao instanciar o objeto 'add_property_persids': %s", zs_metodo, msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
string zs_properties_persid;
zs_properties_persid = msg[0];
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Persid's das propriedades: '%s'", zs_metodo, zs_properties_persid);
int zi_properties_count;
string zs_properties_array[50];
zi_properties_count = split(zs_properties_array, zs_properties_persid, " ");
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Tamanho do array de propriedades: '%s'", zs_metodo, zi_properties_count);

for (zi_i = 0; zi_i < zi_properties_count; zi_i++) {
////////////////////////////////////////////////////
// INSTANCIANDO E POPULANDO CADA PROPRIEDADE no objeto
////////////////////////////////////////////////////
if (!is_null(zs_properties[zi_i])) {
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Instanciando propriedade %s '%s'...", zs_metodo, zi_i, zs_properties_array[zi_i]);
send_wait (0, top_object(), "call_attr", zs_producer_prp, "dob_by_persid", NULL, zs_properties_array[zi_i]);
if ( msg_error() ) {
zs_msg = format("%s ERRO ao instanciar o objeto '%s': %s", zs_metodo, zs_properties_array[zi_i], msg[0]);
logf(ERROR, "%s", zs_msg);
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
object zo_propertie;
zo_propertie = msg[0];
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Persistindo propriedade %s com o valor '%s' no objeto '%s'...", zs_metodo, zi_i, zs_properties[zi_i], zs_properties_array[zi_i]);
zo_propertie.value = zs_properties[zi_i];
}
}

} else {
zs_msg = format("%s ERRO ao identificar a categoria do novo objeto '%s'. Propriedades foram informadas mas sem a categoria.", zs_metodo, zs_persid);
logf(ERROR, "%s", zs_msg);
send_wait(0, zo_group_leader, "uncheck");
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
}

////////////////////////////////////////////////////
// Fazendo CHECKIN no objeto
////////////////////////////////////////////////////
if (zi_depurar >= 2) logf(SIGNIFICANT, "%s Fazendo checkin no objeto '%s'...", zs_metodo, zs_persid);
send_wait(0, zo_group_leader, "checkin");
// Trata a mensagem de retorno do metodo send_wait
for (zi_i=0, zs_msg_return=""; zi_i<msg_length(); zi_i+=1) { 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]); } }
if (msg_error()) {
zs_msg = format("%s ERRO ao fazer checkin no novo objeto '%s': '%s'", zs_metodo, zs_persid, zs_msg_return);
logf(ERROR, "%s", zs_msg);
send_wait(0, zo_group_leader, "uncheck");
z_bloco_fim(zi_depurar, zs_metodo);
return zs_msg;
}
if (zi_depurar >= 1) logf(SIGNIFICANT, "%s Checkin realizado com SUCESSO no objeto '%s'.", zs_metodo, zs_persid);

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


z_bloco_fim(int zi_depurar, string zs_metodo)
{
////////////////////////////////////////////////////////////////////////
// Metodo: z_bloco_fim
// Autor: Henrique Grammelsbacher
// Criado em: 12/26/2007 5:20:50 PM
// Descricao: Grava em log o fim de bloco de depura?
// 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>=1 ) {
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
// Criado em: 20/06/2013
// Descricao: Grava em log o inicio de bloco de depuracao
// 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>=1 ) {
logf(SIGNIFICANT, "=============================================================");
logf(SIGNIFICANT, "%s Inicio - %s", zs_metodo, now());
logf(SIGNIFICANT, "%s Usuario: '%s'", zs_metodo, thread_userid());
logf(SIGNIFICANT, "=============================================================");
}
// 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
///////////////////////////////////
}

 

 

publish originally: May 19 of 2016

From: CA SDM Brasil 

criada Por: Daniel Bighelini

 

Attachments

Outcomes