Tipos de Scripts
Será abordado neste tópico a construção dos artefatos através dos itens: Scripts, Componentes, Críticas e Fontes dinâmicas. O que muda nesses recursos são suas finalidades e recursos exclusivos para cada artefato. Mas antes de mostrarmos as diferenças e particularidades de cada item, veja para que serve cada ícone da página de Editor de scripts.
Para iniciar pressione o botão +SCRIPT, independente do item escolhido nas outras abas sempre será esse botão que iniciará a construção de um artefato.
|
|---|
Informe o título, no campo Tipo são apresentados o tipo que será construído o script. Informe os outros campos caso necessário e pressione o botão SALVAR.
|
|---|
Abrirá a tela de Editor de scripts.
|
|---|
| 1 | Modo Edição | Alterna do modo de visualização para o modo de edição do script. |
| 2 | Desfazer | Desfazer a última alteração realizada no script. |
| 3 | Refazer | Refaz a última alteração desfeita do script. |
| 4 | Localizar | Faz a busca de um termo dentro do script disponível; |
| 5 | Localizar e Substituir | Sobrepõe um trecho de texto indicado dentro do script por outro a critério do usuário. |
| 6 | Formatar Script | Realiza uma indentação automática do script |
| 7 | Modo tela cheia | Alterna a janela do editor entre o modo tela cheia e o modo padrão |
| 8 | Descartar rascunho | Retorna o script para a última versão publicada do mesmo |
| 9 | Salvar | Salva a código atual como rascunho |
| 10 | Publicar | Realiza a publicação do script atual, gerando uma nova versão da extensão |
| 11 | Executar Rascunho | Executa a versão de rascunho do script |
| 12 | Visualizar Parâmetros | Abre a janela onde é possível realizar a configuração dos parâmetros utilizados na execução do script |
| 13 | Configurações | Abre a janela de configurações, exibindo uma lista de configuração de comportamentos do script |
| 14 | Visualizar Dependências | Abre uma janela exibindo quais extensões devem estar disponíveis para o script atual ser executado devidamente |
| 15 | Alternar para modo claro/escuro | Altera a cor de exibição da janela entre um conjunto de cores claras e escuras |
| 16 | Explorar fontes de dados | Abre a visualização do catálogo de dados, informando quais as fontes de dados disponíveis para uso pelo script atual |
| 17 | Quebra de Linha | Alterna a opção de quebra de linha, permitindo escolher se o script exibirá ou não uma barra de rolagem horizontal |
| 18 | Console | Essa aba permite visualizar quando há erros de sintaxe ou outros quando de tenta executar ou publicar o script; |
| 19 | Execuções | Retém o histórico de execuções realizadas no modo rascunho do script, permitindo acessar o log ou visualizar eventuais erros de execução. |
Ao concluir qualquer script é necessário gerar essas informações no Gerador de relatórios. Para ter acesso ao material completo sobre essa ferramenta clique aqui.
Scripts
Vamos começar pelo primeiro item que é Scripts, a partir daqui damos início à construção de um artefato. A linguagem utilizada é chamada de BFC-Script, e é através dela que é possível desenvolver os artefatos. Temos um material sobre esse assunto, para acessá-la clique aqui.
O ambiente de desenvolvimento de scripts é simples, suas principais características são a facilidade de manipulação, por tratar-se de um compilador com funções e recursos no idioma português e a possibilidade de desenvolvimento por mais de um usuário.
Os scripts são pequenos programas com capacidade de interagir com os dados de cada sistema dos produtos com tecnologia Cloud, sejam para entrada e/ou saída de dados, podendo gerar resultados de saída como arquivos, e-mails, notificações, além de consumo de serviços dos próprios sistemas e de terceiros.
Componentes
Um componente nada mais é que um script criado para ser utilizado dentro de outros scripts. Existem situações em que é necessário realizar algo muito repetitivo, para que o usuário desenvolvedor não precise criar uma função dentro de cada script, é feito um componente para ser usado dentro de outros scripts. Esse conjunto de códigos serão importados para dentro de um outro script, sem necessidade de declarar tudo novamente.
A vantagem de realizar um componente é:
- Reaproveitamento dos códigos em diversos scripts;
- Manutenção simplificada, pois será necessário atualizar apenas um artefato.
Mas como isso funciona?
Será informado um nome da função, no exemplo abaixo será arquivoPlanoContabil, logo, serão inseridos um conjunto de códigos passando pelos parâmetros de execução e por último terá o código Scripts.exportar seguido do nome da função que será exportado.
// função que retorna o arquivo
arquivoPlanoContabil = { exercicio, entidade, mes, idPessoa,tipoEnvio ->
//Natureza do Saldo(*)
mascaras_mistas = ["237000000","237100000","237110000","237110100","237110200","237110300","237110400","237120000", "237120100","237120200","237120300","237120400","237130000","237130100","237130200","237130300", "237130400","237140000","237140100","237140200","237140300","237140400","237150000","237150100", "237150200","237150300","237150400","237200000","237210000","237210100","237210200","237210300", "237210400","237210500","237210600","237220000","237220100","237220200","237220300","237220400", "237220500","237220600","237230000","237230100","237230200","237230300","237230400","237230500", "237230600","237240000","237240100","237240200","237240300","237240400","237240500","237240600", "237250000","237250100","237250200","237250300","237250400","237250500","237250600","511200000", "521200000","522139900","522190000","522190100","522190200","522190300","522210300","522220000", "522220100","522220200","522220300","622210900","622220900","821110100","234000000","234100000", "234110000","234200000","234210000","621100000","821000000","821100000","821110000","821110101"];
mascaras_devedoras = ["1","4","6","8"];
mascaras_credoras = ["2","3","5","7"];
mascaras_orcamentarias = ["5","6"];
mascaras_controle = ["7","8"];
mascaras_patrimoniais = ["1","2","3","4"];
imprimir "Iniciando Geração do Arquivo planocontabil.txt " + Datas.hoje().formatar('HH:mm:ss');
listaArquivo = [];
separador = "|";
arquivoTxt = Arquivo.novo('planocontabil.txt');
/*************************************************************************************
Identifica a configuração do plano de contas
*************************************************************************************/
identificaParametro = Dados.contabilidade.v1.parametroEscrituracao.busca(criterio: "entidade.id ="+ entidade + " and exercicio.ano = " + exercicio, campos: "configuracao.id");
percorrer(identificaParametro){item2 ->
configuracaoPlanoContasId = item2.configuracao.id
}
/************************************************************************************/
se(tipoEnvio =="ABERTURA"){
criteriosBusca = "configuracao.id = $configuracaoPlanoContasId";
}senao{
se(tipoEnvio == "DIARIO"){
criteriosBusca = "configuracao.id = $configuracaoPlanoContasId";
}senao{ // mensal
dataAux = (Datas.data(Integer.valueOf(exercicio),(Integer.valueOf(mes)+1),1) - 1).formatar('yyyy-MM-dd')
dataAux2 = Datas.data(Integer.valueOf(exercicio),(Integer.valueOf(mes)),1).formatar('yyyy-MM-dd')
criteriosBusca = "configuracao.id = $configuracaoPlanoContasId and dataVigenciaInicial <= $dataAux and dataVigenciaInicial >= $dataAux2 ";
}
}
camposBusca = "mascara,descricao,tipo"
ordenacaoBusca = "mascara asc";
r = Dados.contabilidade.v1.contaContabil.busca(criterio: criteriosBusca, campos: camposBusca, ordenacao: ordenacaoBusca);
percorrer(r){ item ->
//#Identificador da Pessoa Jurídica junto ao TCE(*)..7
idPessoa = idPessoa;
//Classe,Grupo....19
conta = item.mascara
//Ano de Aplicação do Plano...4
ano = exercicio
//Título ...250
titulo = item.descricao
se(mascaras_mistas.find{it == item.mascara.subTexto(0,9)} != nulo){
naturezaSaldo = "X"
}senao{
se(mascaras_devedoras.find{it == item.mascara.subTexto(0,1)} != nulo) {
naturezaSaldo = "D"
}senao{
se(mascaras_credoras.find{it == item.mascara.subTexto(0,1)} != nulo){
naturezaSaldo = "C"
}senao{
naturezaSaldo = ""
}
}
}
//Escrituração(*)
se (item.tipo == "A") {
escrituracao = "S"
} senao {
escrituracao = "N"
}
//Natureza da Informação(*)
se(mascaras_orcamentarias.find{it == item.mascara.subTexto(0,1)} != nulo) {
naturezaInfo = "O"
}senao{
se(mascaras_controle.find{it == item.mascara.subTexto(0,1)} != nulo) {
naturezaInfo = "C"
}senao{
se(mascaras_patrimoniais.find{it == item.mascara.subTexto(0,1)} != nulo) {
naturezaInfo = "P"
}senao{
naturezaInfo = ""
}
}
}
//Indicador de Superávit Financeiro(*)
/*
F Financeiro
P Patrimonial
X Mista/Hibrida
O Outros Controles*/
//Tipo de Controle da Conta(*)
/*tpControleConta dsTipoControleConta
O Obrigatória
F Facultativa
T Obrigatória – TCE/PR
P Próprio da Entidade*/
// Escreve os dados gerados no arquivo txt.
arquivoTxt.escrever(idPessoa + separador);
arquivoTxt.escrever(conta + separador);
arquivoTxt.escrever(ano + separador);
arquivoTxt.escrever(titulo + separador);
arquivoTxt.escrever(naturezaSaldo);
arquivoTxt.novaLinha()
}
imprimir "Finalizando Geração do Arquivo planocontabil.txt " + Datas.hoje().formatar('HH:mm:ss');
retornar arquivoTxt
}
Scripts.exportar(
arquivoPlanoContabil : arquivoPlanoContabil
)
Quando o usuário precisar fazer uso desse componente dentro de um script é essencial informar o nome do componente para que possa trazer todas as informações.
Na página de informações existe a funcionalidade Identificador, neste local é configurado o nome do artefato, e é através dele que será possível importar os dados para dentro de um script. Para cadastrá-lo ou editá-lo clique no identificador e digite um nome, logo pressione o botão SALVAR.
|
|---|
Um detalhe importante, quando não aparece a informação da cor azul significa que esse artefato foi flexibilizado e está sendo usado por outras entidades tornando-o inviável a edição.
|
|---|
Como foi visto nos parágrafos anteriores os componentes têm suas particularidades, além do que foi apresentado perceba que na tela de informações não é apresentado o histórico de execuções, pois um componente é feito para ser utilizado dentro de outros scripts e não para ser executado sozinho. Na tela que contém as informações do script é apresentado apenas o histórico de atualizações.
|
|---|
Quando um componente estiver sendo importado para um script ele aparecerá da seguinte maneira: na primeira linha é informado o nome do identificador do componente e na linha de baixo é informado o nome que foi exportado. Ao inserir essas informações dentro de um script já estará usando a função declarada dentro do Componente.
MeuComponente = importar("simam_planejamento_programa")
MeuComponente.arquivoPlanoContabil()
Através das Ações disponíveis > Trace execução, é a forma onde é possível visualizar as informações e principalmente a duração da execução do componente.
|
|---|
Clicando em Trace execução, aparecem as informações mostradas abaixo.
{
"id" : 3770586,
"revisao" : 8740551,
"versao" : 1,
"titulo" : "Teste",
"porIdentificador" : false,
"inicio" : "2022-02-24T09:59:14.357",
"termino" : "2022-02-24T09:59:14.539",
"duracao" : 0.182000000
}
Definir dependências
Através da funcionalidade definir dependências a ferramenta de scripts consegue vincular um componente, para isso clique no ícone mostrado na imagem abaixo.
|
|---|
Na sequência, uma nova tela é aberta para que seja cadastrada a dependência, para tanto pressione o botão +DEPENDÊNCIA. Preencha com campos solicitados e salve as informações. Sendo assim, o script ficará com uma dependência cadastrada.
|
|---|
Fontes dinâmicas
Fontes dinâmicas são categorias de scripts que são utilizadas para gerar o conjunto de dados que serão utilizados posteriormente para a geração de um relatório. As fontes dinâmicas devem ser utilizadas em conjunto com a ferramenta de relatórios, porém são criadas e mantidas através da ferramenta de scripts. A mesma fonte dinâmica pode ser consumida por 1 ou mais relatórios diferentes, e para isso, a fonte deve estar disponível na mesma entidade que o relatório desejado.
Para gerar uma nova fonte dinâmica, deve-se acessar a ferramenta de scripts, clicar sobre o botão +SCRIPT, na janela que se abrirá, deve-se selecionar a opção Fonte Dinâmica no campo Tipo, conforme imagem a seguir.
|
|---|
Uma vez que a fonte foi criada, após a primeira publicação da mesma, ela ficará disponível para visualização/edição na aba Fontes Dinâmicas da ferramenta de script.
Editor de Scripts
Quando se está criando fontes dinâmicas, a primeira coisa a se fazer é definir a estrutura. Primeiramente é necessário criar uma variável, geralmente é criada com o nome de esquema e definir quais os campos que aparecerão quando gerado um relatório.
Para cada campo criado na fonte de dados, é necessário informar qual o tipo, ou seja, se será um texto, número e etc. Neste exemplo serão usados os tipos numero e caracter e é possível colocar a quantidade de campos desejados, neste caso usaremos apenas três para exemplificar.
Exemplo:
esquema = [
id: Esquema.numero,
nome: Esquema.caracter,
idade: Esquema.numero
]
Após gerar o esquema da fonte é instanciado o objeto das fontes de dados e abaixo é acrescentado o retorno da fonte, ou seja, por essa expressão será apresentado as informações.
fonte = Dados.dinamico.v2.novo(esquema)
retornar fonte;
Mas, para que sejam retornados dados é preciso informar o que será mostrado, é necessário inserir as informações porque até aqui foi realizada apenas a estrutura. Para isso, descreva entre as duas linhas mencionadas acima as informações que serão apresentadas no relatório. Perceba que foram inseridas o id, nome e idade em cada linha como definido no esquema apresentado anteriormente.
esquema = [
id: Esquema.numero,
nome: Esquema.caracter,
idade: Esquema.numero
]
fonte = Dados.dinamico.v2.novo(esquema)
fonte.inserirLinha([id: 1, nome: "Artur", idade:29])
fonte.inserirLinha([id: 2, nome: "Mateus", idade:35])
fonte.inserirLinha([id: 3, nome: "Sabrina", idade:25])
fonte.inserirLinha([id: 4, nome: "Fernando", idade:42])
retornar fonte;
|
|---|
Neste exemplo foi escrito as informações, mas nada impede de fazer buscas em outras fontes de dados localizado no lado direito da tela. Com essas fontes é possível realizar cálculos, tratar dados entre outros, realizando algo mais elaborado.
|
|---|
|
|---|
Clicando no ícone de executar a ferramenta mostrará se houve algum erro ou se foi publicado corretamente, essa informação é visível abaixo da tela. Neste exemplo não apresentou nenhum erro, ou seja, temos uma fonte de dados válida.
|
|---|
Ao executar um rascunho no editor de Scripts a ferramenta permite que o mesmo seja cancelado através da opção mostrada na imagem abaixo.
|
|---|
Clicando na opção mencionada aparecerá que o rascunho do script está sendo cancelado.
|
|---|
Criando código da fonte dinâmica
Segue abaixo um exemplo funcional de fonte dinâmica, contendo o mínimo necessário para se publicar um script executável de fonte dinâmica:
|
|---|
| Linhas 1-3 | Definição da estrutura de dados que serão passados para o relatório. O conjunto de dados está sendo passado dentro de uma variável tipo Mapa (LinkedHashMap) chamada “estrutura”, e dentro desse mapa existe uma propriedade “id”, que está configurada para o tipo “Esquema.inteiro”, indicando que o jasper deverá receber o campo “id” no formato de dados “Integer” ou “Long”; |
| Linha 4 | Instanciando a fonte de dados propriamente dita através de uma variável chamada “fonte”, qual recebe como parâmetro a variável “estrutura”, indicando quais os campos esperados ao se alimentar os dados na mesma. |
| Linha 5 | Exemplo de chamada da função “inserirLinha” de nossa fonte, onde a mesma recebe uma linha de dados informando “[id: 1]” que posteriormente será lida pelo relatório. |
| Linha 6 | Toda finalização de um script de fonte dinâmica deve retornar a fonte que foi criada e alimentada no decorrer do script. |
Definindo estrutura de uma fonte dinâmica
A estrutura dos dados definidos para o esquema da fonte deve ser criada conforme a necessidade do relatório, e fica a cargo do desenvolvedor/analista definir os campos e tipos mais adequados. A nomenclatura dos campos segue as mesmas regras de nomenclatura de variáveis, e os tipos de dados disponíveis, assim como seus equivalentes no TIBCO podem ser conferidos na tabela a seguir:
| Configuração Esquema | Configuração Jasper |
| Esquema.caracter | java.lang.String |
| Esquema.inteiro | java.lang.Long |
| Esquema.numero | java.math.BigDecimal |
| Esquema.data | java.util.Date |
| Esquema.objeto | java.util.Object |
| Esquema.lista | java.util.List |
Segue exemplo de configuração adequada entre o script e o arquivo do TIBCO, conforme tabela anterior:
|
|---|
Vinculando o relatório com a fonte dinâmica
Alterando a fonte vinculada ao relatório
Vinculando os parâmetros do relatório com a fonte
Naturezas de relatórios
Orquestrando relatórios do tipo fonte dinâmica
Exemplo de script fonte dinâmica 1 (Simples)
Exemplo de script fonte dinâmica 2 (Intermediários)
Exemplo de script fonte dinâmica 3 (Complexo)
Críticas
As críticas de usuários representam uma validação aplicada a registros específicos. Ao criar uma crítica, é exibida a opção 'Evento(s)' na tela de informações. Somente após a seleção de um evento é que o campo Natureza se torna habilitado.
No campo Evento(s), é necessário escolher o tipo de alteração que acionará a crítica. A ferramenta permite a seleção de apenas uma opção ou de todas. A opção Criação dispara a crítica ao criar um novo empenho, Alteração ao editar um empenho já cadastrado e salvar, e 'Excluir' ao deletar um empenho.
Quando se trata da Natureza de uma crítica, ela tem um significado um tanto distinto dos demais. Neste contexto, a Natureza implica uma adição de significado adicional. Ao abrir as opções desse campo, são exibidos alguns registros do sistema selecionado. Quando um desses registros é escolhido, o usuário está especificando que a crítica será acionada ao realizar ações relacionadas aos cadastros de empenhos no sistema Contábil.
|
|---|
A finalidade da crítica é estabelecer regras específicas que impeçam que um usuário edite determinado empenho, a menos que ele passe nas validações previamente definidas. Essa restrição se aplica a situações em que o usuário não está autorizado a criar o empenho, a menos que atenda a essas validações e assim por diante.
A mensagem descrita abaixo é eficaz somente quando o tipo de script é uma Crítica de Usuário. Se for tentado executá-la como uma Fonte Dinâmica ou Script Normal, ocorrerá um erro.
Mensagens.erro("Teste")
Perceba que no editor de scripts do tipo crítica, mesmo sendo publicado o conteúdo não existe o botão de play para simular o modo rascunho, é necessário que seja realizado por dentro dos sistemas.
|
|---|
Neste exemplo a crítica está configurada na natureza Cadastro de empenhos com evento de criação, alteração ou exclusão, isso significa que ao tentar realizar qualquer um dos eventos a ferramenta não deixará realizar nenhuma ação e mostrará erro cadastrado no script.
|
|---|
Na imagem abaixo mostra a mensagem de erro ao tentar salvar uma informação, com isso é perceptível que o script do tipo crítica cadastrado anteriormente funcionou perfeitamente, pois foi mandado dar erro de qualquer maneira ao realizar as ações mencionadas sem validar nada.
|
|---|
É possível alterar os eventos, ou seja, insira ou retire a opção que desejar. Para isso, clique em Eventos, logo, uma tela é aberta para que de fato as ações sejam realizadas. A seguir aperte o botão SALVAR.
|
|---|
Na tela de informações não é apresentado o histórico de execuções, pois um componente é feito para ser utilizado dentro dos sistemas. Na tela que contém as informações do script é apresentado o histórico de atualizações e agendamentos.
|
|---|
Ao clicar no botão na opção 'Habilitado', uma janela será exibida solicitando a confirmação.
Para que isso seja viável, é necessário observar algumas questões:
- Críticas flexibilizadas poderão ser somente desabilitadas/habilitadas por usuários técnicos.
- Críticas de propriedade da entidade poderão ser desabilitadas/habilitadas por usuários administradores.
|
|---|
Além da mensagem de erro, existem também:
Aviso: que não impede uma ação, apenas avisa sobre algo mas não impede de realizar uma ação;
Mensagens.erro("Teste")
Info: aparece uma janela azul sem dar a impressão que algo aconteceu de errado, é uma informação simples para chamar atenção do cliente mas não é impeditivo caso o usuário execute uma ação;
Mensagens.info("Teste")
Registro.novo: mostra todos os campos que é possível ler dentro da crítica, com isso mostra uma lista gigante de informações. Para mostrar todos os campos de um cadastro insira como no exemplo abaixo. A variável registro.novo mostra de onde estão vindo todos os campos cadastrados ou modificados na crítica.
Mensagens.aviso(registro.novo)
Para determinar um único campo se faz necessário acrescentar o nome do campo que deseja, assim é possível ver todos os níveis para acessar determinada informação. Observe no exemplo abaixo.
Mensagens.aviso(registro.novo.recurso.numero)
Quando há muitas informações o sistema apresenta um erro, para que isso não aconteça limite a quantidade de texto mostrado na tela. No exemplo exibido abaixo foi limitado para que apareça 500 caracteres, portanto o desenvolvedor do script pode inserir a quantidade que achar necessário.
Mensagens.aviso((""registro.novo).esquerda(500)