Beispiel #1
0
        public async Task <Retorno <RetornoWsTo> > CancelarAsync(WsMobLinkService.Cancelar objCancelar)
        {
            var retorno = new Retorno <RetornoWsTo>()
            {
                Status = ResultadoOperacao.Sucesso
            };
            RetornoWsTo retornoWsTo = new RetornoWsTo();

            var stopwatch = new Stopwatch();

            /* Cancela nota fiscal */
            try
            {
                retornoWsTo.Etapa = Models.Enum.EtapaRequisicao.PendenteEnvio;

                WsMobLinkService.WSnfseSoapClient cliente = new WsMobLinkService.WSnfseSoapClient(WsMobLinkService.WSnfseSoapClient.EndpointConfiguration.WSnfseSoap);

                stopwatch.Start();
                var resultCancelamento = await cliente.CancelarAsync(objCancelar);

                stopwatch.Stop();

                RetornoServicoTmpTo deserializedNfe = JsonConvert.DeserializeObject <RetornoServicoTmpTo>(resultCancelamento);

                /* Padronizando retorno */
                RetornoServicoTo retornoServicoTo = new RetornoServicoTo()
                {
                    Codigo_municipo = deserializedNfe.Codigo_municipo,
                    Ref             = deserializedNfe.Ref,
                    Cnpj_prestador  = deserializedNfe.Cnpj_prestador,
                    Status          = !string.IsNullOrEmpty(deserializedNfe.Status) ? deserializedNfe.Status : deserializedNfe.Codigo,
                    Mensagem        = deserializedNfe.Mensagem
                };

                retornoWsTo.Etapa            = Models.Enum.EtapaRequisicao.ComRetorno;
                retornoWsTo.TempoExecucao    = stopwatch.Elapsed.Seconds;
                retornoWsTo.RetornoServicoTo = retornoServicoTo;
                retorno.Objeto = retornoWsTo;
            }
            catch (Exception ex)
            {
                retorno.Mensagens.Add(new MensagemSistemaDto()
                {
                    Identificador = "EXCEPTION", Mensagem = string.Format("{0} - {1}", ex.Message, ex.InnerException != null ? ex.InnerException.Message : string.Empty)
                });
                retorno.Mensagens.Add(new MensagemSistemaDto()
                {
                    Identificador = "CDXNF0004", Mensagem = string.Format("Ocorreu um erro ao tentar cancelar a nota fiscal de referência {0}.", objCancelar.referencia)
                });
                retorno.Status         = ResultadoOperacao.Falha;
                retornoWsTo.Observacao = string.Format("{0} - {1}", ex.Message, ex.InnerException != null ? ex.InnerException.Message : string.Empty);
                return(retorno);
            }

            return(retorno);
        }
Beispiel #2
0
        public async Task <Retorno <RetornoServicoTo> > CancelarAsync(CancelamentoNfeTo cancelamentoNfeTo)
        {
            var notaFiscalRetornoTo = new RetornoServicoTo();
            var retorno             = new Retorno <RetornoServicoTo>()
            {
                Status = ResultadoOperacao.Sucesso
            };

            #region ValidaInicioProcesso

            retorno = await ValidaInicioProcesso(cancelamentoNfeTo.Autenticacao.Usuario, cancelamentoNfeTo.Autenticacao.Senha, cancelamentoNfeTo.CodigoMunicipio, cancelamentoNfeTo.CnpjPrestador);

            if (retorno.Status != ResultadoOperacao.Sucesso)
            {
                retorno.Status = ResultadoOperacao.Falha;
                return(retorno);
            }

            #endregion

            var usuario = await _usuarioRepositoy.ObterTodosAsync(cancelamentoNfeTo.Autenticacao.Usuario, cancelamentoNfeTo.Autenticacao.Senha);

            var cidade = await _cidadeNfeRepository.ObterTodosAsync(cancelamentoNfeTo.CodigoMunicipio, string.Empty);

            var parametros = await _parametroRepository.ObterTodosAsync(cancelamentoNfeTo.CodigoMunicipio, cancelamentoNfeTo.CnpjPrestador);

            /* Registra a requisição */
            var requisicao = new Requisicao
            {
                TipoOperacao  = TipoOperacao.Cancelamento,
                Referencia    = Convert.ToInt32(cancelamentoNfeTo.Referencia),
                Etapa         = EtapaRequisicao.RecebidoPedido,
                Status        = StatusOperacao.Indefinido,
                Cidade        = cidade,
                UsuarioId     = usuario.Id,
                Prestador     = parametros.Prestador,
                ServicoWsSoap = parametros.ServicoWsSoap
            };

            var requisicaoId = await _requisicaoRepository.InserirAsync(requisicao);

            ServicoWsSoap servicoWsSoap = new ServicoWsSoap();

            /* Obtem cliente da requisição de autorização*/
            Requisicao requisicaoCliente = null;
            requisicaoCliente = await _requisicaoRepository.ObterTodosPorStatusAsync(Convert.ToInt32(cancelamentoNfeTo.Referencia), TipoOperacao.Autorizacao, EtapaRequisicao.Processada, StatusOperacao.OperacaoEfetivada);

            if (requisicaoCliente == null)
            {
                requisicaoCliente = await _requisicaoRepository.ObterTodosPorStatusAsync(Convert.ToInt32(cancelamentoNfeTo.Referencia), TipoOperacao.Autorizacao, EtapaRequisicao.Processada, StatusOperacao.ProcessandoOperacao);
            }
            if (requisicaoCliente != null)
            {
                /* Cliente pelo qual foi realizada o pedido de autorização */
                servicoWsSoap = requisicaoCliente.ServicoWsSoap;
            }
            else
            {
                servicoWsSoap = parametros.ServicoWsSoap;
            }

            Retorno <RetornoWsTo> retornoServicoWs = null;

            try
            {
                /* Cancela nota fiscal */
                if (servicoWsSoap.Codigo == (int)WsSoapServices.MobLink)
                {
                    WsMobLinkService.Cancelar objCancelar    = cancelamentoNfeTo.ToWsCancelarService(WsSoapServices.MobLink);
                    MobLinkService            mobLinkService = new MobLinkService(_x509Certificate2);
                    retornoServicoWs = await mobLinkService.CancelarAsync(objCancelar);

                    if (retornoServicoWs.Status != ResultadoOperacao.Sucesso)
                    {
                        var requisicaoErro = await _requisicaoRepository.ObterPorIdAsync(requisicaoId);

                        requisicaoErro.Status = StatusOperacao.Erro;
                        requisicaoErro.Erro   = retornoServicoWs.Mensagens.Count > 0 ? retornoServicoWs.Mensagens[0].Mensagem : string.Empty;
                        requisicaoErro.Etapa  = retornoServicoWs.Objeto != null ? retornoServicoWs.Objeto.Etapa : EtapaRequisicao.PendenteEnvio;
                        _requisicaoRepository.Alterar(requisicaoErro);

                        retorno.Mensagens.AddRange(retornoServicoWs.Mensagens);
                        retorno.Status = retornoServicoWs.Status;
                        return(retorno);
                    }

                    var reqNovaEtapa = await _requisicaoRepository.ObterPorIdAsync(requisicaoId);

                    reqNovaEtapa.Etapa = retornoServicoWs.Objeto.Etapa;
                    _requisicaoRepository.Alterar(reqNovaEtapa);
                }
                else
                {
                    retorno.Mensagens.Add(new MensagemSistemaDto()
                    {
                        Identificador = "CDXNF0005", Mensagem = string.Format("Não há um serviço soap cadastrado para a cidade de {0} .", cidade.Descricao)
                    });
                    retorno.Status = ResultadoOperacao.Falha;
                    return(retorno);
                }

                var requisicaoAlteracao = await _requisicaoRepository.ObterPorIdAsync(requisicaoId);

                requisicaoAlteracao.Etapa         = EtapaRequisicao.Processada;
                requisicaoAlteracao.TempoExecucao = retornoServicoWs.Objeto.TempoExecucao;
                requisicaoAlteracao.Observacao    = retornoServicoWs.Objeto.Observacao;
                _requisicaoRepository.Alterar(requisicaoAlteracao);

                notaFiscalRetornoTo.Status   = retornoServicoWs.Objeto.RetornoServicoTo.Status;
                notaFiscalRetornoTo.Mensagem = retornoServicoWs.Objeto.RetornoServicoTo.Mensagem;

                retorno.Objeto = notaFiscalRetornoTo;
            }
            catch (Exception ex)
            {
                var mensagem     = string.Format("O Não foi possível cancelar a nota fiscal de referência {0}.", cancelamentoNfeTo.Referencia);
                var requisicaoex = await _requisicaoRepository.ObterPorIdAsync(requisicaoId);

                requisicaoex.Erro       = string.Format("{0} - {1}", ex.Message, ex.InnerException != null ? ex.InnerException.Message : string.Empty);
                requisicaoex.Status     = StatusOperacao.Erro;
                requisicaoex.Observacao = mensagem;
                _requisicaoRepository.Alterar(requisicaoex);

                retorno.Mensagens.Add(new MensagemSistemaDto()
                {
                    Titulo = "Cancelamento de Nota", Identificador = "CDXNF0001", Mensagem = mensagem
                });
                retorno.Status = ResultadoOperacao.Falha;
            }

            return(retorno);
        }
Beispiel #3
0
 public System.Threading.Tasks.Task <string> CancelarAsync(WsMobLinkService.Cancelar referencia)
 {
     return(base.Channel.CancelarAsync(referencia));
 }