Karina Harumi
-
Contagem de Conteúdo
933 -
Ingressou
-
Última visita
-
Dias Ganhos
185
Tipo de Conteúdo
Perfis
Fóruns
Blogs
Calendário
Downloads
Postagens postado por Karina Harumi
-
-
Você certamente ficará surpreso com o poder que essa ferramenta possuí mas também irá entender que ele exige muito trabalho pra que tudo fique bem no fim do dia.
Bem, Protractor nada mais é que - em tradução livre - um framework de teste end-to-end para aplicações AngularJS . Ele executa testes contra seu aplicativo em execução em um navegador real, interagindo com ele como um usuário faria ( http://angular.github.io/protractor/#/ 1 ). Em suma ele substitui aquele bom e velho checklist que alguém da sua equipe gasta um tempo pra fazer, ou seja, significa redução de custos e de tempo pra sua empresa, ainda mais se você utilizar ele em conjunto com um servidor de integração contínua, como o Jenkins por exemplo ( mas isso é pra um outro post).
O Protractor usa algumas tecnologias pra fazer a sua mágica, são elas:
- Jasmine : ferramenta de testes de comportamento para javascript, é com ele que você irá escrever seus testes ( http://jasmine.github.io/ );
- Webdriver : basicamente automatiza processos em navegadores, é ele quem obedece o Jasmine e clica, preenche e interage com a sua aplicação como se fosse um usuário ( https://github.com/angular/protractor ).
- NodeJS : uma linguagem baseada no V8 JavaScript Engine , orientada a eventos e feita para ser facilmente escalável, é a tecnologia em que o Protractor foi escrito ( https://nodejs.org/ ).
Agora, antes que fique chato demais, vamos a prática…
PARTE 1 - Criar a aplicação a ser testada
- Vamos pegar uma aplicação de exemplo do AngularJS mesmo, o mais simples, segue:
<!doctype html>
Name:
Hello {{yourName}} !
- Crie uma pasta no lugar de sua preferência com o nome de protractortest e salve esse arquivo com o nome index.html .
- Abra index.html no navegador pra garantir que a aplicação funciona.
PARTE 2 - Definindo e baixando as dependências
-
Crie um arquivo chamado package.json na raiz da aplicação com o seguinte conteúdo:
{
“name” : “protractortest”,
“version” : “0.0.1”,
“private” : true,
“scripts” : {
“start” : “cls & http-server -p 8888 -c-1”,
“update-webdriver” : “webdriver-manager update”,
“test” : “protractor protractor.conf.js”
},
“dependencies” : {
“protractor” : “^1.6.1”,
“http-server” : “^0.8.0”
}
}
- Caso não tenha o NodeJS instalado, faça isso agora https://nodejs.org/download/
- E instale o protractor globalmente: via linha de comando, execute ‘npm install -g protractor’
- Para, enfim, baixar as dependências da aplicação execute via linha de comando na pasta da aplicação o comando ‘npm install’ , caso dê algum erro tente executar como sudo (Linux) ou Administrador (Windows).
PARTE 3 - Configurando tudo
- Crie o arquivo de configuração do protractor (protractor.conf.js) na raiz da sua aplicação, conforme exemplo abaixo:
exports . config = {
specs : [
‘./tests/test.js’,
],
capabilities : {
‘browserName’ : ‘chrome’
},
baseUrl : ‘http://localhost:8888/’,
framework : ‘jasmine’,
jasmineNodeOpts : {
showColors : false,
isVerbose: true,
includeStackTrace: true
},
directConnect : true,
onPrepare : function () {
browser . manage (). window (). maximize ();
}
};
- Via linha de comando, na pasta raiz da aplicação, digite ‘npm run update-webdriver’ , isso irá instalar o Webdriver e o driver para o navegador escolhido e assim estaremos prontos para rodar os testes, mas calma, ainda precisamos escrever um…
PARTE 4 - Escrevendo testes
- Crie uma pasta chamada tests e crie nela um arquivo chamado test.js , nele adicione o seguinte conteúdo:
describe ( ‘Meu primeiro teste usando Protractor’ , function () {
it ( ‘Acessando aplicação’ , function () {
browser . get ( ‘http://localhost:8888/’ );
});
it ( ‘Escrevendo no input’ , function () {
var name = ‘o meu nome é Teste, obrigado por me usar…’;
var elementName = element ( by . model ( ‘yourName’ ));
var elementResponse = element ( by . css ( ‘h1’ ));
elementName . sendKeys ( name );
browser . sleep ( 2000 ); // essa linha não é necessária, serve apenas para que você veja a mágica acontecendo
expect ( elementResponse . getText ()). toEqual ( 'Hello ’ + name + ‘!’ );
});
});
FINAL - Rodando os testes
-
Novamente, via linha de comando e na pasta raiz da aplicação, digite ‘npm start’ para subir a aplicação no http://localhost:8888 , em seguida, em outro terminal, digite ‘npm test’ e espere a mágica acontecer…
2 tests , 1 assertion , 0 failures
-
Deu certo? Ótimo! Nesse momento feche os olhos e imagine o quanto isso pode melhorar a sua vida e a qualidade dos seus produtos, agora abra-os, dê aquele sorriso, respire fundo e ao trabalho meu jovem!!
Obrigado por ter lido até aqui, compartilhe em tudo quanto é lugar, afinal, o mundo precisa saber disso…
Pronto
p.s.: por favor, se não deu certo e você não teve sucesso, não desista… Deixe suas dúvidas (ou sugestões) nos comentários que eu terei o prazer de responder e ajudar se preciso.
Tópico originalmente criado por: @Jonathan Santos
-
Tópico originalmente criado por: @Pedro.Bravin
Olá desenvolvedor!
Neste post iremos disponibilizar à você algumas informações referente a como instanciar um componente/biblioteca no Visual FoxPro.
Passo a passo:
Primeiramente devemos criar um novo projeto, e um novo form ou abrir o projeto que você deseja adicionar os componentes;
Depois disso, abra o form principal, clique com o botão direito dentro do form e depois clique em “code”, em seguida, vá até a procedure “Init” do object “Form”.
A init é executada quando o form é aberto, então é nela que vamos instanciar o componente, conforme este exemplo:PUBLIC Boleto
Boleto = CREATEOBJECT(“BoletoX.spdBoletoX”)
PUBLIC ConsultarList As BOLETOX.spdRetConsultarListaNa tela de edição do FoxPro, selecione o botão Object Browser;
Na tela que abrir, selecione o botão “Open Type Library”;
Na tela em seguida, clique na aba “Com Library”, e em seguida em “Browser” navegue até a pasta em que está a .dll ou .ocx.Após seguir estes passos, o componente estará configurado e você já conseguirá utilizar os métodos .dll e OCX.
Caso tenha qualquer dúvida sobre o cenário explicado ou se quiser conhecer nossas soluções, estaremos sempre à disposição, e será um prazer ajudar!
-
Emitentes de MDF-e muitas vezes têm a necessidade de referenciar uma NF-e emitida em contingência FS/FSDA, e para isso é necessário se usar o segundo código de barras da impressão de FS/FSDA. Porém esse código não está diretamente no XML da nota, ele é gerado a partir de determinados dados que constam na nota. Nesse artigo vamos demonstrar como gerar esse código.
Está em anexo um projeto em Delphi que, a partir do XML de uma NF-e, busca todos os dados necessários e realiza a geração do código de barras FSDA. Para poder usá-lo, é necessário ter instalado no sistema algum produto da Tecnospeed que use a OCX GovX (componentes, Manager eDoc, etc).
Tópico originalmente criado por: @Jonathan Santos
-
Quando trabalhamos com aplicações comuns criadas em C#, não precisamos nos preocupar em destruir objetos criados em memória, pois o Garbage Collector nativo do C# faz este trabalho automaticamente.
Porém, quando trabalhamos com objetos COM (Objetos não nativos do C#) o funcionamento é diferente, pois o C# não sabe gerenciar este tipo de objeto. Logo, é necessário encerrá-los de uma forma “não convencional”, utilizando a classe Marshal.
A Classe Marshal nos traz todos os métodos necessários, para que consigamos fazer com que o C# consiga gerenciar os COM Objects. A Microsoft define a classe Marshal como:
Fornece um conjunto de métodos para a alocação de memória não gerenciado, a cópia de blocos de memória não gerenciados, e convertendo conseguiu tipos não gerenciados, bem como outros métodos usados variado ao interagir com código não gerenciado. (Microsoft 31-03-2015)
É simples utilizar a classe Marshal para liberar objetos COM. Abaixo temos um exemplo utilizando o componente spdNFeX:
{ Instanciando COM Object }
spdNFeX _spdNFeX = new spdNFeX();
try {
_spdNFeX.DiretorioLog = “C:\nfeConfig” ;
} finally {{ Informando ao Garbage Collector que esse objeto deve ser gerenciado }
Marshal.FinalReleaseComObject(_spdNFeX);{ Passando null ao Objeto para que o Garbage Collector saiba que deve ser recolhido da memória }
_spdNFeX = null;
}Note que para trabalhar com os objetos COM é necessário que se informe ao Garbage Collector o objeto a se gerenciar, uma vez que ele não o entende como um objeto nativo.
Por fim, deixamos em anexo a este post um projeto de demonstração, que mostra como trabalhar com objeto COM Object e a Classe Marshal.
Interessado em mais post’s C#, não deixa de verificar os Seguintes Post’s:
Referencias:
Microsoft 31-03-2015:
https://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal(v=vs.100).aspx
Tópico originalmente criado por: @Jonathan Santos
-
Após diversas tentativas frustradas e complexas de utilizar xPath em VB6 , acabamos por desenvolver uma OCX gratuita onde é possível utilizar xPath de forma simplificada. Apesar de desenvolvida para ser utilizada em VB6 é possível utilizar em qualquer linguagem que consiga consumir uma OCX .
Como instalar:
Realize o download da OCX no final do post, movendo para a SysWow64 -> S.O. x64 ou System32 -> S.O. x86 e registre utilizando o regsvr32 . Logo após deve referenciar essa OCX em seu projeto( Project -> References -> xPathXML.ocx ).
Métodos disponiveis:
- SelecionaNodeXML -> O método irá retornar a tag ou estrutura informada no primeiro parâmetro, com base no indice informado no segundo parâmetro, buscando estas informações no XML informado no terceiro parâmetro.
- PercorreNodeXML -> O método irá retornar todas as ocorrências da tag ou estrutura informada no primeiro parâmetro, separadas pelo delimitador definido no segundo parâmetro, buscando estas informações no XML informado no terceiro parâmetro.
XML utilizado para testes:
<retEnviNFe versao="3.10" xmlns="http://www.portalfiscal.inf.br/nfe" xmlns:ns2="http://www.w3.org/2000/09/xmldsig#"> <tpAmb>2</tpAmb> <verAplic>GO3.0</verAplic> <cStat>103</cStat> <xMotivo>Lote recebido com sucesso</xMotivo> <cUF>52</cUF> <dhRecbto>2015-03-18T11:15:24-03:00</dhRecbto> <infRec> <nRec>521000010289495</nRec> <nRec>521000010289495</nRec> <nRec>521000010289495</nRec> <tMed>2</tMed> </infRec> </retEnviNFe>
SelecionaNodeXML exemplo de utilização:
Dim XMLDoc As XPathXml.XPathXml Set XMLDoc = New XPathXml.XPathXml edtTesteTag.Text = XMLDoc.SelecionaNodeXml("nRec", 0, mmXml.Text)PercorreNodeXML exemplo de utilização:
Dim XMLDoc As XPathXml.XPathXml Set XMLDoc = New XPathXml.XPathXml Dim i As Integer Dim vetor As Variant vetor = Split(XMLDoc.PercorreNodeXML("nRec", "|", mmXml.Text), "|") cbbTesteTag.Clear For i = LBound(vetor) To UBound(vetor) cbbTesteTag.AddItem vetor(i) NextObtendo atributo de uma tag:
Dim XMLDoc As XPathXml.XPathXml Set XMLDoc = New XPathXml.XPathXml edtTesteTag.Text = XMLDoc.SelecionaNodeXML("retEnviNFe/@versao", 0, mmXml.Text) ou edtTesteTag.Text = XMLDoc.SelecionaNodeXML("@versao", 0, mmXml.Text)OCX e Exemplo de utilização anexados logo abaixo.
https://tsdn.tecnospeed.com.br/files/render/a/d1bA1YExdQc/m/2Aal0HUq8WfaoMbCJXVjsCp1gbKWDONcJmsewKMB3YfVHfqBRMt4Z30DjOvQgJkfk6NI1dQW2FgTópico originalmente criado por: @Jonathan Santos
-
Tópico originalmente criado por: @Jonathan Santos
Cenário do erro:
Windows 7/64 - certificado modelo A3 (TOKEN) - certificadora Serasa
Ao tentar cancelar uma nota no Manager Desktop o certificado pedia varias vezes o código PIN.
Ao cancelar a janela algumas vezes apontava o seguinte erro:
Mensagem do erro:
Exceção não esperada --------------------------------------------
EAccessViolation, Access violation at address 0746C9B0 in module ’ cmCSP.dll '. Read of address 00000008
[0746C9B0] Unknown function at DllRegisterServer
Mesmo registrando a cmCSP.dll o erro persistia.
Solução:
A cmCSP.dll é uma das dlls criada pelo drive do certificado A3.
Basta pegar esta dll de outro computador (que esteja intalado os mesmos drives referente ao mesmo modelo token e mesmo tipo de certificado a3) localizada na pasta Windows/sysWOW64 ou System 32 e registra-la novamente.
-
Tópico originalmente criado por: @Jonathan Santos
Quando criamos uma suite de teste de uma Unit/Projeto em delphi, verificar se todos os métodos de todas as classes estão sendo cobertos por testes pode ser difícil. Por isso, para auxiliar nesta tarefa, podemos utilizar a ferramenta delphi-code-coverage.
O primeiro passo para seu uso é encontrar onde está o código fonte e onde está sua unit de testes(procure pelo projeto criado para os testes). Com estas informações em mãos faça o download do delphi-code-coverage coloque-o no diretório onde o .exe da sua aplicação de teste é gerado.
Crie dois arquivos de texto com o nome de dcov_paths.lst e dcov_units.lst. Podemos utilizar a ferramenta Delphi-code-coverage-wizard para gerar a estrutura inicial desses arquivos .
O primeiro arquivo ( dcov_paths.lst ) contém o caminho para o código-fonte. Por exemplo :
C:\desenvolvimento\componentes\teste\
C:\desenvolvimento\componentes\teste2\
C:\desenvolvimento\componentes\teste\teste3
O segundo arquivo( dcov_units.lst ) contém os nomes das units que você deseja verificar a cobertura. Por exemplo :
testeIC
unitTeste
unitController
Para que o relatório dos dados possa ser utilizado corretamente é necessário que o seu projeto esteja gerando o arquivo .map detalhadamente. Para configurar essa propriedade em seu projeto, entre nas opções e selecione a opção Linking. Depois, na opção Map File , escolha Detailed .
Depois disso criamos um arquivo .bat ( dcov_execute.bat ) que executará o comando usando o code coverage :
CodeCoverage.exe -e “NomeDoExe.exe” -m “NomeDoExe.map” -uf dcov_units.lst -spf dcov_paths.lst -od “emma” -lt -emma -meta -xml -html
O uso e significado de cada comando e alguns outros podem ser encontrados no site onde fizemos o download do CodeCoverage.
Rode o ponto .bat (depois de compilar a suite de teste que configurada no bat). Depois da execução dos testes, ele será gerado um arquivo CodeCoverage_summary.html no diretório configurado no arquivo .bat.
Neste arquivo são gerados links para os arquivos específicos de cada unit contendo suas linhas de cobertura.
As linhas amarelas são as que não são possíveis ser testadas, as verdes são as já cobertas pelos testes e as azuis são as que ainda não são cobertas por testes.
O que é o Jenkins?
O Jenkins é uma ferramenta de Integração contínua 2 usada para verificar modificações feitas nas funcionalidades de um software em um curto tempo de sua implementação. Veja mais sobre Jenkins em https://wiki.jenkins-ci.org/display/JENKINS/Meet+Jenkins 3 .
Como integrar com o Jenkins?
Vá até o menu do projeto que deseja inserir o report e selecione a opção configurar.
Selecione a opção “Add post-build action”, que adiciona opções depois que ele executar o projeto. Depois selecione a opção “Publish HTML reports”.
Clique no botão “Adicionar” e insira o diretório dos arquivos HTML e o nome do report gerado que no caso do CodeCoverage é CodeCoverage_summary.html. Depois clique em salvar no fim da mesma página.
Volte ao projeto e a opção de HTML Report estará visível, sendo ela um link para o relatório gerado pelo Code Coverage.
Referências:
http://thundaxsoftware.blogspot.com.br/2013/02/using-delphi-code-coverage.html
https://code.google.com/p/delphi-code-coverage/
https://code.google.com/p/delphi-code-coverage-wizard/
-
Tópico originalmente criado por: @Jonathan Santos
Obs: prestar atenção de onde está puxando o banco
- Abra o gerenciador de tarefas e finalize o aplicativo e o processo.
- Vá até a raiz do manager dentro da pasta BD e faça um backup do arquivo SPDNFEMANAGER e nomeie o arquivo original.
Ex: SPDNFEMANAGERoriginal
- Dentro da pasta UTIL, copie o banco com a descrição VAZIO e cole na pasta DB. Depois nomeie para SPDNFEMANAGER.
-
Volte para a raíz do manager e faça backup do arquivo NFECONFIG.INI, depois nomeie o backup para NFECONFIG.INI
-
Execute o manager para que seja gravado as tabelas no novo banco, depois volte a fechar o processo e o aplicativo no gerenciador de tarefas.
-
baixe e jogue o programa IBPAMP no cenário do cliente e execute-o.
- Na aba STEP 1:
*Abra o diretório na parte superior e direcione o banco original.
*Abra o diretório na parte inferior e direcione o banco novo.
*na parte superior terá um campo chamado DIALECT selecionado o número 1, mude-o para 3
*Teste a conexão de ambos clicando nos “dois” botões TEST CONNECTION. Aparecerá na tela a mensagem “Passed!”
- Na aba STEP 2:
*Clique nos botões GETDEFINITIONS e BUILDRELATIONS e desmarque todos os quadros deixando marcado apenas o primeiro.
- STEP 3:
*Selecionado o primeiro quadro no STEP 2, clique no botão START.
*Ao finalizar a transferência, aparecerá a mensagem ALL FINE ou ERROR (Uma ou mais tabelas dará erro).
*Continue desmarcando o primeiro quadro no STEP 2 e marcando o segundo quadro, volte na STEP 3 e novamente aperte START.
*Faça o mesmo processo em todos os quadros.
- assim que todos os quadros passarem pelo procedimento, vá até a raíz do manager e renomeie o arquivo NFECONFIG.INI para cópia e volte o arquivo original para NFECONFIG.INI
Execute o Manager.
-
Tópico originalmente criado por: @Jonathan Santos
Se você não conhece o Postman ou não sabe como utilizar, confira este outro material que ira solucionar suas dúvidas: Como instalar e utilizar o Postman para enviar requisições HTTP.
Na página de sumário de rotas HTTP incluimos um arquivo .zip com um pacote de requisições para o Postman. Clique abaixo e realize o download.
RELAÇÃO ROTAS DE API POSTMAN (2).zip1- Após a realização do download de ao menos um dos arquivos, extraia para um local de sua preferência. Logo em seguida abra o Postman e clique em “Import”.
2- Clique em “Choose Files”, localize o arquivo que extraiu no primeiro passo, clique em “abrir” e logo após em “Import”.
3- Pronto! As requisições foram importadas e devem aparecer no canto esquerdo dentro de Collections. Para recuperar uma requisição clique sobre seu nome.
-
1
-
-
Tópico originalmente criado por: @renan
Olá pessoal,
Este é o post relacionado a nossa Live que aconteceu no dia 23 de setembro de 2020, transmitida através do Youtube. Falamos sobre adequação de software legado na LGPD.
O webinar foi transmitido em parceria com o BaseFy, do Grupo Raizato que tem empresas como SCC Check e Autêntica.
Gravação da transmissão da Live:
Se você se interessou pelo Basefy, a solução apresentada pelo Manoel na Live, acesse este link aqui.
Disponibilizamos também aqui os termos de aceite e modelos de contrato para LGPD (citado na Live).
Para fazer o download dos PDFs, você precisa estar logado aqui no Hub. Se ainda não tem conta, você pode criar uma gratuitamente agora.
Qualquer dúvida sobre o conteúdo da Live, o Basefy ou sobre os documentos, fique à vontade para responder aqui nesse tópico.
Código de Conduta - Colaboradores.pdf
Clausulas Gerais - LGPD e Demais.pdf
Clausula Contratual - Contrato de Prestação de Serviços - LGPD.pdf
-
Tópico originalmente criado por: @Jonathan Santos
Como já é sabido por nossos clientes, a TecnoSpeed está constantemente mantendo seus produtos atualizados com a legislação vigente e com novas tecnologias. Porém, o que muitos não sabem é que por trás de tudo isso também estamos investido bastante na qualidade de nossos produtos.
A TecnoSpeed sempre teve como prática a utilização de testes automatizados como forma de garantia de qualidade. Por vezes, tivemos problemas com estes testes e em algumas ocasiões foi necessário reescrever conjuntos inteiros de testes, por encontrarem-se defasados.
Por bastante tempo estivemos incomodados com esta situação e passamos a buscar formas de solucionar este problema. A solução veio através da implantação de um servidor de integração contínua com a ferramenta Jenkins.
Nós já conhecíamos o Jenkins há algum tempo, porém a integração do Jenkins com o Delphi parecia impossível para nós. Até que, em 2014, conhecemos o framework de testes DUnitX 1, um fork de um framework bem conhecido para Delphi, o DUnit.
O DunitX nos permitiu integrar o resultado da execução de testes com o Jenkins, o que já foi um grande avanço. Faltava apenas conseguirmos medir o quanto nosso código estava coberto por testes. Para isso, utilizamos a ferramenta Delphi Code Coverage.
Com todas estas ferramentas em mãos, partimos para a integração entre elas, e aí a história começou a tomar novos rumos.
Como a TecnoSpeed melhorou a qualidade de seus produtos?
Ao final de 2014 a TecnoSpeed possuía uma qualidade média dos produtos de 73%, segundo nosso modelo de medição. Precisávamos de novas ações para elevar a qualidade dos produtos para que nossos clientes não fossem afetados e o servidor de integração contínua parecia uma ótima ideia.Porém, tínhamos o desafio de migrar todos os nossos testes, que estavam escritos em DUnit, para o DUnitX. E tínhamos muitos testes para migrar. Porém, acreditamos na ideia e fizemos um grande esforço de migração, com o objetivo de manter nosso servidor de integração contínua rodando todos os testes, o tempo todo.
A migração deu bastante trabalho, porém o novo servidor logo de cara já nos trouxe informações que antes eram complicadas de se obter ou que ficavam “ocultas” em logs e bancos de dados. Agora, era possível saber em tempo real a saúde de nossos testes. Com isso foi visível a nossa mudança de comportamento e o foco que passamos a dar para a criação de testes que aumentassem a cobertura de nosso código. Finalmente tínhamos métricas em tempo real que nos mostravam a direção a seguir, era como se acendêssemos uma luz que havia estado apagada por bastante tempo.
O resultado, após alguns meses de trabalho pesado, foi muito gratificante: Aumentamos consideravelmente a quantidade e qualidade de nossos testes, a também aumentamos a cobertura de testes sobre o código dos produtos. Todos os testes foram migrados para o novo servidor e conseguimos enxergar os pontos fortes e fracos de cada um, criando planos de ação para eles. Hoje, nossos testes são executados várias vezes ao dia, e conseguimos saber imediatamente quando há algum problema. E por fim, a qualidade de nossos produtos subiu para 86% e tem se mantido alta.
Nosso desafio a partir de agora é continuar com a criação de testes cada vez mais especializados. Cada bug reportado em nossos produtos é analisado por nossa equipe e procuramos entender as causas e nosso processo prevê a criação de testes que evitem que o bug volte a acontecer.
Também começamos a automatizar alguns testes que ainda hoje precisam ser feitos manualmente e já conseguimos algum avanço nesta parte, porém ainda há um caminho considerável a percorrer.
Tudo isto é resultado da preocupação da TecnoSpeed em atender seus clientes da melhor maneira possível, se utilizando de tecnologias que venham de encontro às suas necessidades e procurando a excelência em todos os nossos processos!
-
Tópico originalmente criado por: @Jonathan Santos
Nginx ( engine x ) é basicamente um servidor HTTP e proxy reverso, um servidor proxy de email e um servidor proxy TCP ( http://nginx.org/en/ 2). Ou seja, se precisar subir um site, balancear um serviço HTTP, etc… Nginx deve ser sua escolha!
Instalando no Windows
- Vá até a página de downloads: http://nginx.org/en/download.html
- Escolha a Mainline version para Windows: nginx/Windows-1.x.x
- Descompacte em c:\nginx
- Abra o cmd
- $ cd c:\nginx
- $ start nginx
- Abra o navegador de sua preferência e digite: http://localhost
- Deve exibir a mensagem: Welcome to NGINX
Instalando no Linux
CentOS 7
- Crie um arquivo em: /etc/yum.repos.d/nginx.repo
- Com o seguinte conteúdo:
[nginx] name=nginx repo baseurl=http://nginx.org/packages/centos/$releasever/$basearch/ gpgcheck=0 enabled=1- Inicie o serviço…
- $ systemctl start nginx
- Abra o navegador de sua preferência e digite: http://localhost
- Deve exibir a mensagem: Welcome to NGINX
Em caso de dúvidas ou para mais informações acesse: https://www.nginx.com/resources/wiki/start/topics/tutorials/install/
Configurando o balaceamento para o Manager eDoc
- Crie/Edite o arquivo nginx.conf
Windows: c:\nginx\conf\nginx.conf
worker_processes 1; events { worker_connections 1024; } http { include mime.types; default_type application/octet-stream; sendfile on; keepalive_timeout 65; include edoc.conf; }Linux: \etc\nginx\nginx.conf
user nginx; worker_processes auto; error_log /var/log/nginx/error.log warn; pid /var/run/nginx.pid; events { worker_connections 1024; } http { include /etc/nginx/mime.types; default_type application/octet-stream; log_format main '$remote_addr - $remote_user [$time_local] "$request" ' '$status $body_bytes_sent "$http_referer" ' '"$http_user_agent" "$http_x_forwarded_for"'; access_log /var/log/nginx/access.log main; sendfile on; #tcp_nopush on; keepalive_timeout 65; #gzip on; ssl_session_cache shared:SSL:10m; ssl_session_timeout 10m; include /etc/nginx/conf.d/*.conf; }- Crie o arquivo server.conf
Windows: c:\nginx\conf\server.conf
Linux: \etc\nginx\server.confclient_body_buffer_size 10K; client_header_buffer_size 1k; client_max_body_size 8m; large_client_header_buffers 4 8k; client_body_timeout 12; client_header_timeout 12; keepalive_timeout 15; send_timeout 10; gzip on; gzip_comp_level 2; gzip_min_length 1000; gzip_proxied expired no-cache no-store private auth; gzip_types text/plain application/x-javascript text/xml text/css application/xml; access_log off; error_page 497 =301 https://$host:$server_port$request_uri; proxy_connect_timeout 30s; proxy_send_timeout 45s; proxy_read_timeout 3m; server_tokens off; proxy_pass_header Server;- Crie o arquivo proxy_cache.conf
Windows: c:\nginx\conf\proxy_cache.conf
Linux: \etc\nginx\proxy_cache.confproxy_cache_use_stale error timeout invalid_header updating http_500 http_502 http_503 http_504; proxy_cache_revalidate on; proxy_cache_min_uses 3; proxy_cache_lock on; add_header X-Cache-Status $upstream_cache_status;- Crie o arquivo proxy_header.conf
Windows: c:\nginx\conf\proxy_header.conf
Linux: \etc\nginx\proxy_header.confproxy_redirect off; proxy_set_header Host $host:$server_port; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;- Crie o arquivo edoc.conf
Windows: c:\nginx\conf\edoc.conf
Linux: \etc\nginx\conf.d\edoc.conf# No Linux é necessário criar o diretório /data/nginx/cache/edoc # No Windows é necessário alteras este diretório /data/nginx/cache/edoc para "C:/Desenvolvimento/nginx/cache/edoc" proxy_cache_path /data/nginx/cache/edoc levels=1:2 keys_zone=edoc_proxy_cache:10m inactive=24h max_size=1g; upstream edoc { server 127.0.0.1:8081; # server 127.0.0.1:8082; # MODIFIQUE DE ACORDO COM SEUS IP/PORTA server 127.0.0.1:8083; # E QUANTIDADE DE SERVIDORES server 127.0.0.1:8084; # http://nginx.org/en/docs/http/ngx_http_upstream_module.html server 127.0.0.1:8085; # } server { listen 8080; include server.conf; ### Requisições de GUI ### location ~* ^.+\.(?:css|cur|js|jpe?g|gif|htc|ico|png|htm?l|xml|otf|ttf|eot|woff|svg|map)$ { proxy_pass http://edoc; access_log off; expires 10d; tcp_nodelay off; include proxy_header.conf; proxy_cache_valid 200 1d; include proxy_cache.conf; } location ~* (.*)/(nfe|nfce|nfse|cte|mdfe|cfe)/modo { if ($args ~* getConfig) { proxy_pass http://edoc; } if ($request_method ~* (POST|GET)) { proxy_pass http://edoc; } include proxy_header.conf; proxy_cache edoc_proxy_cache; proxy_cache_valid 200 10m; include proxy_cache.conf; } location ~* /spdNewGUI/(obtermodosaas|documentosvisiveis|cidades-habilitadas) { proxy_pass http://edoc; include proxy_header.conf; proxy_cache edoc_proxy_cache; proxy_cache_valid 200 12h; include proxy_cache.conf; } ### Rotas de consulta e imprime sem cache ### location ~* (.*)/(consulta|imprime) { proxy_pass http://edoc; include proxy_header.conf; } ### Demais requisições para ManagerAPIWeb ### location ~* /ManagerAPIWeb/ { proxy_pass http://edoc; include proxy_header.conf; } ### Qualquer outra requisição diferente das demais ### location ~* / { proxy_pass http://edoc; include proxy_header.conf; proxy_cache edoc_proxy_cache; proxy_cache_valid 200 1d; include proxy_cache.conf; } }Feito isso, basta reiniciar o NGINX
Windows:
- Abra o cmd
- $ cd c:\nginx
- nginx -s reload
Linux:
- No terminal
- $ systemctl restart nginx
Agora é só testar:
- Abra o navegador de sua preferência e digite: http://localhost:8081
- Deve exibir a GUI do Manager eDoc
Pronto 🙂
-
Tópico originalmente criado por: @Jonathan Santos
Em um ambiente de desenvolvimento onde existe o controle de versões do código fonte e um grande número de desenvolvedores trabalhando no mesmo produto, uma das situações mais comuns no dia a dia é a ocorrência de conflitos ao se atualizar a cópia local do código fonte para receber as últimas alterações de determinado arquivo, ou seja, o famoso comando Update .
A TecnoSpeed utiliza o controlador de versões Subversion® através da ferramenta open-source TortoiseSVN. Nesse Post será considerado que os conceitos básicos do controle de versão como: Repository, revision, trunk, update, commit, revert, checkout, externals já são conhecidos.
Existem mais de um tipo de conflito, mas nesse post trataremos do tipo mais comum: Conflito de Arquivo (file conflict) . Um conflito de arquivo acontece quando dois desenvolvedores alteram as mesma linhas de código (ou a mesma linha) de um mesmo arquivo fonte. Isso acontece porque cada desenvolvedor possui sua cópia local do repositório, e cada um faz suas alterações localmente. E quando um dos desenvolvedores dá o comando Update para atualizar sua cópia do arquivo o SVN indica que existe um conflito em determinadas linhas do arquivo, mas o SVN não resolve nenhum conflito de forma automática, pois ele não conhece nada sobre a estrutura do projeto em questão.
O SVN faz somente um marcação sobre as linhas onde ocorreu o conflito e cabe ao desenvolvedor resolver o conflito e manter a estrutura e a lógica do código fonte correta. Para visualizar melhor os conceitos e a resolução de um conflito de arquivo, vamos iniciar um passo a passo da resolução de um conflito simples em um arquivo .pas que possui somente uma função que mostra alertas na tela com determinada frase.
Passo 1
Considere o arquivo MostraMensagens.pas com o seguinte conteúdo:
Figura 1.
Passo 2
Considere que o desenvolvedor 1 fez a seguinte alteração conforme abaixo:
Figura 2.
Houve uma mudança da linha 1 da função, a frase foi trocada de ‘Olá’ para ‘Oi’
Passo 3
Agora considere que o desenvolvedor 2 também alterou a mesma linha em sua cópia local conforme abaixo:
Figura 3.
O desenvolvedor 2 também fez uma alteração na linha 1 da função, trocando a frase de ‘Olá’ para ‘E ai!’.
Passo 4
Agora considere que o desenvolvedor 1 executou o comando Update para atualizar sua cópia da função MostraMensagens(). O SVN irá indicar que ocorreu um conflito no arquivo MostraMensagens.pas, conforme imagem abaixo:
Figura 4
Passo 5
Clicando com o botão direito do mouse na linha indicada em vermelho podemos escolher a opção para editar o conflito (edit conflict) ou o mesmo que resolver o conflito, conforme imagem abaixo:
Figura 5
Passo 6
Após clicar em Edit Conflicts um editor será aberto e poderemos verificar exatamente qual linha está em conflito, conforme imagem abaixo:
Figura 6
Note no editor que do lado esquerdo é mostrado o conteúdo da função MostrarMensagens() com a mudança do desenvolvedor 2, em destaque note a palavra Theirs que indica ao desenvolvedor 1 que deu o comando de Update que a alteração foi feita por outro desenvolvedor. (Mudança de ‘Olá’ para ‘E ai!’)
No lado direito note que também é mostrado o conteúdo da função indicada com a palavra Mine que indica ao desenvolvedor 1 que essa é a sua alteração feita na sua cópia local. (Mudança de ‘Olá’ para ‘Oi’)
Passo 7
Para resolver o conflito vamos utilizar o botão Use Blocks conforme figura abaixo:
Figura 7
Existem 4 opções para a resolução desse conflito:
- Use ‘Theirs’ text block : significa que o resultado final será a utilização da alteração feita pelo desenvolvedor 2. A primeira linha da função irá ficar com a frase ‘E ai!’ ignorando a alteração feita pelo desenvolvedor 1. (Figura 😎
- Use ‘mine’ text block : significa que o resultado final será a utilização da alteração do desenvolvedor 1. A primeira linha da função irá ficar com a frase ‘Oi’ ignorando a alteração do desenvolvedor 2. (Figura 9)
- User ‘Theirs’ text block then ‘mine’ : significa que a função irá utilizar como primeira linha a alteração feita pelo desenvolvedor 2 (frase ‘E ai!’) e após a segunda linha ficará com a alteração do desenvolvedor 1 (frase ‘Oi’), ou seja, aconteceu um Merge , ou com outras palavras uma união das duas alterações. (Figura 10)
- Use ‘Mine’ text block then ‘Theirs’ : o SVN também irá manter as duas alterações feitas pelos desenvolvedores 1 e 2 só que na ordem inversa. A alteração do desenvolvedor 1 ficará na primeira linha e a do desenvolvedor 2 na segunda. (Figura 11)
Figura 8.
Figura 9.
Figura 10.
Figura 11.
Após escolher a forma de resolução do conflito, basta clicar no botão salvar e na tela que surge a opção Marked as Resolved conforme figura abaixo:
Figura 12.
Conforme podemos verificar nesse exemplo de resolução de conflito o SVN somente indica ao desenvolvedor que um conflito ocorreu e cabe a esse verificar qual é a solução para o mesmo. Existem casos onde os desenvolvedores precisam entrar em acordo para resolver o conflito e manter o projeto funcionando corretamente.
-
Tópico originalmente criado por: @Jonathan Santos
Bibliotecas utilizadas:
import “fmt”
import “net/http”
import “net/url”
import “io/ioutil”
import “strings”Neste exemplo utilizaremos em um dos dados a serem enviados o conteúdo de um arquivo texto armazenado na máquina local, para carregar o arquivo basta utilizar a função ReadFile da estrutura ioutil.
dat, _ := ioutil.ReadFile("C:\\Go\\src\\DemoEdoc\\teste.tx2")Construindo form com os parametros e valores a serem enviados:
form := url.Values{}orm.Add(“grupo”, “edoc”)
form.Add(“cnpj”, “08187168000160”)
form.Add(“arquivo”, string(dat))Montando requisição a partir da estrutura http(net/http), onde o primeiro parâmetro será o método de comunicação utilizado, o segundo a url onde será disparada a requisição e o terceiro os dados a serem enviados, neste caso iremos utilizar o form que montamos acima, mas para que este seja devidamente interpretado precisamos realizar um encode.
req, _ := http.NewRequest("POST", "http://192.168.2.154:8081/ManagerAPIWeb/nfce/envia",strings.NewReader(form.Encode()))
Definindo Basic Auth:
req.SetBasicAuth("admin", "123mudar")cli := &http.Client{}
Enviando requisição e tratando retorno:
resp, _ := cli.Do(req)//Trata o retorno
fmt.Println(“Status:”, resp.Status)
fmt.Println(“Cabeçalho:”, resp.Header)
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(“Mensagem:”, string(body)) -
Tópico originalmente criado por: @Jonathan Santos
Quando lidamos com geração de XML para envio a servidores de NF-e, NFS-e, dentre outros documentos fiscais, frequentemente lidamos com problemas de erros de esquema de XML. Mas como podemos fazer para identificar esses problemas nos XMLs? Nesse artigo vamos aprender como utilizar a ferramenta oXygen para identificar e corrigir esses problemas.
O oXygen é uma poderosa ferramenta para trabalhar com XML e todo tipo de tecnologia relacionada à XML, porém vamos usar apenas o recurso de validação de Esquema XML. Mas primeiro é melhor explicar do que se isso se trata.
Um esquema XML, também conhecido por XSD (pois essa é a extensão comum dos arquivos de esquema XML), é um XML também, mas é como se fosse uma “receita” de como se fabricar um XML, um conjunto de regras que um determinado XML precisa obedecer para ser considerado válido segundo ele. Isso garante que o conjunto de dados que o XML pretende transmitir esteja consistente com a utilidade que se deseja dar a ele. Frequentemente é a primeira validação de dados que os servidores de documentos fiscais fazem ao receber um XML.
Voltando ao oXygen, vamos primeiramente baixá-lo e instalá-lo. O oXygen XML Editor está disponível em http://www.oxygenxml.com/download_oxygenxml_editor.html 24. Ele requer o Java instalado no sistema. Durante o download, entre com seus dados e registre uma licença trial de 30 dias para poder utilizá-lo. Você irá receber a licença por email.
A instalação é bem fácil (no esquema “next, next, next… finish”), portanto não vou me ater à ela. Depois de instalado, execute o oXygen. Nessa primeira execução, ele irá solicitar a licença, portanto a insira aqui (copie e cole desde o “------START-LICENSE-KEY------” até o “-------END-LICENSE-KEY-------”).
Uma vez aberto, vamos abrir um XML. Para fins de exemplo, nesse artigo estará em anexo um XML de exemplo de NFS-e para o Rio de Janeiro. Baixe-o e abra-o com o oXygen (botão “Open…”).
Repare na barra lateral ao lado do scroll vertical. Ela contém um pequeno quadrado verde no topo. Essa barra indica quaisquer problemas que possa ter com a sintaxe do XML. Verde indica que está tudo OK, vermelho indica problemas, e pequenas faixas vermelhas indicam as posições dos problemas. No momento ela está verde, porém o XML não está ainda sendo confrontado com um esquema XML. Ou seja, é como se o XML estivesse “sintaticamente” correto, mas não sabemos ainda como ele está “semanticamente” (se ele faz “sentido” para o sistema de NFS-e do Rio de Janeiro).
Portanto, vamos agora associar um esquema XML ao nosso XML. Está em anexo também os esquemas XML para NFS-e do Rio de Janeiro (também disponíveis em https://notacarioca.rio.gov.br/manuais.aspx ). Baixe-os para uma pasta de sua preferência.
Clique no botão “Associate Schema…” (parece uma tachinha vermelha).
Depois, clique no botão “Browse for local file”, navegue até a pasta dos arquivos de esquema e escolha o arquivo “tipos_nfse_v01.xsd”.
Perceba que na barra lateral agora o quadradinho está vermelho, e também há uma faixa vermelha mais abaixo. Clicando nessa faixa, o editor te leva ao ponto onde há o problema. Ao passar o mouse em cima do texto sublinhado de vermelho, vemos uma explicação bem técnica sobre o problema.
Traduzindo, isso significa que a tag Cpf, ao possuir 14 caracteres, não está de acordo com o que o esquema XML especifica para essa tag, que é 11 caracteres. Oras, parece que estamos tentando informar um CNPJ na tag do Cpf. Portanto podemos ou informar de fato um CPF, com 11 caracteres numéricos…
… ou trocar a tag para CNPJ.
A barra lateral passa a indicar verde. Seu XML agora está válido segundo o esquema XML, e agora pode ser enviado ao servidor do Rio de Janeiro, porém muito provavelmente ainda será analisado sob outros aspectos (assinatura do XML, validade dos dados em si, etc).
-
Tópico originalmente criado por: @Jonathan Santos
O banco de dados embarcado surgiu para aplicações pequenas nas quais precisamos utilizar um banco de dados mas não queremos instalar um SGBD junto com o produto para executá-lo.
Um banco muito conhecido e eficiente é o Apache Derby, desenvolvido completamente em Java. Por isso é uma excelente opção para aplicações portáveis criadas tambem em Java, como o produto da Tecnospeed Manager Neverstop .
Portanto para este tutorial utilizamos o banco de dados do Manager Neverstop para dar os exemplos de manipulação do banco de dados Derby Embarcado.
Primeiramente para manipular o banco de dados utilizaremos um SQL Client chamado Squirrel . O download pode ser encontrado aqui 22 .
O Squirrel, também é um produto desenvolvido inteiramente em java e suporta além do Derby, vários outros bancos de dados, por isso é altamente recomendado.
Após instalar o Squirrel, siga os passos abaixo:
Para abrir o Squirrel, entre na pasta raiz de instalação e execute o .bat squirrel-sql.bat.
Agora precisamos configurar o Driver do banco de dados Derby Embarcado. Para isso clique em Drivers no menu lateral esquerdo, clique com o botão direito em Apache Derby Embedded e em seguidar clique em Modify Driver .
Seleciona a aba Extra Class Path e clique em Add para adicionarmos o driver do Derby que está em anexo neste post.
Selecione o arquivo e clique em OK .
Após este passo é possível perceber que o nosso driver está com o ícone de ok.
Agora vamos configurar a conexão com o banco de dados.
Para conectar-se ao banco basta clica no ícone de “+” no canto superior esquerdo.
Preencha o name para identificar o banco de dados e selecione o driver do Derby como mostra a imagem abaixo.
No campos URL deve-se informar o caminho para o banco de dados. Quando é um banco de dados embarcado nós temos que configurar o diretório em que se encontra o banco de dados. No exemplo abaixo iremos utilizar o diretório padrão de instalação do banco de dados do Manager Neverstop. A URL deverá ficar da seguinte forma:
jdbc:derby:C:\Arquivos de programas\ManagerNeverStop\resources\database\NeverStopDB
Após isso precisamos preencher o User Name e o Password, que no caso do Manager Neverstop por padrão são admin/admin.
Após estas configurações a tela deve ficar desta forma.
Após isso clique em Test e em seguida em Connect e deverá aparecer uma mensagem dizendo que a conexão foi realizada com sucesso.
Pronto, agora podemos clicar em OK e em seguida conectar no banco de dados do Manager Neverstop.
IMPORTANTE: Como o Derby é um banco de dados embarcado, ele só permite uma conexão por vez, portanto sempre que for tentar se conectar em um banco embarcado, tenha certeza que nenhuma outra aplicação esteja conectada neste banco.
Seguem agora algumas dicas para utilização do Squirrel.
Para executar comandos SQL basta clicar na aba SQL e aplicar os comandos
Para navegar sobre as tabelas e esquemas basta acessar pela treeview do menu lateral esquerdo como mostra a imagem abaixo
-
Nem todo software precisa de documentação, porém uma documentação quando bem feita, sempre torna um software melhor.
Para começarmos a falar sobre documentação, precisamos primeiramente entender que o processo de documentar software muda de empresa para empresa e de produto para produto, porém ele faz parte do processo de produção, então um software que carece de documentação não pode ser considerado como um produto finalizado.
Neste sentido, o que precisa ser documentado?
Aqui na TecnoSpeed, aprendemos com o tempo que uma boa documentação precisa, além de seguir um certo padrão, trazer valor ao usuário final, de forma que ele entenda melhor o problema que está tentando resolver e também consiga utilizar mais facilmente nossos produtos, agilizando seu trabalho e reduzindo seus custos. Desta forma, optamos por seguir alguns passos para documentarmos nossos produtos. São eles:
- Contextualizar o problema
- Contextualizar o produto
- Descrever os detalhes técnicos
Contextualização do Problema
Para contextualizarmos o problema, precisamos explicar o cenário no qual este problema está inserido e quais são as implicações deste cenário. Como trabalhamos com documentos fiscais, procuramos orientar nosso cliente quanto a detalhes do documento fiscal, legislação e datas de obrigatoriedades, por exemplo.
Contextualização do Produto
Para contextualizarmos o produto, precisamos considerar que este é o primeiro contato do cliente com ele, portanto é importante explicarmos o que é o produto, quais são as vantagens de utilizá-lo e os problemas que ele resolve. Procuramos guiar nosso cliente pelo processo de instalação e “primeiro uso”, através de uma demonstração ou de um roteiro de integração. Através da demonstração procuramos conseguir com que o cliente utilize nosso software para realizar uma operação completa, como emitir uma nota fiscal, por exemplo. Já o roteiro de integração procura orientar o cliente a utilizar nosso software da maneira como ele foi pensado para funcionar. Neste momento da documentação, vídeos explicativos e screencasts são muito úteis para facilitar o entendimento.
Detalhes técnicos
Após o cliente estar familiarizado com o cenário e o produto, podemos partir para uma documentação mais técnica. É neste ponto que ferramentas como dicionários de dados e diagramas nos ajudam a explicar mais detalhadamente o comportamento do produto.
Em um componente, por exemplo, precisamos documentar as classes e métodos disponíveis, os parâmetros, retornos e as exceções que podem ser geradas. No caso de um documento fiscal, é importante documentarmos também as rejeições que os WebServices retornam, para que nosso cliente saiba o que fazer caso receba uma rejeição no retorno de uma comunicação.
Por fim, um valor que fica implícito em nossa documentação é que, por ela fazer parte de nosso portal, ela torna-se colaborativa. Nossos funcionários e nossa rede de usuários podem contribuir para criar uma documentação melhor, através de sua participação nos comentários. Isto torna a documentação um artefato vivo do produto, estando em constante evolução. Assim podemos atender em tempo real às necessidades de nossa rede
-
Tópico originalmente criado por: @Jonathan Santos
A ideia de integração continua já discutida em um post anterior ( https://ciranda.me/tsdn/blog-do-desenvolvimento-tecnospeed/post/usando-cobertura-de-codigo-para-delphi-integrado-com-jenkins 3 ), será dada continuidade, nesse post, mostrando agora uma ferramenta para auxilio de cobertura de código para projetos feitos em Java.
As ferramentas que usaremos para fazer a cobertura de código serão plugins do próprio jenkins, diferente da ferramenta usada para Delphi ( deplhi-code-coverage. ) citada no post anterior, que por sua vez só geravam relatórios que seriam usados pelo jenkins.
Usaremos dois plugins que se complementam, são eles o Sonar( http://www.sonarqube.org/ 1 ) e o JaCoCo (https://wiki.jenkins-ci.org/display/JENKINS/JaCoCo+Plugin 3) .
Perceba que para o uso desses plugins, é necessário uma plataforma jenkins já instalada e configurada um job para seu projeto que deseja monitorar( http://jenkins-ci.org/ ).
O primeiro passo é fazer o download do sonarqube no link já citado. Descompacte e selecione a pasta correspondente ao seus sistema operacional dentro da pasta bin. Execute o prompt de comando(cmd) nessa pasta e execute o “StartSonar.bat”, ele funciona como um servidor com um banco de dados em memoria, usado para a analise do código.
O segundo passo para o usos desses pluguins é sua instalação.Vá até a opção “Gerenciar Jenkins” no menu principal e escolha a opção gerenciar pluguins. Selecione a aba “Disponíveis” e procure pelo plugin Sonar e JaCoCo.
Depois de sua instalação, dentro do menu “Gerenciar Jenkins” selecione a opção configurar sistema, procure pela seção do plugin Sonar e adicione-o(necessário selecionar um nome). Clique em avançado e coloque o ip da máquina em que o server que o servidor sonar estiver rodando, caso esteja rodando na mesma máquina, basta deixar vazio que a configuração default é a localhost(máquina local).
Agora vá até o job que deseja configurar e selecione “Configurar” e vá até a opção “Add post-build action”. Selecione a opção “Record JaCoCo coverage report”. Ainda na mesma opção adicione também o“Sonar”.
As duas opções devem funcionar automaticamente, sem serem reconfiguradas. Caso se tenha problemas selecione a “?” nas opções que possuem dicas de como ser feita sua configuração.
PS: Perceba que as configurações de como irá surgir o sol(status do job) precisa ser informado em porcentagem de cobertura.O ultimo passo agora é verificar se o arquivo .pom do seu projeto java está com JaCoCo inserido em sua seção de plugins.
01.<build>02.<plugins>03.<plugin>04.<groupId>org.jacoco</groupId>05.<artifactId>jacoco-maven-plugin</artifactId>06.<version>${jacoco.version}</version>07.<executions>08.<execution>09.<goals>10.<goal>prepare-agent</goal>11.</goals>12.</execution>13.<execution>14.<id>report</id>15.<phase>prepare-package</phase>16.<goals>17.<goal>report</goal>18.</goals>19.</execution>20.</executions>21.</plugin>22.</plugins>23.</build>Depois disso basta construir o projeto e ele apresentará os dados da cobertura de código.
Agora será possível ver no próprio job as linhas que estão sendo cobertas pelas linhas de código e as que não estão, divididos em porcentagem.
Clicando no link Sonar que agora se encontra no job, podemos ver os dados gerados pelo sonar. Podemos verificar desde dividas técnicas (segundo regras configuradas) até problemas de escrita no codigo.
É possível ainda incluir muito mais plugins em seu job do Jenkins, que ajudam a tornar o deploy de seus produtos com ainda mais qualidade!
Maiores informações sobre os plugins podem ser encontradas nas referências desse post.
Referencias
http://www.sonarqube.org/measure-coverage-by-integration-tests-with-sonar-updated/http://www.eclemma.org/jacoco/trunk/doc/maven.html
http://www.methodsandtools.com/tools/tools.php?sonar
http://www.lordofthejars.com/2012/08/jacoco-jenkins-plugin.html
-
Tópico originalmente criado por: @Jonathan Santos
Para que serve o Inno Setup?
Ele serve para criar pacotes de instalaçao de programas, ou seja, com ele é possível definir todos arquivos e componentes que farão ou precisam estar presentes na máquina do usuário, para que funcione da forma esperada.
O Inno Setup foi desenvolvido em Delphi, mas nada impede de utiliza-lo na geração de pacotes de outras linguagens.
Como ele é feito em Delphi, ele tem a seção code que se utiliza da linguagem Pascal para o desenvolvimento e melhorias na criação do pacote.Onde encontramos o Inno Setup para download?
Neste link: http://www.jrsoftware.org/isdl.php 20
Exemplo prático utilizando o Wizard
Primeiro passo para nosso exemplo é a instalação do Inno Setup, faça o download no link descrito acima e depois dê inicio nesse exemplo.
Essa é a tela inicial do Inno Setup instalado.
Para iniciar a criação, clique no botão wizard e irá se abrir uma janela do passo a passo como abaixo.
Feito o passo anterior, é preciso informar alguns dados como nome da sua aplicação versão e a empresa que está disponibilizando, são todos dados não obrigatórios, mas que fazem a diferença em um pacote do produto.
Na imagem abaixo, você pode escolher para onde será o destino da sua aplicação e o nome da pasta o qual será instalado.
Um dos pontos mais importantes da criação é o executável principal, que pode ser escolhido nesta seção do wizard.
Abaixo, temos a opção de adicionar arquivos ou pastas visto que nossos sistemas nem sempre é feito apenas de executáveis, adicione quantos forem preciso.Nesta parte é escolhida o nome da pasta que irá aparecer no iniciar do windows, e alguns checkbox que definem se será preciso adicionar ou não e o link de desinstalação do seu pacote.
Aqui é possível definir arquivos que serão abertos após a instalação e o termo de licensa de uso do seu sistema, onde o usuário só instalará se estiver de acordo com suas normas ou regras.
O inno setup está preparado para várias linguagens e aqui você pode definir quais usará.
Após todo este wizard e “next next” que vimos logo acima, ao finalizar o wizard, o inno setup irá gerar este arquivo com extensão .iss que é o arquivo utilizado para geração e muito mais fácil manutenção e este pode ser versionado para controle de alterações.
Após ter certeza que adicionou todos arquivos e alterações e configurações do seu sistema estão OK, basta clicar em Compile, este abrirá uma janela como abaixo, e nesta compilação é verificado a existencia dos arquivos e dependências e estão tudo dentro do esperado irá gerar seu Setup, e para testar basta executa-lo utilizando o F9 caso ainda esteja nessa página, ou execuntado diretamente seu Setup.
Bom, este foi um exemplo básico de como criar um instalador com Inno Setup, teremos um post mais elaborado abordando assuntos mais avançados que são registros de DLL e codificação dentro do .iss .
-
Tópico originalmente criado por: @Jonathan Santos
Antes de começar, já que a instalação demora, saiba que se você sabe construir páginas para a web ( AngularJS , jQuery , React , HTML + CSS + JS puro , etc…), você pode criar aplicativos para Android , IOS , Windows Phone , e demais plataformas. Fique até o fim, você vai ver que é verdade e além disso vai pensar: Puts, era só isso!?
Bom, o que é Apache Cordova ? Basicamente é um cara que com um único código é possível criar aplicações híbridas, ou seja, funciona nas plataformas mobile mais conhecidas. Ele é Free e Open Source , tem suporte a plugins para uso de recursos nativos tais como bateria, vibra, câmera, etc… E é muito, mas muito fácil de trabalhar ( https://cordova.apache.org/ 6).
Sem mais, vamos a configuração do ambiente. Baixe e instale:
JDK 1.8 - http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html 3
Android Studio - http://developer.android.com/intl/pt-br/sdk/index.html 2(última versão)Dentro do Android Studio, baixe as seguintes SDKs:
- Tools/Android SDK Tools (última versão)
- Tools/Android SDK Platform Tools (última versão)
- SDK Platform API 23
- Extras/Google Repository
- Extras/Support Library
- Extras/Support Repository
ATENÇÃO! Para ver essas SDKs, crie um projeto qualquer e encontre na barra superior um ícone do Android com a seta para baixo.
Por fim, instale o NodeJS, a versão LTS mais recente - http://nodejs.org 1
Como disse, isso vai demorar um pouco, vá até a garrafa mais próxima pegue um café, troque umas ideias de inovação com seu companheiro de trabalho, implemente algo e volte…
…
Legal! Parece que você já voltou! Já instalou tudo? Se algo não der certo, entre em contato, terei o prazer de ajudar
Agora vamos ter que editar as variáveis de ambiente, aqui vou me ater somente ao Windows, mas o mesmo processo deverá ser feito para Linux e Mac.
-
Use a busca do Windows ou encontre as ‘Propriedades do Sistema’ e clique no botão ‘Variáveis de Ambiente’
-
Edite a variável ‘PATH’ e após o ; adicione os seguintes paths:
C:\Users\ seu.usuario \AppData\Local\Android\sdk\platform-tools
C:\Users\ seu.usuario \AppData\Local\Android\sdk\tools -
Não esqueça de trocar o seu.usuario para o nome do usuário que está utilizando na máquina
-
Agora num prompt de comando (cmd) teste 4 comandos: java, javac, android, node --version
-
Se nenhum deu erro, ótimo, podemos ir mais além agora, caso algo dê errado, não se esqueça, entre em contato!
Agora, enfim, chegamos no Apache Cordova:
- No cmd, digite ‘ npm install -g cordova ’ (esse também demora um pouquinho)
- Crie uma pasta qualquer, caminhe até ela no cmd e digite: cordova create . br.com.tecnospeed.myApp myApp
- Agora adicione uma plataforma, no nosso caso, vamos adicionar apenas a android: cordova platform add android
- Por fim, se tudo estiver ok: cordova run android (isso abrirá um emulador)
- Ao abrir, deverá aparecer a logo do Apache Cordova e uma tarja verde com o escrito: DEVICE IS READY
- Caso queria testar direto no Android basta plugá-lo a sua máquina e mandar rodar o run novamente. Se por ventura não funcionar, verifique se os drivers para o seu celular estão instalados e se o seu Android está habilitado o modo desenvolvedor ( http://www.techtudo.com.br/dicas-e-tutoriais/noticia/2014/10/como-ativar-o-modo-desenvolvedor-no-android.html 1).
- Ou ainda, você servir no seu navegador, usando o comando: cordova serve
Até aqui tudo certo?
Seguindo, como instalar e utilizar um plugin do Apache Cordova:
- Acesse o site: https://cordova.apache.org/plugins/ 3
- Busque por: device
- Verifique o nome dele e execute o comando: cordova plugin add cordova-plugin-device
- Vá até a pasta do projeto, no arquivo www\js\index.js adicione as seguintes linhas, dentro da função onDeviceReady :
document.getElementById('info').innerHTML = '<br>' + device.cordova + '<br>' + device.model + '<br>' + device.platform + '<br>' + device.uuid + '<br>' + device.version + '<br>' + device.manufacturer + '<br>' + device.isVirtual + '<br>' + device.serial + '<br>';- Agora no arquivo www\index,html após a linha 44 adicione apenas:
<div id="info"></div>- Execute o cordova run android comando para testar
- Deve ter aparecido os dados sobre o dispositivo, caso não aparaeça, talvez seja necessário inspecionar o código gerar e a saída do console, e esse é o próximo passo…
Inspecionar minha aplicação Android pelo computador
- Fácil, fácil
- Vá até o seu Google Chrome e na barra de endereços digite: chrome://inspect/#devices
- Com o seu Android conectado ao PC, o mesmo irá aparecer na listagem e ai basta apenas clicar em inspect e verificar ou fazer o que bem entender.
Próximo passo!
Caso queria gerar o seu aplicativo para IOS por exemplo, você PRECISA ter um Mac. Existem alguns serviços online em que você aluga uma máquina Mac para esse fim, porém ter um Mac em mãos facilita e muito o seu trabalho. Vale ressaltar que para publicar seus aplicativos você precisa ter contas de desenvolvedor tanto no Google quanto na Apple, mas isso é assunto para uma outra hora…
Não acredite que por serem híbridas essa aplicações ficarão extremamente lentas ou absurdamente mais lentas em relação as linguagens nativas, isso é minimo e acaba não importando. O futuro está em aplicações Web, logo este é o futuro, pode confiar, se bem construído, você terá mobile apps poderosos e multi-plataforma.
Estamos encerrando por aqui, mas como o Apache Cordova aceita HTML + CSS + JS você ganha uma gama de possibilidades, tais como utilizar jQuery além do javascript nativo, construir um app em AngularJS ou ReactJS , enfim, o limite aqui é até onde vai sua criatividade e disposição. Só não se esqueça de considerar o fato que cada plataforma tem o seu design pattern, não estrague o UX do seu usuário.
É isso pessoal, meu muito obrigado e até!
-
Tópico originalmente criado por: @Jonathan Santos
O TClientDataSet é uma estrutura de acesso a dados em memória que está presente no Delphi desde as suas primeiras versões. Este componente é um dos mais utilizados por desenvolvedores, tendo muitas aplicações práticas.
Porém, este mesmo componente apresenta alguns problemas com consumo de memória, especialmente em cenários multi-threaded , por não ser um componente que está completamente otimizado este tipo de cenário. Apesar de não apresentar problemas de Memory Leak , o próprio consumo de memória do componente pode causar o travamento da aplicação, geralmente com erros de “Insufficient Memory for this Operation” ou “Out of Memory”.
Para reduzir o impacto deste problema, existem alternativas à utlização do TClientDataSet, como trabalhar com dados em arquivo ao invés de memória, trabalhar com estruturas de dados que utilizam Generics ou trocar o TClientDataSet por componentes de terceiros que têm a mesma finalidade, como o KbmMemTable
-
Tópico originalmente criado por: @Jonathan Santos
Durante o desenvolvimento e manutenção de sistemas de software, por melhor que os desenvolvedores possam ser, erros podem ser cometidos. Um dos erros mais difíceis de serem detectados são os chamados Memory Leaks, principalmente por não causarem erros aparentes na execução dos programas, mas nem por isso são menos destrutivos quando não tratados.
Memory Leaks, ou “Vazamento de Memória”, é um problema que ocorre quando porções de memória utilizadas pelo programa não são liberadas depois de utilizadas. Isso faz com que o programa passe a usar mais e mais memória, nunca liberando, e pode por fim consumir toda a memória RAM, causando graves problemas ao sistema (ex: lentidão, travamentos, erros de execução, etc). Esse problema é particularmente grave em sistemas que são executados por longos períodos, como serviços, aplicações para servidores, drivers de dispositivos, sistemas embarcados, etc.
Portanto, vamos demonstrar como podemos capturar esse problema em nossas aplicações Delphi, usando a ferramenta Eureka Log (versão trial disponível em https://www.eurekalog.com/ 23). Usarei nesse artigo o Delphi 7 com o EurekaLog 7. Vale notar também que até o momento de escrita desse artigo, o EurekaLog é compatível com Delphi 3 em diante até o Delphi XE6.
Antes de instalar o EurekaLog, feche quaisquer Delphis abertos. Instalar o EurekaLog é bem simples (inclusive está em português), não vou me alongar muito nesse ponto, apenas gostaria de destacar que é possível escolher para quais versões de Delphi presentes no sistema você deseja instalar o EurekaLog.
Depois de instalado, ao abrir o Delphi, notem que foi criado mais um item de menu chamado “EurekaLog”. Porém, não é nesse menu que vamos encontrar as opções que iremos usar. Na verdade, há mais um item de menu criado, dessa vez dentro do menu “Project”, o “EurekaLog Options”. Isso deve-se ao fato de o EurekaLog armazenar suas configurações individualmente para cada projeto.
Ao entrar nessa tela, veja que a princípio o EurekaLog encontra-se desativado, portanto devemos ativá-lo marcando “Activate EurekaLog”. Certifique-se de que em “Project Type” esteja selecionado “VCL Forms Application”.
Entre na seção “Memory Problems” e certifique-se de estar marcado a opção “Catch memory leaks”, e clique em OK.
Depois disso dê um Build em seu projeto (menu Project --> Build). É isso, tudo pronto para detectar os memory leaks do seu projeto!
Para demonstração, vou deixar como anexo desse artigo um pequeno projeto com botões que causam memory leaks de duas formas bastante comuns de ocorrer. A primeira forma é não “dar Free” no final de uso de uma instância de objeto. A segunda forma é criar duas instâncias e atribuir as duas à mesma variável, fazendo com que a primeira instância tenha sua referência perdida. Para fins didáticos, deixei nesse projeto o EurekaLog desativado, para ativar siga as etapas já citadas.
Agora para detectar os memory leaks, execute sua aplicação e use-a da maneira que achar conveniente. Procure usar os recursos que você desconfia que está causando memory leaks. No caso da demonstração, clique nos botões algumas vezes. Ao fechar o aplicativo, caso haja detecção de leaks, será aberto uma mensagem de erro, informando que o aplicativo contém erros. Se tiver escrito “Application has leaked memory”, encontramos memory leaks.
Para abrir um relatório dos leaks encontrados, clique no “click here” da mensagem. Será aberta uma tela enumerando todos os memory leaks encontrados, tipo, tamanho, quantidade, dentre inúmeras outras informações. Em cada leak, há toda a “call stack” do momento da detecção do leak, e essa é a parte mais útil, pois aqui podemos descobrir o ponto exato da sua aplicação que está causando o leak. Para isso, procure na coluna Procedure/Method nomes de rotinas que lhe sejam familiar em relação ao seu projeto.
Ao dar clique-duplo na linha, o EurekaLog lhe levará ao Delphi na linha da rotina que causou o memory leak.
Para corrigir o memory leak ainda depende do desenvolvedor identificar e corrigir dentro dessa rotina a causa do leak (no caso do exemplo, remover a dupla instanciação).
Por fim, algumas observações: ao entregar releases do seu produto aos seus clientes, desative antes o EurekaLog, senão caso aconteça leaks que não foram removidos, ao encerrar a aplicação vai aparecer aquele diálogo do erro por memory leaks. Outro detalhe é mais para os desenvolvedores que utilizam controle de versão (Git, Subversion, Mercurial, etc): o EurekaLog armazena suas configurações junto às configurações do projeto, e isso causa diferenças de versionamento e pode causar alguns problemas. As configurações não são eliminadas mesmo quando desativa-se o EurekaLog, portanto a única maneira que vejo de eliminar as configurações do EurekaLog do seu projeto é desinstalando ele.
-
1
-
-
Tópico originalmente criado por: @Jonathan Santos
Escrito por Andrew Hunt e David Thomas, dois dos fundadores do Manifesto Ágil, o livro The Pragmatic Programmer se tornou uma referência para programadores que buscam aprimorar suas habilidades. Através de análises de casos reais e aprendizados de anos de experiência no mercado, os autores estabeleceram uma série de princípios e conceitos que compreendem as características e responsabilidades de um programador pragmático.
Este artigo é uma tentativa de, em poucas palavras, introduzir o conceito de pragmatismo no contexto da programação segundo os autores e servir como um breve resumo do livro.
O que torna um programador, pragmático?
Apesar de todo programador ser único e possuir pontos fortes e fracos, algumas características são inerentes à todo programador que se diz ser dedicado e responsável em seu trabalho, sendo elas:
- Adaptação rápida: Instinto por técnicas e tecnologias. Capacidade e interesse em se aprender novas tecnologias e associar o aprendizado ao conhecimento já obtido.
- Inquisição: Interesse em se obter clareza. Questionar e analisar toda situação intrínseca à dado problema.
- Pensamento crítico: Atitude de procurar entender e se assegurar da razão e dos motivos antes de fazer qualquer suposição.
- Realismo: Capacidade de compreender a real natureza de dado problema de forma a não idealizar possíveis soluções, mas sim entender o que pode ser feito de fato.
- Versatilidade: Disposição em se relacionar com várias áreas. Mesmo enquanto especialista, estar disposto a aprender e adquirir um leque genérico de conhecimento.
Para se tornar um programador pragmático é necessário pensar sobre o que você está fazendo, enquanto você está fazendo. Não basta fazer uma auditoria isolada para se obter resultados positivos, mas sim criar o hábito de efetuar uma constante avaliação crítica de cada decisão que você tomou ou que pretende tomar. Em outras palavras, é necessário desligar o piloto automático e se fazer presente e consciente de toda ação tomada, estar constantemente pensando e criticando seu trabalho com base nos princípios do pragmatismo.
Princípios a serem seguidos
Ao longo dos capítulos o livro trata sobre vários princípios de como aprimorar sua atitude enquanto programador. Existem muitos livros dedicados inteiramente à alguns destes princípios, tamanha a importância e recorrência dos problemas que eles se propõem a resolver.
1. Não se repita (DRY - Don’t Repeat Yourself)
Evite ambiguidade e duplicação. Toda parte do conhecimento deve possuir somente uma representação em todo o sistema.
2. Reflita sobre seu trabalho
Desligue o piloto automático. Critique e avalie constantemente seu trabalho.
3. Seja um catalisador de mudança
Você não pode impor mudanças às pessoas. Ao invés disso, mostre a elas como o futuro pode ser e ajude-as a participar de sua criação.
4. Invista regularmente em seu portfólio de conhecimento
Faça da aprendizagem um hábito. Procure apender algo novo relacionado ao seu trabalho todo dia.
5. A maneira como você diz é tão importante quanto o que você diz
Não adianta ter ótimas idéias se você não as comunica eficientemente.
6. Facilite a reutilização
Se for fácil de reutilizar, as pessoas reutilizarão. Crie as circunstâncias que favoreçam a reutilização.
7. Não suponha, prove
Prove suas suposições no cenário real, com dados reais e limites reais. Desta forma não haverá dúvidas sobre a eficácia da solução proposta.
8. Refatore cedo, refatore sempre
Assim como você deve regar e cuidar de um jardim, reescreva, reorganize e reconstrua o código quando necessário. Ataque a raiz do problema.
9. Projete para testar
Comece a pensar em teste antes mesmo de programar uma linha sequer. Evite código que não possa ser testado.
10. O código não está pronto até todos os testes estarem passando
Palavras para se viver.
Essas foram somente algumas das dicas e dos princípios apresentados pelo livro, inclusive, em sua versão original, o livro vem acompanhado de uma folha que pode ser destacada servindo como um guia de referência rápido com mais de 70 dicas além de resenhas sobre os pontos mais importantes de cada capítulo. De fato um ótimo item para se ter sempre à disposição.
Em suma, se está interessado em saber mais sobre como aprimorar seu trabalho enquanto desenvolvedor, não pense duas vezes antes de adquirir este livro. A versão original em inglês pode ser obtida através da Amazon e já existem versões em português em lojas no Brasil como a Saraiva.
Boa leitura.
-
Comentário originalmente feito por: elijah.junnior
Sim eu refiz os testes, agora já estou conseguindo realizar os consumos. Acredito que o problema tenha sido a minha implementação, fiz algumas alterações e tudo passou a funcioanar
Padrão Único NFSe - O que é?
em Desenvolvimento de Software
Postado
Esse artigo tem como objetivo explicar o que é o modelo de padrão único de nota fiscal de serviços (NFS-e) oferecido pelo Componente NFSe da Tecnospeed, e quais são as vantagens em usá-lo.
Cenário atual da NFS-e
Para se entender o problema abordado pelo Padrão Único, primeiramente é necessário se explicar como está o cenário de NFS-e atualmente.
Existem no momento inúmeros sistemas de NFS-e empregados pelos munícipios, cada um com seu modelo de comunicação de dados. Nós da Tecnospeed costumamos nomeá-los de acordo com seu fabricante ou, no caso dos padrões desenvolvidos pela própria prefeitura do município, o próprio nome do município ou órgão municipal que o desenvolveu. Alguns dos mais conhecidos são Ginfes, Betha, Ábaco, IssNetOnline, SIGISS, Simpliss, GovBR, dentre outros.
Existe também um padrão criado pelo próprio governo federal, mais precisamente pela Associação Brasileira das Secretarias de Finanças das Capitais (ABRASF), que desenvolveu um padrão que tinha como objetivo servir de base para todos os sistemas de NFS-e. Naturalmente nós o chamamos de padrão ABRASF. Não vou me alongar nos detalhes desse padrão, mas vale citar que esse modelo especificava o esquema dos XMLs usados em toda a comunicação entre os ERPs e o sistema de NFS-e da prefeitura.
De fato, muitos dos padrões de NFS-e são baseados no padrão ABRASF, porém, pelo fato de o padrão ABRASF não ser mandatório, mas sim apenas um modelo conceitual, existem os que são bastante diferentes, tanto na estrutura dos XMLs usados para envio dos lotes de notas quanto no modelo de comunicação. Ao passo que o padrão ABRASF estabeleceu um modelo assíncrono (o lote não é processado imediatamente) alguns padrões são síncronos (os lotes são processados no momento do envio). Alguns possuem serviços a mais além dos estabelecidos pelo padrão ABRASF, outros a menos, ou com parâmetros diferentes, outros com comportamentos diferentes. Mesmo os que seguiram o padrão ABRASF, cada um seguiu à sua maneira, fazendo adaptações conforme suas necessidades. A verdade é que cada padrão tem sua própria maneira de trabalhar, suas peculiaridades, etc.
Vários padrões, vários layouts de integração diferentes
O Componente NFSe, em relação aos serviços de NFSe especificados pelo padrão ABRASF (envio de lotes, consulta de situação do lote, consulta do lote, consulta de nota por NFSe, consulta de nota por RPS e cancelamento) consegue estabelecer uma interface razoavelmente comum entre os diversos padrões. Uma consulta de nota por NFSe, por exemplo, para dois padrões com funcionamento bastante diferente, vai ser chamada pelo ERP ao componente de uma única maneira.
Porém, para o layout do envio dos lotes de notas não havia um “denominador comum”. Cada padrão exige um conjunto diferente de dados, com campos com nomes diferentes e até mesmo formatos de dados diferentes, e cabia ao desenvolvedor que se utilizava do Componente NFSe estudar os campos dos inúmeros padrões existentes, e saber quais dados usar em quais campos desses padrões. Isso aumentava muito a complexidade do uso do Componente NFSe.
Padrão Único: vários padrões, um único layout de integração
Foi pensando em diminuir esse problema de “Torre de Babel” que a Tecnospeed criou o Padrão Único NFSe. Ele funciona como um “esperanto”, ou seja, uma “linguagem universal”, que será traduzida para os diferentes layouts exigidos pelos padrões.
O objetivo do Padrão Único é possibilitar a emissão de NFS-es para todos os padrões através de um único layout, e ainda ser flexível o suficiente para permitir se trabalhar com as particularidades de cada padrão. Ou seja, um ERP se utilizando do Padrão Único irá especificar sempre os mesmos campos com os mesmos formatos de dados independente do município para o qual ele estará emitindo notas, e deixar ao Componente NFSe a tarefa de saber que campos do Padrão Único correspondem a que campos do padrão do município, e que formato de dados ele usa.
O Padrão Único estabelece um “denominador comum” entre os padrões, e com ele é possível se emitir NFS-e para para a grande maioria dos casos de emissão de notas de serviço. Em um cenário típico, o Padrão Único oferece tudo o que é necessário para se emitir NFS-es para os municípios homologados no Componente NFSe. Porém é importante ressaltar que ele não cobre todos os campos particulares de todos os padrões, apenas os essenciais e que tem funcionalidade em comum. Pode eventualmente surgir a necessidade de se informar dados particulares ao um padrão que não são cobertos pelo Padrão Único. Nesses casos, o Padrão Único oferece uma maneira de se especificar esses dados especiais, informando no arquivo de integração o nome do campo do padrão do município com um “@” (arroba) no início. Vale lembrar que esses casos são bastante raros de se acontecer.
Raros também são os padrões que não são cobertos pelo Padrão Único, devido a um grau de diferença tamanho entre esse padrão e o padrão ABRASF que impossibilitou traçar qualquer paralelo entre os campos dos dois padrões. Até o momento nos deparamos com apenas um padrão assim, usado por poucos municípios, para o qual deve ainda ser usado o layout próprio do padrão.
No final, o Padrão Único vem se mostrando uma poderosa ferramenta capaz de reduzir imensamente o esforço dos desenvolvedores na implementação da emissão de NFS-e pelos seus produtos.
Tópico originalmente criado por: @Jonathan Santos