diff --git a/gradle.properties b/gradle.properties index bd7309b..8d0c7be 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1 +1 @@ -version=0.0.28-BETA +version=1.0.0-SNAPSHOT diff --git a/src/main/java/br/com/correios/api/postagem/CorreiosPostagemApi.java b/src/main/java/br/com/correios/api/postagem/CorreiosPostagemApi.java index 1a64253..1a4b961 100644 --- a/src/main/java/br/com/correios/api/postagem/CorreiosPostagemApi.java +++ b/src/main/java/br/com/correios/api/postagem/CorreiosPostagemApi.java @@ -9,8 +9,10 @@ import br.com.correios.api.postagem.exception.ObjetoPlpFoiPostadoException; import br.com.correios.api.postagem.exception.ObjetoPlpInexistenteOuJaFoiCanceladoException; import br.com.correios.api.postagem.exception.ObjetoPlpJaFoiCanceladoException; -import br.com.correios.api.postagem.plp.CorreiosLogToPlpDocumentoConverter; +import br.com.correios.api.postagem.plp.CorreiosLogToDocumentoPlpConverter; import br.com.correios.api.postagem.plp.DocumentoPlp; +import br.com.correios.api.postagem.plp.NovaPlpBuilder; +import br.com.correios.api.postagem.plp.NovaPlpToCorreiosLogConverter; import br.com.correios.api.postagem.plp.ObjetoPostado; import br.com.correios.api.postagem.webservice.CorreiosClienteWebService; import br.com.correios.api.postagem.xml.XmlPlpParser; @@ -26,7 +28,7 @@ public class CorreiosPostagemApi { private final CorreiosServicoPostagemAPI correiosServicoPostagemAPI; public CorreiosPostagemApi(CorreiosCredenciais credenciais) { - this.correiosServicoPostagemAPI = new SoapCorreiosServicoPostagemAPI(credenciais, new CorreiosClienteWebService(), new ClienteRetornadoDosCorreiosToClienteConverter(), new XmlPlpParser(), new CorreiosLogToPlpDocumentoConverter()); + this.correiosServicoPostagemAPI = new SoapCorreiosServicoPostagemAPI(credenciais, new CorreiosClienteWebService(), new ClienteRetornadoDosCorreiosToClienteConverter(), new XmlPlpParser(), new CorreiosLogToDocumentoPlpConverter(), new NovaPlpToCorreiosLogConverter()); } /** @@ -78,4 +80,10 @@ public void cancelaObjetoDaPlp(Long plpId, String numeroEtiqueta) throws ObjetoP } } + /** + * Cria uma nova PLP atraves dos dados do pacote, destinatario e remetente (metodo fechaPLP do WSDL do Correios) + */ + public NovaPlpBuilder novaPlp() { + return new NovaPlpBuilder(correiosServicoPostagemAPI); + } } diff --git a/src/main/java/br/com/correios/api/postagem/CorreiosServicoPostagemAPI.java b/src/main/java/br/com/correios/api/postagem/CorreiosServicoPostagemAPI.java index 73ff27e..c80435e 100644 --- a/src/main/java/br/com/correios/api/postagem/CorreiosServicoPostagemAPI.java +++ b/src/main/java/br/com/correios/api/postagem/CorreiosServicoPostagemAPI.java @@ -5,6 +5,8 @@ import br.com.correios.api.postagem.cliente.ClienteEmpresa; import br.com.correios.api.postagem.cliente.ContratoEmpresa; import br.com.correios.api.postagem.plp.DocumentoPlp; +import br.com.correios.api.postagem.plp.NovaPlp; +import br.com.correios.api.postagem.plp.Plp; public interface CorreiosServicoPostagemAPI { @@ -15,4 +17,6 @@ public interface CorreiosServicoPostagemAPI { Optional buscaDocumentoPlp(Long plpId, String etiqueta); boolean cancelaObjetoDaPlp(Long plpId, String numeroEtiqueta); + + Plp fechaPlp(String cartaoDePostagem, Long codigoPlpCliente, NovaPlp novaPlp); } diff --git a/src/main/java/br/com/correios/api/postagem/SoapCorreiosServicoPostagemAPI.java b/src/main/java/br/com/correios/api/postagem/SoapCorreiosServicoPostagemAPI.java index 63a64ec..f75f6e4 100644 --- a/src/main/java/br/com/correios/api/postagem/SoapCorreiosServicoPostagemAPI.java +++ b/src/main/java/br/com/correios/api/postagem/SoapCorreiosServicoPostagemAPI.java @@ -2,14 +2,23 @@ import static java.lang.String.format; +import java.util.LinkedList; +import java.util.List; + import com.google.common.base.Optional; -import br.com.correios.api.converter.Converter; import br.com.correios.api.exception.CorreiosServicoSoapException; import br.com.correios.api.postagem.cliente.ClienteEmpresa; +import br.com.correios.api.postagem.cliente.ClienteRetornadoDosCorreiosToClienteConverter; import br.com.correios.api.postagem.cliente.ContratoEmpresa; import br.com.correios.api.postagem.exception.CorreiosPostagemAutenticacaoException; +import br.com.correios.api.postagem.plp.CorreiosLogToDocumentoPlpConverter; import br.com.correios.api.postagem.plp.DocumentoPlp; +import br.com.correios.api.postagem.plp.NovaPlp; +import br.com.correios.api.postagem.plp.NovaPlpToCorreiosLogConverter; +import br.com.correios.api.postagem.plp.ObjetoPlp; +import br.com.correios.api.postagem.plp.Plp; +import br.com.correios.api.postagem.plp.PlpNaoFechadaException; import br.com.correios.api.postagem.webservice.CorreiosClienteApi; import br.com.correios.api.postagem.xml.Correioslog; import br.com.correios.api.postagem.xml.XmlPlpParser; @@ -23,21 +32,22 @@ class SoapCorreiosServicoPostagemAPI implements CorreiosServicoPostagemAPI { private final CorreiosClienteApi clienteApi; private final CorreiosCredenciais credenciais; - private final Converter clienteEmpresaConverter; + private final ClienteRetornadoDosCorreiosToClienteConverter clienteEmpresaConverter; private final XmlPlpParser xmlPlpParser; - private final Converter> documentoPlpConverter; + private final CorreiosLogToDocumentoPlpConverter documentoPlpConverter; + private final NovaPlpToCorreiosLogConverter correiosPlpConverter; - SoapCorreiosServicoPostagemAPI(CorreiosCredenciais credenciais, - CorreiosClienteApi clienteApi, - Converter clienteEmpresaConverter, - XmlPlpParser xmlPlpParser, - Converter> documentoPlpConverter) { + SoapCorreiosServicoPostagemAPI(CorreiosCredenciais credenciais, CorreiosClienteApi clienteApi, + ClienteRetornadoDosCorreiosToClienteConverter clienteEmpresaConverter, XmlPlpParser xmlPlpParser, + CorreiosLogToDocumentoPlpConverter documentoPlpConverter, + NovaPlpToCorreiosLogConverter correiosPlpConverter) { this.credenciais = credenciais; this.clienteApi = clienteApi; this.clienteEmpresaConverter = clienteEmpresaConverter; this.xmlPlpParser = xmlPlpParser; this.documentoPlpConverter = documentoPlpConverter; + this.correiosPlpConverter = correiosPlpConverter; } @Override @@ -45,10 +55,8 @@ public Optional buscaCliente(ContratoEmpresa contratoEmpresa) { try { ClienteERP clienteRetornadoDosCorreios = clienteApi.getCorreiosWebService().buscaCliente(contratoEmpresa.getContrato(), contratoEmpresa.getCartaoDePostagem(), credenciais.getUsuario(), credenciais.getSenha()); - return Optional.fromNullable(clienteRetornadoDosCorreios) - .transform(clienteEmpresaConverter::convert) - .transform(Optional::of) - .or(Optional.absent()); + return Optional.fromNullable(clienteRetornadoDosCorreios).transform(clienteEmpresaConverter::convert) + .transform(Optional::of).or(Optional.absent()); } catch (AutenticacaoException e) { throw new CorreiosPostagemAutenticacaoException(format("Ocorreu um erro ao se autenticar nos correios com a seguinte credencial: %s", credenciais)); @@ -62,20 +70,13 @@ public Optional buscaDocumentoPlp(Long plpId) { try { String xmlPlp = clienteApi.getCorreiosWebService().solicitaXmlPlp(plpId, credenciais.getUsuario(), credenciais.getSenha()); - boolean xmlPlpDosCorreiosEstaValido = xmlPlp != null && !xmlPlp.isEmpty(); + return getDocumentoPlpValidadoAPartirDo(xmlPlp); - if (xmlPlpDosCorreiosEstaValido) { - return xmlPlpParser.convert(xmlPlp) - .transform(documentoPlpConverter::convert) - .or(Optional.absent()); - } } catch (AutenticacaoException e) { throw new CorreiosPostagemAutenticacaoException(format("Ocorreu um erro ao se autenticar nos correios com a seguinte credencial: %s", credenciais)); } catch (SigepClienteException e) { throw new CorreiosServicoSoapException(format("Ocorreu um erro ao chamar o servico com o PLP de id %d", plpId), e); } - - return Optional.absent(); } @Override @@ -83,20 +84,13 @@ public Optional buscaDocumentoPlp(Long plpId, String etiqueta) { try { String xmlPlp = clienteApi.getCorreiosWebService().solicitaPLP(plpId, etiqueta, credenciais.getUsuario(), credenciais.getSenha()); - boolean xmlPlpDosCorreiosEstaValido = xmlPlp != null && !xmlPlp.isEmpty(); + return getDocumentoPlpValidadoAPartirDo(xmlPlp); - if (xmlPlpDosCorreiosEstaValido) { - return xmlPlpParser.convert(xmlPlp) - .transform(documentoPlpConverter::convert) - .or(Optional.absent()); - } } catch (AutenticacaoException e) { throw new CorreiosPostagemAutenticacaoException(format("Ocorreu um erro ao se autenticar nos correios com a seguinte credencial: %s", credenciais)); } catch (SigepClienteException e) { throw new CorreiosServicoSoapException(format("Ocorreu um erro ao chamar o servico com o PLP de id %d", plpId), e); } - - return Optional.absent(); } @Override @@ -110,4 +104,40 @@ public boolean cancelaObjetoDaPlp(Long plpId, String numeroEtiqueta) { } } + private Optional getDocumentoPlpValidadoAPartirDo(String xmlPlp) { + boolean xmlPlpDosCorreiosEstaValido = xmlPlp != null && !xmlPlp.isEmpty(); + + if (xmlPlpDosCorreiosEstaValido) { + Optional correiosLog = xmlPlpParser.getObjectFrom(xmlPlp); + + if (correiosLog.isPresent() && correiosLog.get().getPlp() != null) { + return Optional.of(documentoPlpConverter.convert(correiosLog.get())); + } + } + + return Optional.absent(); + } + + @Override + public Plp fechaPlp(String cartaoDePostagem, Long codigoPlpCliente, NovaPlp novaPlp) { + try { + Correioslog correiosLog = correiosPlpConverter.convert(novaPlp); + + List etiquetasSemDigitoVerificador = new LinkedList<>(); + + for (ObjetoPlp objetoPlp : novaPlp.getObjetosPlp()) { + etiquetasSemDigitoVerificador.add(objetoPlp.getNumeroDaEtiquetaSemDigitoVerificador()); + } + + String xmlFrom = xmlPlpParser.getXmlFrom(correiosLog); + + Long plpId = clienteApi.getCorreiosWebService() + .fechaPlpVariosServicos(xmlFrom, codigoPlpCliente, cartaoDePostagem, etiquetasSemDigitoVerificador, credenciais.getUsuario(), credenciais.getSenha()); + + return new Plp(plpId); + } catch (Exception e) { + throw new PlpNaoFechadaException(e); + } + } + } diff --git a/src/main/java/br/com/correios/api/postagem/destinatario/DestinatarioDoObjeto.java b/src/main/java/br/com/correios/api/postagem/destinatario/DestinatarioDoObjeto.java index f862e1c..d1ad8e5 100644 --- a/src/main/java/br/com/correios/api/postagem/destinatario/DestinatarioDoObjeto.java +++ b/src/main/java/br/com/correios/api/postagem/destinatario/DestinatarioDoObjeto.java @@ -23,13 +23,12 @@ public class DestinatarioDoObjeto { * * Somente o Complemento não é obrigatório */ - private EnderecoDoDestinatario enderedo; + private EnderecoDoDestinatario endereco; - public DestinatarioDoObjeto(String nome, DadosDeContatoDoDestinatario dadosDeContato, - EnderecoDoDestinatario enderedo) { + public DestinatarioDoObjeto(String nome, DadosDeContatoDoDestinatario dadosDeContato, EnderecoDoDestinatario endereco) { this.nome = nome; this.dadosDeContato = dadosDeContato; - this.enderedo = enderedo; + this.endereco = endereco; } public String getNome() { @@ -40,8 +39,8 @@ public DadosDeContatoDoDestinatario getDadosDeContato() { return dadosDeContato; } - public EnderecoDoDestinatario getEnderedo() { - return enderedo; + public EnderecoDoDestinatario getEndereco() { + return endereco; } } diff --git a/src/main/java/br/com/correios/api/postagem/exception/PlpException.java b/src/main/java/br/com/correios/api/postagem/exception/ParseIncorretoNoXmlPlpException.java similarity index 50% rename from src/main/java/br/com/correios/api/postagem/exception/PlpException.java rename to src/main/java/br/com/correios/api/postagem/exception/ParseIncorretoNoXmlPlpException.java index 19f6287..50c728f 100644 --- a/src/main/java/br/com/correios/api/postagem/exception/PlpException.java +++ b/src/main/java/br/com/correios/api/postagem/exception/ParseIncorretoNoXmlPlpException.java @@ -1,10 +1,10 @@ package br.com.correios.api.postagem.exception; -public class PlpException extends RuntimeException { +public class ParseIncorretoNoXmlPlpException extends RuntimeException { private static final long serialVersionUID = 4238354294423806208L; - public PlpException(String message, Exception e) { + public ParseIncorretoNoXmlPlpException(String message, Exception e) { super(message, e); } } diff --git a/src/main/java/br/com/correios/api/postagem/plp/CorreiosLogToPlpDocumentoConverter.java b/src/main/java/br/com/correios/api/postagem/plp/CorreiosLogToDocumentoPlpConverter.java similarity index 70% rename from src/main/java/br/com/correios/api/postagem/plp/CorreiosLogToPlpDocumentoConverter.java rename to src/main/java/br/com/correios/api/postagem/plp/CorreiosLogToDocumentoPlpConverter.java index 98fb9b7..5328686 100644 --- a/src/main/java/br/com/correios/api/postagem/plp/CorreiosLogToPlpDocumentoConverter.java +++ b/src/main/java/br/com/correios/api/postagem/plp/CorreiosLogToDocumentoPlpConverter.java @@ -3,8 +3,6 @@ import java.util.ArrayList; import java.util.List; -import com.google.common.base.Optional; - import br.com.correios.api.converter.Converter; import br.com.correios.api.postagem.remetente.RemetenteDaPostagem; import br.com.correios.api.postagem.remetente.RemetenteDosCorreiosToRemetenteConverter; @@ -13,14 +11,12 @@ import br.com.correios.api.postagem.xml.ObjetoPostal; import br.com.correios.api.postagem.xml.Remetente; -public class CorreiosLogToPlpDocumentoConverter implements Converter> { +public class CorreiosLogToDocumentoPlpConverter implements Converter { @Override - public Optional convert(Correioslog correioslog) { + public DocumentoPlp convert(Correioslog correioslog) { DadosPlp plpDosCorreios = correioslog.getPlp(); - if (plpDosCorreios == null) { - return Optional.absent(); - } + InformacoesPlp plp = new PlpDosCorreiosToPlpConverter().convert(plpDosCorreios); Remetente remetenteDosCorreios = correioslog.getRemetente(); @@ -36,9 +32,7 @@ public Optional convert(Correioslog correioslog) { listaDeObjetosPostados.add(objetoPostado); } - DocumentoPlp documentoPlp = new DocumentoPlp(correioslog.getTipoArquivo(), correioslog.getVersaoArquivo(), plp, remetente, correioslog.getFormaPagamento(), listaDeObjetosPostados); - - return Optional.of(documentoPlp); + return new DocumentoPlp(correioslog.getTipoArquivo(), correioslog.getVersaoArquivo(), plp, remetente, correioslog.getFormaPagamento(), listaDeObjetosPostados); } } diff --git a/src/main/java/br/com/correios/api/postagem/plp/DestinatarioDoObjetoPlp.java b/src/main/java/br/com/correios/api/postagem/plp/DestinatarioDoObjetoPlp.java new file mode 100644 index 0000000..461d499 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/DestinatarioDoObjetoPlp.java @@ -0,0 +1,21 @@ +package br.com.correios.api.postagem.plp; + +public class DestinatarioDoObjetoPlp { + + private final String nome; + private final Endereco endereco; + + DestinatarioDoObjetoPlp(String nome, Endereco endereco) { + this.nome = nome; + this.endereco = endereco; + } + + public String getNome() { + return nome; + } + + public Endereco getEndereco() { + return endereco; + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/DestinatarioDoObjetoPlpBuilder.java b/src/main/java/br/com/correios/api/postagem/plp/DestinatarioDoObjetoPlpBuilder.java new file mode 100644 index 0000000..10f011f --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/DestinatarioDoObjetoPlpBuilder.java @@ -0,0 +1,42 @@ +package br.com.correios.api.postagem.plp; + +public class DestinatarioDoObjetoPlpBuilder { + + private String nome; + private Endereco endereco; + + public DestinatarioDoObjetoPlpComNomeBuilder comNome(String nomeDoDestinatario) { + this.nome = nomeDoDestinatario; + return new DestinatarioDoObjetoPlpComNomeBuilder(this); + } + + public class DestinatarioDoObjetoPlpComNomeBuilder { + + private DestinatarioDoObjetoPlpBuilder builder; + + public DestinatarioDoObjetoPlpComNomeBuilder(DestinatarioDoObjetoPlpBuilder builder) { + this.builder = builder; + } + + public DestinatarioDoObjetoPlpComEnderecoBuilder comEndereco(Endereco enderecoDoDestinatario) { + builder.endereco = enderecoDoDestinatario; + return new DestinatarioDoObjetoPlpComEnderecoBuilder(builder); + } + + } + + public class DestinatarioDoObjetoPlpComEnderecoBuilder { + + private DestinatarioDoObjetoPlpBuilder builder; + + public DestinatarioDoObjetoPlpComEnderecoBuilder(DestinatarioDoObjetoPlpBuilder builder) { + this.builder = builder; + } + + public DestinatarioDoObjetoPlp build() { + return new DestinatarioDoObjetoPlp(builder.nome, builder.endereco); + } + + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/DimensoesDoObjetoPlp.java b/src/main/java/br/com/correios/api/postagem/plp/DimensoesDoObjetoPlp.java new file mode 100644 index 0000000..93da45a --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/DimensoesDoObjetoPlp.java @@ -0,0 +1,43 @@ +package br.com.correios.api.postagem.plp; + +import java.math.BigDecimal; + +import br.com.correios.api.postagem.dimensao.DimensoesDoObjeto.TipoDoObjetoSendoEnviado; + +public class DimensoesDoObjetoPlp { + + private final TipoDoObjetoSendoEnviado tipoDoObjetoSendoEnviado; + private final BigDecimal altura; + private final BigDecimal comprimento; + private final BigDecimal largura; + private final BigDecimal diametro; + + DimensoesDoObjetoPlp(TipoDoObjetoSendoEnviado tipoDoObjetoSendoEnviado, BigDecimal altura, BigDecimal comprimento, BigDecimal largura, BigDecimal diametro) { + this.tipoDoObjetoSendoEnviado = tipoDoObjetoSendoEnviado; + this.altura = altura; + this.comprimento = comprimento; + this.largura = largura; + this.diametro = diametro; + } + + public BigDecimal getAltura() { + return altura; + } + + public BigDecimal getComprimento() { + return comprimento; + } + + public BigDecimal getLargura() { + return largura; + } + + public BigDecimal getDiametro() { + return diametro; + } + + public TipoDoObjetoSendoEnviado getTipoDoObjetoSendoEnviado() { + return tipoDoObjetoSendoEnviado; + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/DimensoesDoObjetoPlpBuilder.java b/src/main/java/br/com/correios/api/postagem/plp/DimensoesDoObjetoPlpBuilder.java new file mode 100644 index 0000000..e791073 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/DimensoesDoObjetoPlpBuilder.java @@ -0,0 +1,140 @@ +package br.com.correios.api.postagem.plp; + +import java.math.BigDecimal; + +import br.com.correios.api.postagem.dimensao.DimensoesDoObjeto.TipoDoObjetoSendoEnviado; + +public class DimensoesDoObjetoPlpBuilder { + + private BigDecimal altura; + private BigDecimal comprimento; + private BigDecimal largura; + private BigDecimal diametro; + private TipoDoObjetoSendoEnviado tipoDoObjetoSendoEnviado; + + public DimensoesDoObjetoPlpDoTipoPacoteOuCaixaBuilder doTipoPacoteOuCaixa() { + this.tipoDoObjetoSendoEnviado = TipoDoObjetoSendoEnviado.PACOTE_OU_CAIXA; + return new DimensoesDoObjetoPlpDoTipoPacoteOuCaixaBuilder(this); + } + + public DimensoesDoObjetoPlpDoTipoRoloOuCilindroBuilder doTipoRoloOuCilindro() { + this.tipoDoObjetoSendoEnviado = TipoDoObjetoSendoEnviado.ROLO_OU_CILINDRO; + return new DimensoesDoObjetoPlpDoTipoRoloOuCilindroBuilder(this); + } + + public DimensoesDoObjetoPlpDoTipoEnvelopeBuilder doTipoEnvelope() { + this.tipoDoObjetoSendoEnviado = TipoDoObjetoSendoEnviado.ENVELOPE; + return new DimensoesDoObjetoPlpDoTipoEnvelopeBuilder(this); + } + + public class DimensoesDoObjetoPlpDoTipoPacoteOuCaixaBuilder { + + private DimensoesDoObjetoPlpBuilder builder; + + private DimensoesDoObjetoPlpDoTipoPacoteOuCaixaBuilder(DimensoesDoObjetoPlpBuilder builder) { + this.builder = builder; + } + + public DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComAlturaBuilder comAltura(BigDecimal alturaDaCaixa) { + builder.altura = alturaDaCaixa; + return new DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComAlturaBuilder(builder); + } + } + + public class DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComAlturaBuilder { + + private DimensoesDoObjetoPlpBuilder builder; + + private DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComAlturaBuilder(DimensoesDoObjetoPlpBuilder builder) { + this.builder = builder; + } + + public DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComComprimentoBuilder comComprimento(BigDecimal comprimentoDaCaixa) { + builder.comprimento = comprimentoDaCaixa; + return new DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComComprimentoBuilder(builder); + } + } + + public class DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComComprimentoBuilder { + + private DimensoesDoObjetoPlpBuilder builder; + + private DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComComprimentoBuilder(DimensoesDoObjetoPlpBuilder builder) { + this.builder = builder; + } + + public DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComLarguraBuilder comLargura(BigDecimal larguraDaCaixa) { + builder.largura = larguraDaCaixa; + return new DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComLarguraBuilder(builder); + } + } + + public class DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComLarguraBuilder { + + private DimensoesDoObjetoPlpBuilder builder; + + private DimensoesDoObjetoPlpDoTipoPacoteOuCaixaComLarguraBuilder(DimensoesDoObjetoPlpBuilder builder) { + this.builder = builder; + } + + public DimensoesDoObjetoPlp build() { + return new DimensoesDoObjetoPlp(builder.tipoDoObjetoSendoEnviado, builder.altura, builder.comprimento, builder.largura, builder.diametro); + } + } + + public class DimensoesDoObjetoPlpDoTipoRoloOuCilindroBuilder { + + private DimensoesDoObjetoPlpBuilder builder; + + private DimensoesDoObjetoPlpDoTipoRoloOuCilindroBuilder(DimensoesDoObjetoPlpBuilder builder) { + this.builder = builder; + } + + public DimensoesDoObjetoPlpDoTipoRoloOuCilindroComComprimentoBuilder comComprimento(BigDecimal comprimentoDoCilindro) { + builder.comprimento = comprimentoDoCilindro; + return new DimensoesDoObjetoPlpDoTipoRoloOuCilindroComComprimentoBuilder(builder); + } + } + + public class DimensoesDoObjetoPlpDoTipoRoloOuCilindroComComprimentoBuilder { + + private DimensoesDoObjetoPlpBuilder builder; + + private DimensoesDoObjetoPlpDoTipoRoloOuCilindroComComprimentoBuilder(DimensoesDoObjetoPlpBuilder builder) { + this.builder = builder; + } + + public DimensoesDoObjetoPlpDoTipoRoloOuCilindroComDiametroBuilder comDiametro(BigDecimal diametroDoCilindro) { + builder.diametro = diametroDoCilindro; + return new DimensoesDoObjetoPlpDoTipoRoloOuCilindroComDiametroBuilder(builder); + } + } + + public class DimensoesDoObjetoPlpDoTipoRoloOuCilindroComDiametroBuilder { + + private DimensoesDoObjetoPlpBuilder builder; + + private DimensoesDoObjetoPlpDoTipoRoloOuCilindroComDiametroBuilder(DimensoesDoObjetoPlpBuilder builder) { + this.builder = builder; + } + + public DimensoesDoObjetoPlp build() { + return new DimensoesDoObjetoPlp(builder.tipoDoObjetoSendoEnviado, builder.altura, builder.comprimento, builder.largura, builder.diametro); + } + } + + public class DimensoesDoObjetoPlpDoTipoEnvelopeBuilder { + + private DimensoesDoObjetoPlpBuilder builder; + + private DimensoesDoObjetoPlpDoTipoEnvelopeBuilder(DimensoesDoObjetoPlpBuilder builder) { + this.builder = builder; + } + + public DimensoesDoObjetoPlp build() { + return new DimensoesDoObjetoPlp(builder.tipoDoObjetoSendoEnviado, builder.altura, builder.comprimento, builder.largura, builder.diametro); + } + + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/Endereco.java b/src/main/java/br/com/correios/api/postagem/plp/Endereco.java new file mode 100644 index 0000000..bdfcd29 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/Endereco.java @@ -0,0 +1,53 @@ +package br.com.correios.api.postagem.plp; + +import br.com.correios.Cep; + +public class Endereco { + + private final Cep cep; + private final String logradouro; + private final Integer numero; + private final String complemento; + private final String bairro; + private final String cidade; + private final String uf; + + Endereco(Cep cep, String logradouro, Integer numero, String complemento, String bairro, String cidade, String uf) { + this.cep = cep; + this.logradouro = logradouro; + this.numero = numero; + this.complemento = complemento; + this.bairro = bairro; + this.cidade = cidade; + this.uf = uf; + } + + public Cep getCep() { + return cep; + } + + public String getLogradouro() { + return logradouro; + } + + public Integer getNumero() { + return numero; + } + + public String getComplemento() { + return complemento; + } + + public String getBairro() { + return bairro; + } + + public String getCidade() { + return cidade; + } + + public String getUf() { + return uf; + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/EnderecoBuilder.java b/src/main/java/br/com/correios/api/postagem/plp/EnderecoBuilder.java new file mode 100644 index 0000000..04011f4 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/EnderecoBuilder.java @@ -0,0 +1,129 @@ +package br.com.correios.api.postagem.plp; + +import br.com.correios.Cep; + +public class EnderecoBuilder { + + private Cep cep; + private String logradouro; + private Integer numero; + private String complemento; + private String bairro; + private String cidade; + private String uf; + + public EnderecoComCepBuilder cep(Cep cepEndereco) { + this.cep = cepEndereco; + return new EnderecoComCepBuilder(this); + } + + public class EnderecoComCepBuilder { + + private EnderecoBuilder builder; + + private EnderecoComCepBuilder(EnderecoBuilder builder) { + this.builder = builder; + } + + public EnderecoComLogradouroBuilder logradouro(String logradouroEndereco) { + builder.logradouro = logradouroEndereco; + return new EnderecoComLogradouroBuilder(builder); + } + + } + + public class EnderecoComLogradouroBuilder { + + private EnderecoBuilder builder; + + private EnderecoComLogradouroBuilder(EnderecoBuilder builder) { + this.builder = builder; + } + + public EnderecoComNumeroBuilder numero(Integer numeroEndereco) { + this.builder.numero = numeroEndereco; + return new EnderecoComNumeroBuilder(builder); + } + + } + + public class EnderecoComNumeroBuilder { + + private EnderecoBuilder builder; + + private EnderecoComNumeroBuilder(EnderecoBuilder builder) { + this.builder = builder; + } + + public EnderecoComComplementoBuilder complemento(String complementoDoEndereco) { + this.builder.complemento = complementoDoEndereco; + return new EnderecoComComplementoBuilder(builder); + } + + } + + public class EnderecoComComplementoBuilder { + + private EnderecoBuilder builder; + + private EnderecoComComplementoBuilder(EnderecoBuilder builder) { + this.builder = builder; + } + + public EnderecoComBairroBuilder bairro(String nomeBairro) { + this.builder.bairro = nomeBairro; + return new EnderecoComBairroBuilder(builder); + } + + } + + public class EnderecoComBairroBuilder { + + private EnderecoBuilder builder; + + private EnderecoComBairroBuilder(EnderecoBuilder builder) { + this.builder = builder; + } + + public EnderecoComCidadeBuilder cidade(String nomeDaCidade) { + this.builder.cidade = nomeDaCidade; + return new EnderecoComCidadeBuilder(builder); + } + + } + + public class EnderecoComCidadeBuilder { + + private EnderecoBuilder builder; + + private EnderecoComCidadeBuilder(EnderecoBuilder builder) { + this.builder = builder; + } + + public EnderecoComUfBuilder uf(String ufEstado) { + this.builder.uf = ufEstado; + return new EnderecoComUfBuilder(builder); + } + + } + + public class EnderecoComUfBuilder { + + private EnderecoBuilder builder; + + private EnderecoComUfBuilder(EnderecoBuilder builder) { + this.builder = builder; + } + + public Endereco build() { + return new Endereco(builder.cep, + builder.logradouro, + builder.numero, + builder.complemento, + builder.bairro, + builder.cidade, + builder.uf); + } + + } +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/NovaPlp.java b/src/main/java/br/com/correios/api/postagem/plp/NovaPlp.java new file mode 100644 index 0000000..8beca42 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/NovaPlp.java @@ -0,0 +1,23 @@ +package br.com.correios.api.postagem.plp; + +import java.util.Set; + +public class NovaPlp { + + private final RemetentePlp remetente; + private final Set objetosPlp; + + public NovaPlp(RemetentePlp remetente, Set objetosPlp) { + this.remetente = remetente; + this.objetosPlp = objetosPlp; + } + + public RemetentePlp getRemetente() { + return remetente; + } + + public Set getObjetosPlp() { + return objetosPlp; + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/NovaPlpBuilder.java b/src/main/java/br/com/correios/api/postagem/plp/NovaPlpBuilder.java new file mode 100644 index 0000000..278d845 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/NovaPlpBuilder.java @@ -0,0 +1,86 @@ +package br.com.correios.api.postagem.plp; + +import static com.google.common.collect.Sets.newHashSet; + +import java.util.Set; + +import br.com.correios.api.postagem.CorreiosServicoPostagemAPI; + +public class NovaPlpBuilder { + + private String cartaoDePostagem; + private RemetentePlp remetente; + private Set objetosPlp; + private Long codigoPlpCliente = 0l; + private CorreiosServicoPostagemAPI correiosServicoPostagemAPI; + + public NovaPlpBuilder(CorreiosServicoPostagemAPI correiosServicoPostagemAPI) { + this.correiosServicoPostagemAPI = correiosServicoPostagemAPI; + } + + public NovaPlpComCartaoDePostagemBuilder comCartaoDePostagem(String cartaoDePostagem) { + this.cartaoDePostagem = cartaoDePostagem; + return new NovaPlpComCartaoDePostagemBuilder(this); + } + + public class NovaPlpComCartaoDePostagemBuilder { + + private NovaPlpBuilder builder; + + public NovaPlpComCartaoDePostagemBuilder(NovaPlpBuilder builder) { + this.builder = builder; + } + + public NovaPlpComRemetenteBuilder deRemetente(RemetentePlp remetente) { + builder.remetente = remetente; + return new NovaPlpComRemetenteBuilder(builder); + } + + } + + public class NovaPlpComRemetenteBuilder { + + private NovaPlpBuilder builder; + + private NovaPlpComRemetenteBuilder(NovaPlpBuilder builder) { + this.builder = builder; + } + + public NovaPlpComObjetoAdicionadoBuilder adicionandoObjeto(ObjetoPlp objetoPlp) { + builder.objetosPlp = newHashSet(objetoPlp); + return new NovaPlpComObjetoAdicionadoBuilder(builder); + } + + public NovaPlpComObjetoAdicionadoBuilder adicionandoObjetos(Set objetosPlp) { + builder.objetosPlp = objetosPlp; + return new NovaPlpComObjetoAdicionadoBuilder(builder); + } + + } + + public class NovaPlpComObjetoAdicionadoBuilder { + + private NovaPlpBuilder builder; + + private NovaPlpComObjetoAdicionadoBuilder(NovaPlpBuilder builder) { + this.builder = builder; + } + + public NovaPlpComObjetoAdicionadoBuilder adicionandoObjeto(ObjetoPlp objetoPlp) { + builder.objetosPlp.add(objetoPlp); + return new NovaPlpComObjetoAdicionadoBuilder(builder); + } + + public NovaPlpComObjetoAdicionadoBuilder comCodigoPlpCliente(Long codigoPlpCliente) { + builder.codigoPlpCliente = codigoPlpCliente; + return this; + } + + public Plp fechaPlp() { + return correiosServicoPostagemAPI.fechaPlp(cartaoDePostagem, codigoPlpCliente, new NovaPlp(builder.remetente, builder.objetosPlp)); + } + + } + + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/NovaPlpToCorreiosLogConverter.java b/src/main/java/br/com/correios/api/postagem/plp/NovaPlpToCorreiosLogConverter.java new file mode 100644 index 0000000..196dff1 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/NovaPlpToCorreiosLogConverter.java @@ -0,0 +1,115 @@ +package br.com.correios.api.postagem.plp; + +import java.math.BigDecimal; + +import br.com.correios.api.converter.Converter; +import br.com.correios.api.postagem.dimensao.DimensoesDoObjeto.TipoDoObjetoSendoEnviado; +import br.com.correios.api.postagem.xml.Correioslog; +import br.com.correios.api.postagem.xml.DadosPlp; +import br.com.correios.api.postagem.xml.Destinatario; +import br.com.correios.api.postagem.xml.DimensaoObjeto; +import br.com.correios.api.postagem.xml.Nacional; +import br.com.correios.api.postagem.xml.ObjetoPostal; +import br.com.correios.api.postagem.xml.Remetente; +import br.com.correios.api.postagem.xml.ServicoAdicional; + +public class NovaPlpToCorreiosLogConverter implements Converter { + + private static final String POSTAGEM = "Postagem"; + private static final String CARTAO_POSTAGEM = ""; + private static final BigDecimal VERSAO_ARQUIVO = BigDecimal.valueOf(2.3); + + @Override + public Correioslog convert(NovaPlp novaPlp) { + + Correioslog correioslog = new Correioslog(); + correioslog.setTipoArquivo(POSTAGEM); + correioslog.setVersaoArquivo(VERSAO_ARQUIVO); + + DadosPlp plp = new DadosPlp(); + plp.setCartaoPostagem(CARTAO_POSTAGEM); + + correioslog.setPlp(plp); + + correioslog.setRemetente(asRemetente(novaPlp.getRemetente())); + + for (ObjetoPlp objetoPlp : novaPlp.getObjetosPlp()) { + correioslog.getObjetoPostal().add(asObjetoPostal(objetoPlp)); + } + + return correioslog; + } + + private Remetente asRemetente(RemetentePlp remetentePlp) { + Remetente remetente = new Remetente(); + + remetente.setNomeRemetente(remetentePlp.getNome()); + remetente.setEmailRemetente(remetentePlp.getEmail()); + remetente.setNumeroContrato(remetentePlp.getNumeroContrato()); + remetente.setNumeroDiretoria(Byte.parseByte(remetentePlp.getNumeroDeDiretoria())); + remetente.setCodigoAdministrativo(remetentePlp.getCodigoAdministrativo()); + + Endereco enderecoPlp = remetentePlp.getEndereco(); + remetente.setBairroRemetente(enderecoPlp.getBairro()); + remetente.setCepRemetente(enderecoPlp.getCep().value()); + remetente.setCidadeRemetente(enderecoPlp.getCidade()); + remetente.setComplementoRemetente(enderecoPlp.getComplemento()); + remetente.setLogradouroRemetente(enderecoPlp.getLogradouro()); + remetente.setNumeroRemetente(String.valueOf(enderecoPlp.getNumero())); + remetente.setUfRemetente(enderecoPlp.getUf()); + + return remetente; + } + + private ObjetoPostal asObjetoPostal(ObjetoPlp objetoPlp) { + ObjetoPostal objetoPostal = new ObjetoPostal(); + Endereco endereco = objetoPlp.getDestinatarioDoObjeto().getEndereco(); + DimensoesDoObjetoPlp dimensoesDoObjeto = objetoPlp.getDimensoesDoObjeto(); + + objetoPostal.setNumeroEtiqueta(objetoPlp.getNumeroDaEtiqueta()); + objetoPostal.setCodigoServicoPostagem(objetoPlp.getCodigoDeServico()); + objetoPostal.setPeso(objetoPlp.getPesoDoObjeto().emGramas().toBigInteger()); + + Destinatario destinatario = new Destinatario(); + destinatario.setComplementoDestinatario(endereco.getComplemento()); + destinatario.setLogradouroDestinatario(endereco.getLogradouro()); + destinatario.setNomeDestinatario(objetoPlp.getDestinatarioDoObjeto().getNome()); + destinatario.setNumeroEndDestinatario(String.valueOf(endereco.getNumero())); + + objetoPostal.setDestinatario(destinatario); + + Nacional nacional = new Nacional(); + nacional.setBairroDestinatario(endereco.getBairro()); + nacional.setCidadeDestinatario(endereco.getCidade()); + nacional.setUfDestinatario(endereco.getUf()); + nacional.setCepDestinatario(endereco.getCep().value()); + + objetoPostal.setNacional(nacional); + + ServicoAdicional servicoAdicional = new ServicoAdicional(); + objetoPlp.getCodigoServicosAdicionais().forEach(servicoAdicional::addCodigoServicoAdicional); + objetoPlp.getValorDeclaradoParaEncomenda().ifPresent(valorDeclaradoParaEncomenda -> { + servicoAdicional.setValorDeclarado(valorDeclaradoParaEncomenda.toEngineeringString()); + }); + + objetoPostal.setServicoAdicional(servicoAdicional); + + DimensaoObjeto dimensaoObjeto = new DimensaoObjeto(); + + TipoDoObjetoSendoEnviado tipoDoObjetoSendoEnviado = objetoPlp.getDimensoesDoObjeto().getTipoDoObjetoSendoEnviado(); + + if(TipoDoObjetoSendoEnviado.ENVELOPE != tipoDoObjetoSendoEnviado) { + dimensaoObjeto.setDimensaoAltura(dimensoesDoObjeto.getAltura().toEngineeringString()); + dimensaoObjeto.setDimensaoComprimento(dimensoesDoObjeto.getComprimento().toEngineeringString()); + dimensaoObjeto.setDimensaoDiametro(dimensoesDoObjeto.getDiametro().signum()); + dimensaoObjeto.setDimensaoLargura(dimensoesDoObjeto.getLargura().toEngineeringString()); + } + + dimensaoObjeto.setTipoObjeto(Short.valueOf(dimensoesDoObjeto.getTipoDoObjetoSendoEnviado().getCodigoInternoDosCorreios())); + + objetoPostal.setDimensaoObjeto(dimensaoObjeto); + + return objetoPostal; + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/ObjetoPlp.java b/src/main/java/br/com/correios/api/postagem/plp/ObjetoPlp.java new file mode 100644 index 0000000..c30deae --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/ObjetoPlp.java @@ -0,0 +1,61 @@ +package br.com.correios.api.postagem.plp; + +import java.math.BigDecimal; +import java.util.Optional; +import java.util.Set; + +public class ObjetoPlp { + + private final DimensoesDoObjetoPlp dimensoesDoObjeto; + private final PesoDoObjetoPlp pesoDoObjeto; + private final String codigoDeServico; + private final String numeroDaEtiqueta; + private final DestinatarioDoObjetoPlp destinatarioDoObjeto; + private final Set codigoServicosAdicionais; + private final BigDecimal valorAdicionalDoSeguro; + + ObjetoPlp(DimensoesDoObjetoPlp dimensoesDoObjeto, PesoDoObjetoPlp pesoDoObjeto, String codigoDeServico, + String numeroDaEtiqueta, DestinatarioDoObjetoPlp destinatarioDoObjeto, Set codigoServicosAdicionais, + BigDecimal valorAdicionalDoSeguro) { + this.dimensoesDoObjeto = dimensoesDoObjeto; + this.pesoDoObjeto = pesoDoObjeto; + this.codigoDeServico = codigoDeServico; + this.numeroDaEtiqueta = numeroDaEtiqueta; + this.destinatarioDoObjeto = destinatarioDoObjeto; + this.codigoServicosAdicionais = codigoServicosAdicionais; + this.valorAdicionalDoSeguro = valorAdicionalDoSeguro; + } + + public DimensoesDoObjetoPlp getDimensoesDoObjeto() { + return dimensoesDoObjeto; + } + + public PesoDoObjetoPlp getPesoDoObjeto() { + return pesoDoObjeto; + } + + public String getCodigoDeServico() { + return codigoDeServico; + } + + public String getNumeroDaEtiqueta() { + return numeroDaEtiqueta; + } + + public String getNumeroDaEtiquetaSemDigitoVerificador() { + return numeroDaEtiqueta.substring(0, 10) + numeroDaEtiqueta.substring(11); + } + + public DestinatarioDoObjetoPlp getDestinatarioDoObjeto() { + return destinatarioDoObjeto; + } + + public Set getCodigoServicosAdicionais() { + return codigoServicosAdicionais; + } + + public Optional getValorDeclaradoParaEncomenda() { + return Optional.ofNullable(valorAdicionalDoSeguro); + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/ObjetoPlpBuilder.java b/src/main/java/br/com/correios/api/postagem/plp/ObjetoPlpBuilder.java new file mode 100644 index 0000000..ed28d41 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/ObjetoPlpBuilder.java @@ -0,0 +1,113 @@ +package br.com.correios.api.postagem.plp; + +import static com.google.common.collect.Sets.newHashSet; + +import java.math.BigDecimal; +import java.util.Set; + +public class ObjetoPlpBuilder { + + private final static String CODIGO_DE_SERVICO_ADICIONAL_SEGURO = "019"; + private final static String CODIGO_DE_SERVICO_REGISTRO_NACIONAL = "025"; + + private DimensoesDoObjetoPlp dimensoesDoObjeto; + private PesoDoObjetoPlp pesoDoObjeto; + private String codigoDeServico; + private String numeroDaEtiqueta; + private DestinatarioDoObjetoPlp destinatarioDoObjeto; + private Set codigoServicosAdicionais = newHashSet(CODIGO_DE_SERVICO_REGISTRO_NACIONAL); + private BigDecimal valorAdicionalDoSeguro; + + public ObjetoPlpComDimensoesDoObjetoBuilder comDimensoes(DimensoesDoObjetoPlp dimensoesDoObjeto) { + this.dimensoesDoObjeto = dimensoesDoObjeto; + return new ObjetoPlpComDimensoesDoObjetoBuilder(this); + } + + public class ObjetoPlpComDimensoesDoObjetoBuilder { + + private ObjetoPlpBuilder builder; + + private ObjetoPlpComDimensoesDoObjetoBuilder(ObjetoPlpBuilder builder) { + this.builder = builder; + } + + public ObjetoPlpComPesoDoObjetoPlpBuilder comPeso(PesoDoObjetoPlp pesoDoObjeto) { + builder.pesoDoObjeto = pesoDoObjeto; + return new ObjetoPlpComPesoDoObjetoPlpBuilder(builder); + } + + } + + public class ObjetoPlpComPesoDoObjetoPlpBuilder { + + private ObjetoPlpBuilder builder; + + private ObjetoPlpComPesoDoObjetoPlpBuilder(ObjetoPlpBuilder builder) { + this.builder = builder; + } + + public ObjetoPlpComCodigoDeServicoBuilder usandoCodigoDeServico(String codigoDeServico) { + builder.codigoDeServico = codigoDeServico; + return new ObjetoPlpComCodigoDeServicoBuilder(builder); + } + + } + + public class ObjetoPlpComCodigoDeServicoBuilder { + + private ObjetoPlpBuilder builder; + + private ObjetoPlpComCodigoDeServicoBuilder(ObjetoPlpBuilder builder) { + this.builder = builder; + } + + public ObjetoPlpComNumeroDaEtiquetaBuilder comNumeroDaEtiqueta(String numeroDaEtiqueta) { + builder.numeroDaEtiqueta = numeroDaEtiqueta; + return new ObjetoPlpComNumeroDaEtiquetaBuilder(builder); + } + + } + + public class ObjetoPlpComNumeroDaEtiquetaBuilder { + + private ObjetoPlpBuilder builder; + + private ObjetoPlpComNumeroDaEtiquetaBuilder(ObjetoPlpBuilder builder) { + this.builder = builder; + } + + public ObjetoPlpComDestinatarioBuilder paraDestinatario(DestinatarioDoObjetoPlp destinatarioDoObjetoPlp) { + builder.destinatarioDoObjeto = destinatarioDoObjetoPlp; + return new ObjetoPlpComDestinatarioBuilder(builder); + } + + } + + public class ObjetoPlpComDestinatarioBuilder { + + private ObjetoPlpBuilder builder; + + private ObjetoPlpComDestinatarioBuilder(ObjetoPlpBuilder builder) { + this.builder = builder; + } + + public ObjetoPlpComDestinatarioBuilder adicionandoServicoAdicionalComCodigo(String codigoServicoAdicional) { + builder.codigoServicosAdicionais.add(codigoServicoAdicional); + return new ObjetoPlpComDestinatarioBuilder(builder); + } + + public ObjetoPlpComDestinatarioBuilder comValorAdicionalDoSeguro(BigDecimal valorAdicionalDoSeguro) { + builder.codigoServicosAdicionais.add(CODIGO_DE_SERVICO_ADICIONAL_SEGURO); + builder.valorAdicionalDoSeguro = valorAdicionalDoSeguro; + return new ObjetoPlpComDestinatarioBuilder(builder); + } + + public ObjetoPlp build() { + return new ObjetoPlp(builder.dimensoesDoObjeto, builder.pesoDoObjeto, builder.codigoDeServico, + builder.numeroDaEtiqueta, builder.destinatarioDoObjeto, builder.codigoServicosAdicionais, + builder.valorAdicionalDoSeguro); + } + + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/PesoDoObjetoPlp.java b/src/main/java/br/com/correios/api/postagem/plp/PesoDoObjetoPlp.java new file mode 100644 index 0000000..94bc7d9 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/PesoDoObjetoPlp.java @@ -0,0 +1,35 @@ +package br.com.correios.api.postagem.plp; + +import java.math.BigDecimal; + +import com.google.common.base.Preconditions; + +public class PesoDoObjetoPlp { + + private static final BigDecimal MIL = BigDecimal.valueOf(1000); + private BigDecimal pesoEmGramas; + + // Construtor estático para forçar a construção pelo factory method + private PesoDoObjetoPlp(BigDecimal pesoEmGramas) { + this.pesoEmGramas = pesoEmGramas; + } + + public static PesoDoObjetoPlp emGramas(BigDecimal pesoEmGramas) { + Preconditions.checkArgument(pesoEmGramas != null, "Peso deve ter um valor valido"); + return new PesoDoObjetoPlp(pesoEmGramas); + } + + public static PesoDoObjetoPlp emKilos(BigDecimal pesoEmKilos) { + Preconditions.checkArgument(pesoEmKilos != null, "Peso deve ter um valor valido"); + return new PesoDoObjetoPlp(pesoEmKilos.multiply(MIL)); + } + + public BigDecimal emGramas() { + return pesoEmGramas; + } + + public BigDecimal emKilos() { + return pesoEmGramas.divide(MIL); + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/Plp.java b/src/main/java/br/com/correios/api/postagem/plp/Plp.java new file mode 100644 index 0000000..bc52693 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/Plp.java @@ -0,0 +1,23 @@ +package br.com.correios.api.postagem.plp; + +import org.apache.commons.lang3.builder.ToStringBuilder; +import org.apache.commons.lang3.builder.ToStringStyle; + +public class Plp { + + private final Long plpId; + + public Plp(Long plpId) { + this.plpId = plpId; + } + + public Long getPlpId() { + return plpId; + } + + @Override + public String toString() { + return ToStringBuilder.reflectionToString(this, ToStringStyle.NO_CLASS_NAME_STYLE); + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/PlpNaoFechadaException.java b/src/main/java/br/com/correios/api/postagem/plp/PlpNaoFechadaException.java new file mode 100644 index 0000000..2110eb1 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/PlpNaoFechadaException.java @@ -0,0 +1,10 @@ +package br.com.correios.api.postagem.plp; + +public class PlpNaoFechadaException extends RuntimeException { + + private static final long serialVersionUID = 1L; + + public PlpNaoFechadaException(Exception e) { + super("Erro ao tentar fechar a PLP", e); + } +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/RemetentePlp.java b/src/main/java/br/com/correios/api/postagem/plp/RemetentePlp.java new file mode 100644 index 0000000..6a94821 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/RemetentePlp.java @@ -0,0 +1,45 @@ +package br.com.correios.api.postagem.plp; + +public class RemetentePlp { + + private final String nome; + private final String email; + private final String numeroContrato; + private final String numeroDeDiretoria; + private final String codigoAdministrativo; + private final Endereco endereco; + + RemetentePlp(String nome, String email, String numeroContrato, String numeroDeDiretoria, String codigoAdministrativo, Endereco endereco) { + this.nome = nome; + this.email = email; + this.numeroContrato = numeroContrato; + this.numeroDeDiretoria = numeroDeDiretoria; + this.codigoAdministrativo = codigoAdministrativo; + this.endereco = endereco; + } + + public String getNome() { + return nome; + } + + public String getEmail() { + return email; + } + + public String getNumeroContrato() { + return numeroContrato; + } + + public String getNumeroDeDiretoria() { + return numeroDeDiretoria; + } + + public String getCodigoAdministrativo() { + return codigoAdministrativo; + } + + public Endereco getEndereco() { + return endereco; + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/plp/RemetentePlpBuilder.java b/src/main/java/br/com/correios/api/postagem/plp/RemetentePlpBuilder.java new file mode 100644 index 0000000..ce7eea7 --- /dev/null +++ b/src/main/java/br/com/correios/api/postagem/plp/RemetentePlpBuilder.java @@ -0,0 +1,111 @@ +package br.com.correios.api.postagem.plp; + +public class RemetentePlpBuilder { + + private String nome; + private String email; + private String numeroContrato; + private String numeroDeDiretoria; + private String codigoAdministrativo; + private Endereco endereco; + + public RemetentePlpComNomeBuilder comNome(String nomeRemetente) { + this.nome = nomeRemetente; + return new RemetentePlpComNomeBuilder(this); + } + + public class RemetentePlpComNomeBuilder { + + private RemetentePlpBuilder builder; + + private RemetentePlpComNomeBuilder(RemetentePlpBuilder builder) { + this.builder = builder; + } + + public RemetentePlpComEmailBuilder comEmail(String emailRemetente) { + this.builder.email = emailRemetente; + return new RemetentePlpComEmailBuilder(builder); + } + + } + + public class RemetentePlpComEmailBuilder { + + private RemetentePlpBuilder builder; + + private RemetentePlpComEmailBuilder(RemetentePlpBuilder builder) { + this.builder = builder; + } + + public RemetentePlpComNumeroDeContratoBuilder comNumeroDeContrato(String numeroDeContrato) { + this.builder.numeroContrato = numeroDeContrato; + return new RemetentePlpComNumeroDeContratoBuilder(builder); + } + + } + + public class RemetentePlpComNumeroDeContratoBuilder { + + private RemetentePlpBuilder builder; + + private RemetentePlpComNumeroDeContratoBuilder(RemetentePlpBuilder builder) { + this.builder = builder; + } + + public RemetentePlpComNumeroDeDiretoriaBuilder comNumeroDeDiretoria(String numeroDeDiretoria) { + this.builder.numeroDeDiretoria = numeroDeDiretoria; + return new RemetentePlpComNumeroDeDiretoriaBuilder(builder); + } + + } + + public class RemetentePlpComNumeroDeDiretoriaBuilder { + + private RemetentePlpBuilder builder; + + private RemetentePlpComNumeroDeDiretoriaBuilder(RemetentePlpBuilder builder) { + this.builder = builder; + } + + public RemetentePlpComCodigoAdministrativoBuilder comCodigoAdministrativo(String codigoAdministrativo) { + this.builder.codigoAdministrativo = codigoAdministrativo; + return new RemetentePlpComCodigoAdministrativoBuilder(builder); + } + + } + + public class RemetentePlpComCodigoAdministrativoBuilder { + + private RemetentePlpBuilder builder; + + private RemetentePlpComCodigoAdministrativoBuilder(RemetentePlpBuilder builder) { + this.builder = builder; + } + + public RemetentePlpComEnderecoBuilder comEndereco(Endereco enderecoDoRemetente) { + this.builder.endereco = enderecoDoRemetente; + return new RemetentePlpComEnderecoBuilder(builder); + } + + } + + public class RemetentePlpComEnderecoBuilder { + + private RemetentePlpBuilder builder; + + private RemetentePlpComEnderecoBuilder(RemetentePlpBuilder builder) { + this.builder = builder; + } + + public RemetentePlp build() { + return new RemetentePlp(builder.nome, + builder.email, + builder.numeroContrato, + builder.numeroDeDiretoria, + builder.codigoAdministrativo, + builder.endereco); + } + + } + +} diff --git a/src/main/java/br/com/correios/api/postagem/xml/XmlPlpParser.java b/src/main/java/br/com/correios/api/postagem/xml/XmlPlpParser.java index 35e25ae..e54019f 100644 --- a/src/main/java/br/com/correios/api/postagem/xml/XmlPlpParser.java +++ b/src/main/java/br/com/correios/api/postagem/xml/XmlPlpParser.java @@ -1,14 +1,16 @@ package br.com.correios.api.postagem.xml; import java.io.StringReader; +import java.io.StringWriter; import javax.xml.bind.JAXBContext; import javax.xml.bind.JAXBException; +import javax.xml.bind.Marshaller; import javax.xml.bind.Unmarshaller; import com.google.common.base.Optional; -import br.com.correios.api.postagem.exception.PlpException; +import br.com.correios.api.postagem.exception.ParseIncorretoNoXmlPlpException; public class XmlPlpParser { @@ -18,14 +20,26 @@ public XmlPlpParser() { try { jaxbContext = JAXBContext.newInstance(Correioslog.class); } catch (JAXBException e) { - throw new PlpException("Ocorreu um erro ao criar a instancia do JaxB Context com a classe Correioslog", e); + throw new ParseIncorretoNoXmlPlpException("Ocorreu um erro ao criar a instancia do JaxB Context com a classe Correioslog", e); } } - public Optional convert(String xmlPlp) { - Correioslog correiosLog = parseFrom(xmlPlp); + public Optional getObjectFrom(String xmlPlp) { + return Optional.fromNullable(parseFrom(xmlPlp)); + } + + public String getXmlFrom(Correioslog correiosLog) { + try { + Marshaller marshaller = jaxbContext.createMarshaller(); + + StringWriter writer = new StringWriter(); + marshaller.marshal(correiosLog, writer); - return Optional.fromNullable(correiosLog); + return writer.toString(); + + } catch (JAXBException e) { + throw new ParseIncorretoNoXmlPlpException("Ocorreu um erro ao tentar fazer o marshal do XML da PLP: " + correiosLog, e); + } } private Correioslog parseFrom(String xml) { @@ -37,7 +51,7 @@ private Correioslog parseFrom(String xml) { return (Correioslog) unmarshaller.unmarshal(reader); } catch (JAXBException e) { - throw new PlpException("Ocorreu um erro ao tentar fazer o Unmarshal do XML da PLP: " + xml, e); + throw new ParseIncorretoNoXmlPlpException("Ocorreu um erro ao tentar fazer o unmarshal do XML da PLP: " + xml, e); } } diff --git a/src/test/java/br/com/correios/api/postagem/CorreiosPostagemApiTest.java b/src/test/java/br/com/correios/api/postagem/CorreiosPostagemApiTest.java index c40f0eb..c62edea 100644 --- a/src/test/java/br/com/correios/api/postagem/CorreiosPostagemApiTest.java +++ b/src/test/java/br/com/correios/api/postagem/CorreiosPostagemApiTest.java @@ -1,16 +1,32 @@ package br.com.correios.api.postagem; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertNotNull; + +import java.math.BigDecimal; import org.junit.Before; import org.junit.Test; import com.google.common.base.Optional; +import br.com.correios.Cep; import br.com.correios.api.postagem.cliente.ClienteEmpresa; import br.com.correios.api.postagem.cliente.ContratoEmpresa; +import br.com.correios.api.postagem.plp.DestinatarioDoObjetoPlp; +import br.com.correios.api.postagem.plp.DestinatarioDoObjetoPlpBuilder; +import br.com.correios.api.postagem.plp.DimensoesDoObjetoPlp; +import br.com.correios.api.postagem.plp.DimensoesDoObjetoPlpBuilder; import br.com.correios.api.postagem.plp.DocumentoPlp; +import br.com.correios.api.postagem.plp.Endereco; +import br.com.correios.api.postagem.plp.EnderecoBuilder; +import br.com.correios.api.postagem.plp.ObjetoPlp; +import br.com.correios.api.postagem.plp.ObjetoPlpBuilder; import br.com.correios.api.postagem.plp.ObjetoPostado; +import br.com.correios.api.postagem.plp.PesoDoObjetoPlp; +import br.com.correios.api.postagem.plp.Plp; +import br.com.correios.api.postagem.plp.RemetentePlp; +import br.com.correios.api.postagem.plp.RemetentePlpBuilder; import br.com.correios.credentials.CorreiosCredenciais; public class CorreiosPostagemApiTest { @@ -20,12 +36,12 @@ public class CorreiosPostagemApiTest { @Before public void startUp() { - credenciais = new CorreiosCredenciais("seu-usuario", "sua-senha"); + credenciais = new CorreiosCredenciais("usuario", "senha"); postagemApi = new CorreiosPostagemApi(credenciais); } @Test - public void deveriaBuscarOClienteDosCorreiosAPartirDasInformacoesDoCadastroDoCliente() throws Exception { + public void deveriaBuscarOClienteDosCorreiosAPartirDasInformacoesDoCadastroDoCliente() { String cnpj = "123456878"; ContratoEmpresa informacoesDeCadastro = new ContratoEmpresa(cnpj, "123456878", "123456878"); @@ -35,14 +51,14 @@ public void deveriaBuscarOClienteDosCorreiosAPartirDasInformacoesDoCadastroDoCli } @Test - public void deveriaBuscarOsDadosDaPlpViaPlpId() throws Exception { + public void deveriaBuscarOsDadosDaPlpViaPlpId() { Optional cliente = postagemApi.buscaDocumentoPlp(67488374L); assertThat(cliente.isPresent()).isTrue(); } @Test - public void deveriaRetornasOsDadosDeUmaEtiquetaEspecificaDadaUmaPlp() throws Exception { + public void deveriaRetornarOsDadosDeUmaEtiquetaEspecificaDadaUmaPlp() { Optional plp = postagemApi.buscaDocumentoPlp(48925409L); Optional objetoPostado = plp.get().getObjetoPostadoComEtiqueta("PJ938918208BR"); @@ -51,7 +67,7 @@ public void deveriaRetornasOsDadosDeUmaEtiquetaEspecificaDadaUmaPlp() throws Exc } @Test - public void deveriaRetornasOsDadosDeUmaEtiquetaEspecificaDadaUmaPlp2() throws Exception { + public void deveriaRetornarUmaPlpInexistenteDadoOsDadosDeUmaEtiquetaInvalida() { long plpIdInextistente = 250045L; Optional plp = postagemApi.buscaDocumentoPlp(plpIdInextistente); @@ -63,4 +79,53 @@ public void deveriaCancelarUmObjetoDePlp() { postagemApi.cancelaObjetoDaPlp(48925409L, "PJ938918208BR"); } + @Test + public void deveriaCriarUmaNovaPlp() { + Endereco endereco = new EnderecoBuilder() + .cep(new Cep("11045530")) + .logradouro("Rua Pindorama") + .numero(15) + .complemento("apto 31") + .bairro("Boqueirao") + .cidade("Santos") + .uf("SP") + .build(); + + RemetentePlp remetente = new RemetentePlpBuilder() + .comNome("gabriel") + .comEmail("gabriel.lima.ads@gmail.com") + .comNumeroDeContrato("123") + .comNumeroDeDiretoria("72") + .comCodigoAdministrativo("") + .comEndereco(endereco) + .build(); + + DestinatarioDoObjetoPlp destinatario = new DestinatarioDoObjetoPlpBuilder() + .comNome("Greg") + .comEndereco(endereco) + .build(); + + PesoDoObjetoPlp peso = PesoDoObjetoPlp.emGramas(BigDecimal.valueOf(1000)); + + DimensoesDoObjetoPlp dimensoes = new DimensoesDoObjetoPlpBuilder() + .doTipoEnvelope() + .build(); + + ObjetoPlp objetoPlp = new ObjetoPlpBuilder() + .comDimensoes(dimensoes) + .comPeso(peso) + .usandoCodigoDeServico("04162") + .comNumeroDaEtiqueta("etiquetaNaoFechadaAinda") + .paraDestinatario(destinatario) + .build(); + + Plp plp = postagemApi.novaPlp() + .comCartaoDePostagem("numeroDoCartaoDePostagem") + .deRemetente(remetente) + .adicionandoObjeto(objetoPlp) + .fechaPlp(); + + assertNotNull(plp.getPlpId()); + } + } diff --git a/src/test/java/br/com/correios/api/postagem/SoapCorreiosServicoPostagemAPITest.java b/src/test/java/br/com/correios/api/postagem/SoapCorreiosServicoPostagemAPITest.java index 6dca5e5..36744da 100644 --- a/src/test/java/br/com/correios/api/postagem/SoapCorreiosServicoPostagemAPITest.java +++ b/src/test/java/br/com/correios/api/postagem/SoapCorreiosServicoPostagemAPITest.java @@ -19,12 +19,14 @@ import com.google.common.base.Optional; -import br.com.correios.api.converter.Converter; import br.com.correios.api.exception.CorreiosServicoSoapException; import br.com.correios.api.postagem.cliente.ClienteEmpresa; +import br.com.correios.api.postagem.cliente.ClienteRetornadoDosCorreiosToClienteConverter; import br.com.correios.api.postagem.cliente.ContratoEmpresa; import br.com.correios.api.postagem.exception.CorreiosPostagemAutenticacaoException; +import br.com.correios.api.postagem.plp.CorreiosLogToDocumentoPlpConverter; import br.com.correios.api.postagem.plp.DocumentoPlp; +import br.com.correios.api.postagem.plp.NovaPlpToCorreiosLogConverter; import br.com.correios.api.postagem.webservice.CorreiosClienteApi; import br.com.correios.api.postagem.xml.Correioslog; import br.com.correios.api.postagem.xml.XmlPlpParser; @@ -42,11 +44,13 @@ public class SoapCorreiosServicoPostagemAPITest { @Mock(answer=Answers.RETURNS_DEEP_STUBS) private CorreiosClienteApi clienteAPI; @Mock - private Converter clienteEmpresaConverter; + private ClienteRetornadoDosCorreiosToClienteConverter clienteEmpresaConverter; @Mock private XmlPlpParser xmlPlpParser; @Mock - private Converter> documentoPlpConverter; + private CorreiosLogToDocumentoPlpConverter documentoPlpConverter; + @Mock + private NovaPlpToCorreiosLogConverter correiosPlpConverter; @Mock private ContratoEmpresa contratoEmpresa; @Mock @@ -62,17 +66,17 @@ public class SoapCorreiosServicoPostagemAPITest { @Before public void setup() throws Exception { - servicoPostagemAPI = new SoapCorreiosServicoPostagemAPI(credenciais, clienteAPI, clienteEmpresaConverter, xmlPlpParser, documentoPlpConverter); + servicoPostagemAPI = new SoapCorreiosServicoPostagemAPI(credenciais, clienteAPI, clienteEmpresaConverter, xmlPlpParser, documentoPlpConverter, correiosPlpConverter); when(clienteAPI.getCorreiosWebService().buscaCliente(anyString(), anyString(), anyString(), anyString())).thenReturn(clienteERP); when(clienteEmpresaConverter.convert(clienteERP)).thenReturn(clienteEmpresa); when(clienteAPI.getCorreiosWebService().solicitaXmlPlp(anyLong(), anyString(), anyString())).thenReturn("xml"); - when(xmlPlpParser.convert(anyString())).thenReturn(Optional.of(correiosLog)); - when(documentoPlpConverter.convert(correiosLog)).thenReturn(Optional.of(documentoPlp)); + when(xmlPlpParser.getObjectFrom(anyString())).thenReturn(Optional.of(correiosLog)); + when(documentoPlpConverter.convert(correiosLog)).thenReturn(documentoPlp); when(clienteAPI.getCorreiosWebService().cancelarObjeto(anyLong(), anyString(), anyString(), anyString())).thenReturn(true); } @Test - public void deveriaBuscarCliente() throws Exception { + public void deveriaBuscarCliente() { Optional cliente = servicoPostagemAPI.buscaCliente(contratoEmpresa); assertEquals(clienteEmpresa, cliente.get()); @@ -114,12 +118,12 @@ public void deveriaLancarExcecaoParaClienteCasoHajaUmProblemaParaBuscarClienteNo } @Test - public void deveriaBuscarXmlPlpEConverterParaDocumentoPlp() throws Exception { + public void deveriaBuscarXmlPlpEConverterParaDocumentoPlp() { Optional documentoPlpBuscado = servicoPostagemAPI.buscaDocumentoPlp(123L); assertEquals(documentoPlp, documentoPlpBuscado.get()); verify(documentoPlpConverter).convert(any()); - verify(xmlPlpParser).convert(any()); + verify(xmlPlpParser).getObjectFrom(any()); } @Test @@ -130,12 +134,12 @@ public void deveriaRetornarVazioQuandoServicoNaoDevolverXmlPlp() throws Exceptio assertFalse(documentoPlpBuscado.isPresent()); verify(documentoPlpConverter, never()).convert(any()); - verify(xmlPlpParser, never()).convert(any()); + verify(xmlPlpParser, never()).getObjectFrom(any()); } @Test - public void deveriaRetornarVazioQuandoNaoForPossivelConverterXml() throws Exception { - when(xmlPlpParser.convert(anyString())).thenReturn(Optional.absent()); + public void deveriaRetornarVazioQuandoNaoForPossivelConverterXml() { + when(xmlPlpParser.getObjectFrom(anyString())).thenReturn(Optional.absent()); Optional documentoPlpBuscado = servicoPostagemAPI.buscaDocumentoPlp(123L); @@ -143,8 +147,8 @@ public void deveriaRetornarVazioQuandoNaoForPossivelConverterXml() throws Except } @Test - public void deveriaRetornarVazioQuandoNaoForPossivelConverterCorreiosLogEmDocumentoPlp() throws Exception { - when(documentoPlpConverter.convert(correiosLog)).thenReturn(Optional.absent()); + public void deveriaRetornarVazioQuandoNaoNaoHouverPlpNoCorreiosLog() { + when(correiosLog.getPlp()).thenReturn(null); Optional documentoPlpBuscado = servicoPostagemAPI.buscaDocumentoPlp(123L); diff --git a/src/test/java/br/com/correios/api/postagem/destinatario/DestinatarioDosCorreiosToDestinatarioConverterTest.java b/src/test/java/br/com/correios/api/postagem/destinatario/DestinatarioDosCorreiosToDestinatarioConverterTest.java index fd8a4d9..b2cdb73 100644 --- a/src/test/java/br/com/correios/api/postagem/destinatario/DestinatarioDosCorreiosToDestinatarioConverterTest.java +++ b/src/test/java/br/com/correios/api/postagem/destinatario/DestinatarioDosCorreiosToDestinatarioConverterTest.java @@ -26,9 +26,9 @@ public void deveriaConverterODestinatarioDosCorreiosParaODestinatarioDoSdk() thr assertThat(destinatario.getDadosDeContato().getEmail()).isEqualTo("email@gmail.com"); assertThat(destinatario.getDadosDeContato().getTelefone()).isEqualTo("01211125589"); assertThat(destinatario.getDadosDeContato().getCelular()).isEqualTo("011995875580"); - assertThat(destinatario.getEnderedo().getLogradouro()).isEqualTo("Rua Gregorio"); - assertThat(destinatario.getEnderedo().getComplemento()).isEqualTo("Vila Sao Pedro"); - assertThat(destinatario.getEnderedo().getNumero()).isEqualTo("60"); + assertThat(destinatario.getEndereco().getLogradouro()).isEqualTo("Rua Gregorio"); + assertThat(destinatario.getEndereco().getComplemento()).isEqualTo("Vila Sao Pedro"); + assertThat(destinatario.getEndereco().getNumero()).isEqualTo("60"); } } diff --git a/src/test/java/br/com/correios/api/postagem/plp/ObjetoPlpTest.java b/src/test/java/br/com/correios/api/postagem/plp/ObjetoPlpTest.java new file mode 100644 index 0000000..410c793 --- /dev/null +++ b/src/test/java/br/com/correios/api/postagem/plp/ObjetoPlpTest.java @@ -0,0 +1,28 @@ +package br.com.correios.api.postagem.plp; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; + +@RunWith(MockitoJUnitRunner.class) +public class ObjetoPlpTest { + + @Mock + private DimensoesDoObjetoPlp dimensoesDoObjetoPlp; + @Mock + private PesoDoObjetoPlp pesoDoObjeto; + @Mock + private DestinatarioDoObjetoPlp destinatarioDoObjetoPlp; + + @Test + public void deveriaRetornarONumeroDaEtiquetaSemDigitoVerificador() { + ObjetoPlp objetoPlp = new ObjetoPlp(dimensoesDoObjetoPlp, pesoDoObjeto, "04162", "SI973006763BR", destinatarioDoObjetoPlp, null, null); + + assertEquals("SI973006763BR", objetoPlp.getNumeroDaEtiqueta()); + assertEquals("SI97300676BR", objetoPlp.getNumeroDaEtiquetaSemDigitoVerificador()); + } + +}