コード例 #1
0
 public CondicaoPagamento GetCondicaoPagamentosByID(int?idCondicaoPagamento)
 {
     try
     {
         AbrirConexao();
         var _where = string.Empty;
         _where   = " WHERE idcondicaopagamento = " + idCondicaoPagamento;
         SqlQuery = new SqlCommand("SELECT * FROM tbCondicaoPagamentos" + _where, con);
         reader   = SqlQuery.ExecuteReader();
         var objCondPagamento = new CondicaoPagamento();
         while (reader.Read())
         {
             objCondPagamento = new CondicaoPagamento()
             {
                 idCondicaoPagamento = Convert.ToInt32(reader["idcondicaopagamento"]),
                 nmCondicaoPagamento = Convert.ToString(reader["nmcondicaopagamento"]),
                 txJuros             = Convert.ToDecimal(reader["txjuros"]),
                 multa            = Convert.ToDecimal(reader["multa"]),
                 desconto         = Convert.ToDecimal(reader["desconto"]),
                 dtCadastro       = Convert.ToDateTime(reader["dtcadastro"]),
                 dtAtualizacao    = Convert.ToDateTime(reader["dtAtualizacao"]),
                 CondicaoParcelas = this.GetParcelasByID(idCondicaoPagamento),
             };
         }
         return(objCondPagamento);
     }
     catch (Exception error)
     {
         throw new Exception(error.Message);
     }
     finally
     {
         FecharConexao();
     }
 }
コード例 #2
0
        public override void Gravar()
        {
            #region Condição de pagamento
            ICondicaoPagamento condicaoPagamento = new CondicaoPagamento();
            condicaoPagamento.Descricao = "Condição de pagamento";
            condicaoPagamento.PrazoMedio = 1;
            condicaoPagamento.FormaCalculoVencimento = Enuns.Cadastro.Financeiro.FormaCalculoVencimento.Mensal;
            condicaoPagamento.VencimentoFeriado = Enuns.Cadastro.Financeiro.VencimentoFeriado.Manter;
            condicaoPagamento.MesmoDiaMes = true;
            string guidCondPag = condicaoPagamento.Save();
            #endregion

            #region Período de vencimento
            IPeriodo periodo = new OpenPOS.Data.Cadastro.Periodo.Periodo();
            periodo.Descricao = "Período de vencimento semanal";
            periodo.Tipo = TipoVencimento.ForaSemana;
            string guidPeriodo = periodo.Save();
            #endregion

            ICondicaoPagamentoParcelado condPagParc = new CondicaoPagamentoParcelado();
            condPagParc.CondicaoPagamento = new CondicaoPagamento(guidCondPag);
            condPagParc.ApartirDataEmissao = 1;
            condPagParc.ApartirDataVencimentoAnterior = 1;
            condPagParc.Percentual = 1;
            condPagParc.PeriodoVencimento = new OpenPOS.Data.Cadastro.Periodo.Periodo(guidPeriodo);
            GUID = condPagParc.Save();
        }
コード例 #3
0
        public bool Edit(CondicaoPagamento condicaoPagamento)
        {
            try
            {
                AbrirConexao();
                SqlQuery = new SqlCommand("UPDATE tbCondicaoPagamentos SET nmcondicaopagamento=@nmcondicaopagamento, txjuros=@txjuros, multa=@multa, desconto=@desconto, " +
                                          "dtatualizacao=@dtAtualizacao WHERE idcondicaopagamento=@idcondicaopagamento", con);

                SqlQuery.Parameters.AddWithValue("@idcondicaopagamento", condicaoPagamento.idCondicaoPagamento);
                SqlQuery.Parameters.AddWithValue("@nmcondicaopagamento", condicaoPagamento.nmCondicaoPagamento);
                SqlQuery.Parameters.AddWithValue("@txjuros", condicaoPagamento.txJuros);
                SqlQuery.Parameters.AddWithValue("@multa", condicaoPagamento.multa);
                SqlQuery.Parameters.AddWithValue("@desconto", condicaoPagamento.desconto);
                SqlQuery.Parameters.AddWithValue("@dtatualizacao", condicaoPagamento.dtAtualizacao);

                // Validação para saber se a linha foi alterada no BD
                int i = SqlQuery.ExecuteNonQuery();
                if (i >= 1)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            catch (Exception error)
            {
                throw new Exception(error.Message);
            }
            finally
            {
                FecharConexao();
            }
        }
コード例 #4
0
        public bool Create(CondicaoPagamento condicaoPagamento)
        {
            int i = 0;

            try
            {
                AbrirConexao();
                SqlTransaction sqlTrans = con.BeginTransaction();
                SqlCommand     command  = con.CreateCommand();
                command.Transaction = sqlTrans;

                command.CommandText = "INSERT INTO tbCondicaoPagamentos (nmcondicaopagamento, txjuros, multa, desconto, dtcadastro, dtatualizacao) VALUES " +
                                      "(@nmcondicaopagamento, @txjuros, @multa, @desconto, @dtcadastro, @dtatualizacao);SELECT CAST(SCOPE_IDENTITY() AS int)";

                command.Parameters.AddWithValue("@nmcondicaopagamento", condicaoPagamento.nmCondicaoPagamento);
                command.Parameters.AddWithValue("@txjuros", condicaoPagamento.txJuros);
                command.Parameters.AddWithValue("@multa", condicaoPagamento.multa);
                command.Parameters.AddWithValue("@desconto", condicaoPagamento.desconto);
                command.Parameters.AddWithValue("@dtcadastro", condicaoPagamento.dtCadastro);
                command.Parameters.AddWithValue("@dtatualizacao", condicaoPagamento.dtAtualizacao);
                Int32 idRetorno = Convert.ToInt32(command.ExecuteScalar());

                command.CommandText = "INSERT INTO tbCondicaoPagamentoParcelas (idFormaPagamento, idCondicaoPagamento, nrParcela, nrPrazo, nrPorcentagem) VALUES " +
                                      "(@idFormaPagamento, @idCondicaoPagamento, @nrParcela, @nrPrazo, @nrPorcentagem);";

                foreach (var item in condicaoPagamento.CondicaoParcelas)
                {
                    command.Parameters.Clear();
                    command.Parameters.AddWithValue("@idFormaPagamento", item.idFormaPagamento);
                    command.Parameters.AddWithValue("@idCondicaoPagamento", idRetorno);
                    command.Parameters.AddWithValue("@nrParcela", item.nrParcela);
                    command.Parameters.AddWithValue("@nrPrazo", item.nrPrazo);
                    command.Parameters.AddWithValue("@nrPorcentagem", item.nrPorcentagem);
                    i = command.ExecuteNonQuery();
                }

                sqlTrans.Commit();

                // Tratamento para saber se alguma linha foi alterada no Banco de Dados

                if (i >= 1)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            catch (Exception error)
            {
                throw new Exception(error.Message);
            }
            finally
            {
                FecharConexao();
            }
        }
コード例 #5
0
        public CondicaoPagamento mapToModel(CondicaoPagamento condicao)
        {
            condicao.Descricao = Descricao ?? condicao.Descricao;
            condicao.Tipo      = Tipo >= 1 || Tipo <= 3 ? condicao.Tipo : Tipo;
            condicao.CreatedAt = condicao.CreatedAt;
            condicao.UpdatedAt = DateTime.Now;

            return(condicao);
        }
コード例 #6
0
        public CondicaoPagamento Adicionar(CondicaoPagamento condicaoPagamento)
        {
            if (!condicaoPagamento.EhValido(_condicaoPagamentoRepositorio))
            {
                return(condicaoPagamento);
            }

            return(_condicaoPagamentoRepositorio.Adicionar(condicaoPagamento));
        }
コード例 #7
0
        public CondicaoPagamento BuscaCondicaoPagamentoPorCodigo(int itbc_condicao_pagamento)
        {
            CondicaoPagamento condicaoPagamento = RepositoryService.CondicaoPagamento.ObterPor(itbc_condicao_pagamento);

            if (condicaoPagamento != null)
            {
                return(condicaoPagamento);
            }
            return(null);
        }
コード例 #8
0
        public CondicaoPagamentoClass mapFromModel(CondicaoPagamento condicao)
        {
            Id        = condicao.Id;
            Descricao = condicao.Descricao;
            Tipo      = condicao.Tipo;
            CreatedAt = condicao.CreatedAt;
            UpdatedAt = condicao.UpdatedAt;

            return(this);
        }
コード例 #9
0
        public CondicaoPagamento BuscaCondicaoPagamento(Guid itbc_condicao_pagamentoid)
        {
            CondicaoPagamento condicaoPagamento = RepositoryService.CondicaoPagamento.ObterPor(itbc_condicao_pagamentoid);

            if (condicaoPagamento != null)
            {
                return(condicaoPagamento);
            }
            return(null);
        }
コード例 #10
0
 public override void Gravar()
 {
     ICondicaoPagamento condicaoPagamento = new CondicaoPagamento();
     condicaoPagamento.Descricao = "Condição de pagamento";
     condicaoPagamento.PrazoMedio = 1;
     condicaoPagamento.FormaCalculoVencimento = Enuns.Cadastro.Financeiro.FormaCalculoVencimento.Mensal;
     condicaoPagamento.VencimentoFeriado = Enuns.Cadastro.Financeiro.VencimentoFeriado.Manter;
     condicaoPagamento.MesmoDiaMes = true;
     GUID = condicaoPagamento.Save();
 }
コード例 #11
0
        public CondicaoPagamento mapToModel(bool create)
        {
            CondicaoPagamento condicao = new CondicaoPagamento();

            condicao.Descricao = Descricao;
            condicao.Tipo      = Tipo;
            condicao.CreatedAt = create ? DateTime.Now : condicao.CreatedAt;
            condicao.UpdatedAt = DateTime.Now;

            return(condicao);
        }
コード例 #12
0
        public void EditarErro()
        {
            Gravar();

            ICondicaoPagamento condicaoPagamento = new CondicaoPagamento(GUID);
            condicaoPagamento.FormaCalculoVencimento = Enuns.Cadastro.Financeiro.FormaCalculoVencimento.Quinzenal;
            condicaoPagamento.MesmoDiaMes = true;
            condicaoPagamento.Save();

            condicaoPagamento.Delete();
        }
コード例 #13
0
        public CondicaoPagamento AtualizarCondicaoPagamento(CondicaoPagamento condicaoPagamento)
        {
            condicaoPagamento.Validar();
            AssertionConcern.AssertArgumentNotEquals(0, condicaoPagamento.CondicaoPagamentoCodigo,
                                                     string.Format(Erros.NotZeroParameter, "CondicaoPagamentoCodigo"));
            var condicaoPagamentoAtual =
                _condicaoPagamentoRepository.ObterPorCodigo(condicaoPagamento.CondicaoPagamentoCodigo);

            condicaoPagamentoAtual.Ativo              = condicaoPagamento.Ativo;
            condicaoPagamentoAtual.Descricao          = condicaoPagamento.Descricao;
            condicaoPagamentoAtual.QuantidadeParcelas = condicaoPagamento.QuantidadeParcelas;
            return(_condicaoPagamentoRepository.Atualizar(condicaoPagamentoAtual));
        }
コード例 #14
0
        public async Task <bool> Atualizar(CondicaoPagamento condicaoPagamento)
        {
            if (!ExecutarValidacao(new CondicaoPagamentoValidation(), condicaoPagamento))
            {
                return(false);
            }

            if (_condicaoPagamentoRepository.JaExiste(condicaoPagamento.Id, condicaoPagamento.Descricao))
            {
                Notificar("Já existe uma condição de pagamento com esta descrição informada.");
                return(false);
            }

            await _condicaoPagamentoRepository.Atualizar(condicaoPagamento);

            return(true);
        }
コード例 #15
0
        private ParcelaPagamento CalculaParcela(CondicaoPagamento condicaoPagamento, CondicaoPagamentoParcela condicaoPagamentoParcela, DateTime dataBase, decimal valorTotal, int numero)
        {
            var valorParcela    = Decimal.Round(valorTotal * (condicaoPagamentoParcela.Percentual / 100), 2);
            var descontoParcela = Decimal.Round(valorParcela * (condicaoPagamento.Desconto / 100), 2);

            var parcela = new ParcelaPagamento()
            {
                Valor            = valorParcela,
                Desconto         = descontoParcela,
                ValorTotal       = valorParcela - descontoParcela,
                DataVencimento   = dataBase.AddDays(condicaoPagamentoParcela.NumeroDias),
                FormaPagamento   = condicaoPagamentoParcela.FormaPagamento,
                FormaPagamentoId = condicaoPagamentoParcela.FormaPagamentoId,
                Parcela          = numero
            };

            return(parcela);
        }
        public IHttpActionResult Delete(long id)
        {
            try
            {
                CondicaoPagamento condicaoPagamento = db.CondicaoPagamentos.Find(id);
                if (condicaoPagamento == null)
                {
                    return(NotFound());
                }

                db.CondicaoPagamentos.Remove(condicaoPagamento);
                db.SaveChanges();
            }
            catch (Exception e)
            {
                return(Util.ResponseError(Request, e));
            }

            return(Util.ResponseSuccess(Request, "Condição de Pagamento removida com sucesso"));
        }
コード例 #17
0
        public List <ParcelaPagamento> CalculaParcela(CondicaoPagamento condicaoPagamento, DateTime dataBase, decimal valorDataBase)
        {
            if (condicaoPagamento.Parcela == null || condicaoPagamento.Parcela.Count == 0)
            {
                throw new ArgumentNullException(nameof(condicaoPagamento.Parcela), "Informe as parcelas");
            }

            var parcelas   = new List <ParcelaPagamento>(condicaoPagamento.Parcela.Count);
            var valorTotal = valorDataBase;

            for (int i = 0; i < condicaoPagamento.Parcela.Count - 1; i++)
            {
                var condicaoPagamentoParcela = condicaoPagamento.Parcela[i];
                var parcela = this.CalculaParcela(condicaoPagamento, condicaoPagamentoParcela, dataBase, valorTotal, i + 1);
                parcelas.Add(parcela);
            }

            var ultimaParcela = condicaoPagamento.Parcela[condicaoPagamento.Parcela.Count - 1];

            parcelas.Add(this.CalculaUltimaParcela(condicaoPagamento, ultimaParcela, dataBase, valorTotal, parcelas, condicaoPagamento.Parcela.Count));

            return(parcelas);
        }
コード例 #18
0
        public IActionResult Salvar(CondicaoPagamento condicao, string hfListaParcelas)
        {
            CondicaoPagamentoBLL BLL = new CondicaoPagamentoBLL();
            string mensagemErro;

            List <ParcelamentoCondicao.ParcelaTela> parcelas = new List <ParcelamentoCondicao.ParcelaTela>();

            if (!String.IsNullOrEmpty(hfListaParcelas))
            {
                parcelas = JsonConvert.DeserializeObject <List <ParcelamentoCondicao.ParcelaTela> >(hfListaParcelas);
            }

            if (condicao.Codigo == null)
            {
                if (BLL.insertCondicaoPagamento(condicao, parcelas, out mensagemErro))
                {
                    TempData["mensagemSucesso"] = "Condição de pagamento cadastrada com sucesso!";
                }
                else
                {
                    TempData["mensagemErro"] = mensagemErro;
                }
            }
            else
            {
                if (BLL.updateCondicaoPagamento(condicao, parcelas, out mensagemErro))
                {
                    TempData["mensagemSucesso"] = "Condição de pagamento atualizada com sucesso!";
                }
                else
                {
                    TempData["mensagemErro"] = mensagemErro;
                }
            }

            return(RedirectToAction("List"));
        }
コード例 #19
0
        public List <CondicaoPagamento> GetCondicaoPagamentos()
        {
            try
            {
                AbrirConexao();
                SqlQuery = new SqlCommand("SELECT * FROM tbCondicaoPagamentos", con);
                reader   = SqlQuery.ExecuteReader();

                var lista = new List <CondicaoPagamento>();

                while (reader.Read())
                {
                    var condicaoPagamento = new CondicaoPagamento
                    {
                        idCondicaoPagamento = Convert.ToInt32(reader["idcondicaopagamento"]),
                        nmCondicaoPagamento = Convert.ToString(reader["nmcondicaopagamento"]),
                        txJuros             = Convert.ToDecimal(reader["txjuros"]),
                        multa         = Convert.ToDecimal(reader["multa"]),
                        desconto      = Convert.ToDecimal(reader["desconto"]),
                        dtCadastro    = Convert.ToDateTime(reader["dtcadastro"]),
                        dtAtualizacao = Convert.ToDateTime(reader["dtAtualizacao"]),
                    };

                    lista.Add(condicaoPagamento);
                }

                return(lista);
            }
            catch (Exception error)
            {
                throw new Exception(error.Message);
            }
            finally
            {
                FecharConexao();
            }
        }
コード例 #20
0
        public IActionResult Edit(int?codigoCondicao)
        {
            CondicaoPagamentoBLL    BLL        = new CondicaoPagamentoBLL();
            ParcelamentoCondicaoBLL parcelaBLL = new ParcelamentoCondicaoBLL();
            string mensagemErro;

            if (codigoCondicao != null && codigoCondicao != 0)
            {
                CondicaoPagamento condicaoCorrente = BLL.getCondicoes((int)codigoCondicao, "", out mensagemErro).FirstOrDefault();

                if (condicaoCorrente != null)
                {
                    List <ParcelamentoCondicao.ParcelaTela> parcelas = parcelaBLL.getParcelasTela((int)condicaoCorrente.Codigo, out mensagemErro);

                    ViewBag.listaParcelas = JsonConvert.SerializeObject(parcelas);
                }

                return(View(condicaoCorrente));
            }
            else
            {
                return(View());
            }
        }
        public IHttpActionResult Update(long id, CondicaoPagamentoClass condicaoPagamento)
        {
            CondicaoPagamento condicao = db.CondicaoPagamentos.Find(id);

            try
            {
                ValidateTipo(condicaoPagamento, false);

                if (condicao != null)
                {
                    condicaoPagamento.mapToModel(condicao);

                    db.SaveChanges();
                }
            }
            catch (Exception e)
            {
                return(Util.ResponseError(Request, e));
            }

            condicaoPagamento.mapFromModel(condicao);

            return(Util.ResponseSuccess(Request, condicaoPagamento, "Condição de Pagamento atualizada com sucesso!"));
        }
コード例 #22
0
 public CondicaoPagamento Criar(CondicaoPagamento condicaoPagamento)
 {
     _context.CondicoesPagamento.Add(condicaoPagamento);
     _context.SaveChanges();
     return(_context.Entry(condicaoPagamento).Entity);
 }
コード例 #23
0
 public override void Popular()
 {
     ICondicaoPagamento condicaoPagamento = new CondicaoPagamento(GUID);
     DumpElement(condicaoPagamento);
 }
コード例 #24
0
 public void Deletar(CondicaoPagamento condicaoPagamento)
 {
     _context.CondicoesPagamento.Remove(condicaoPagamento);
     _context.SaveChanges();
 }
コード例 #25
0
 public override void Excluir()
 {
     ICondicaoPagamento condicaoPagamento = new CondicaoPagamento(GUID);
     condicaoPagamento.Delete();
 }
コード例 #26
0
ファイル: MSG0094.cs プロジェクト: ertprs/crm_fonte
        public Fatura DefinirPropriedades(Intelbras.Message.Helper.MSG0094 xml)
        {
            Fatura crm = new Fatura(this.Organizacao, this.IsOffline);

            if (!String.IsNullOrEmpty(xml.NumeroNotaFiscal))
            {
                crm.NumeroNF = xml.NumeroNotaFiscal;
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "NumeroNotaFiscal não enviado.";
                return(crm);
            }

            crm.Serie     = xml.NumeroSerie;
            crm.ClienteId = new Lookup(new Guid(xml.CodigoClienteCRM), xml.TipoObjetoCliente);


            crm.ChaveIntegracao = xml.ChaveIntegracao; //NumeroPedido.ToString();

            if (xml.NumeroPedido != null)
            {
                Pedido pedido = new Servicos.PedidoService(this.Organizacao, this.IsOffline).BuscaPedidoEMS(xml.NumeroPedido.ToString());
                if (pedido != null)
                {
                    crm.PedidoCRM = new Lookup(pedido.ID.Value, "");

                    Fatura fatura = new Servicos.FaturaService(this.Organizacao, this.IsOffline).ObterFaturaPorPedidoEMS(xml.NumeroPedido.ToString());
                    if (fatura != null)
                    {
                        crm.ID = fatura.ID.Value;
                    }
                }
            }

            if (!String.IsNullOrEmpty(xml.NumeroPedidoCliente))
            {
                crm.PedidoCliente = xml.NumeroPedidoCliente;
            }
            else
            {
                crm.AddNullProperty("PedidoCliente");
            }

            if (!String.IsNullOrEmpty(xml.Descricao))
            {
                crm.Descricao = xml.Descricao;
            }
            else
            {
                crm.AddNullProperty("Descricao");
            }

            //Service Estabelecimento
            Estabelecimento ObjEstabelecimento = new Intelbras.CRM2013.Domain.Servicos.EstabelecimentoService(this.Organizacao, this.IsOffline).BuscaEstabelecimentoPorCodigo(xml.Estabelecimento.Value);

            if (ObjEstabelecimento != null)
            {
                crm.Estabelecimento = new Lookup((Guid)ObjEstabelecimento.ID, "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador do Estabelecimento não encontrado.";
                return(crm);
            }

            //Service Condição Pagamento
            CondicaoPagamento ObjCondicaoPagamento = null;

            if (xml.CondicaoPagamento.HasValue)
            {
                ObjCondicaoPagamento = new Intelbras.CRM2013.Domain.Servicos.CondicaoPagamentoService(this.Organizacao, this.IsOffline).BuscaCondicaoPagamentoPorCodigo(xml.CondicaoPagamento.Value);

                if (ObjCondicaoPagamento != null)
                {
                    crm.CondicaoPagamento = new Lookup((Guid)ObjCondicaoPagamento.ID, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador da Condição de Pagamento não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("CondicaoPagamento");
            }

            crm.NomeAbreviado = xml.NomeAbreviadoCliente;

            //Service Natureza Operação
            NaturezaOperacao ObjNaturezaOperacao = new Intelbras.CRM2013.Domain.Servicos.NaturezaOperacaoService(this.Organizacao, this.IsOffline).BuscaNaturezaOperacaoPorCodigo(xml.NaturezaOperacao);

            if (ObjNaturezaOperacao != null)
            {
                crm.NaturezaOperacao = new Lookup((Guid)ObjNaturezaOperacao.ID, "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador da Natureza de Operação não encontrado.";
                return(crm);
            }

            //Service Moeda
            Moeda ObjMoeda = new Intelbras.CRM2013.Domain.Servicos.MoedaService(this.Organizacao, this.IsOffline).BuscaMoedaPorCodigo(xml.Moeda);

            if (ObjMoeda != null)
            {
                crm.Moeda = new Lookup((Guid)ObjMoeda.ID, "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador da Moeda não encontrado.";
                return(crm);
            }

            //Service para resolver o status
            if (System.Enum.IsDefined(typeof(Enum.Fatura.Status), xml.SituacaoNota))
            {
                crm.Status = xml.SituacaoNota;
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador da Situação da nota não encontrado.";
                return(crm);
            }

            if (System.Enum.IsDefined(typeof(Enum.Fatura.RazaoStatus), xml.SituacaoEntrega))
            {
                crm.RazaoStatus = xml.SituacaoEntrega;
            }

            crm.DataEmissao = xml.DataEmissao;

            if (xml.DataSaida.HasValue)
            {
                crm.DataSaida = xml.DataSaida;
            }
            else
            {
                crm.AddNullProperty("DataSaida");
            }

            if (xml.DataEntrega.HasValue)
            {
                crm.DataEntrega = xml.DataEntrega;
            }
            else
            {
                crm.AddNullProperty("DataEntrega");
            }

            if (xml.DataConfirmacao != null)
            {
                crm.DataConfirmacao = xml.DataConfirmacao;
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "DataConfirmacao não enviada.";
                return(crm);
            }

            if (xml.DataCancelamento.HasValue)
            {
                crm.DataCancelamento = xml.DataCancelamento;
            }
            else
            {
                crm.AddNullProperty("DataCancelamento");
            }

            if (xml.DataConclusao.HasValue)
            {
                crm.DataConclusao = xml.DataConclusao;
            }
            else
            {
                crm.AddNullProperty("DataConclusao");
            }

            crm.ValorFrete = xml.ValorFrete;

            crm.PesoLiquido = xml.PesoLiquido;

            crm.PesoBruto = xml.PesoBruto;

            if (!String.IsNullOrEmpty(xml.Observacao))
            {
                crm.Observacao = xml.Observacao;
            }
            else
            {
                crm.AddNullProperty("Observacao");
            }

            crm.Volume = xml.Volume.ToString();

            crm.BaseICMS            = xml.ValorBaseICMS;
            crm.ValorICMS           = xml.ValorICMS;
            crm.ValorIPI            = xml.ValorIPI;
            crm.BaseSubstTributaria = xml.ValorBaseSubstituicaoTributaria;
            crm.ValorSubstituicao   = xml.ValorSubstituicaoTributaria;
            crm.ClienteRetira       = xml.RetiraNoLocal;

            if (xml.MetodoEntrega.HasValue)
            {
                crm.MetodoEntrega = xml.MetodoEntrega;
            }
            else
            {
                crm.AddNullProperty("MetodoEntrega");
            }

            //Service Transportadora
            Transportadora ObjTransportadora = new Intelbras.CRM2013.Domain.Servicos.TransportadoraService(this.Organizacao, this.IsOffline).ObterPorCodigoTransportadora(xml.Transportadora.Value);

            if (ObjTransportadora != null)
            {
                crm.Transportadora = new Lookup((Guid)ObjTransportadora.ID, "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador da Transportadora não encontrado.";
                return(crm);
            }

            crm.Frete = xml.Frete;

            //crm.CondicoesFrete = xml.tipo;

            if (!String.IsNullOrEmpty(xml.TelefoneCobranca))
            {
                crm.TelefoneCobranca = xml.TelefoneCobranca;
            }
            else
            {
                crm.AddNullProperty("TelefoneCobranca");
            }

            if (!String.IsNullOrEmpty(xml.FaxCobranca))
            {
                crm.FaxCobranca = xml.FaxCobranca;
            }
            else
            {
                crm.AddNullProperty("FaxCobranca");
            }

            //Removido essa validação para que as NF de clientes estrangeiros sejam integrados no CRM
            //if (!String.IsNullOrEmpty(xml.CNPJ))
            //    crm.CpfCnpj = Intelbras.CRM2013.Domain.Servicos.Helper.FormatarCnpj(xml.CNPJ);
            //else if (!String.IsNullOrEmpty(xml.CPF))
            //    crm.CpfCnpj = Intelbras.CRM2013.Domain.Servicos.Helper.FormatarCpf(xml.CPF);
            //else
            //{
            //    resultadoPersistencia.Sucesso = false;
            //    resultadoPersistencia.Mensagem = "CNPJ/CPF não enviado.";
            //    return crm;
            //}

            if (!String.IsNullOrEmpty(xml.InscricaoEstadual))
            {
                crm.InscricaoEstadual = xml.InscricaoEstadual;
            }
            else
            {
                crm.AddNullProperty("InscricaoEstadual");
            }

            if (!string.IsNullOrEmpty(xml.Oportunidade))
            {
                crm.Oportunidade = new Lookup(new Guid(xml.Oportunidade), "");
            }

            xml.PrecoBloqueado = xml.PrecoBloqueado;

            if (xml.ValorDesconto.HasValue)
            {
                crm.ValorDescontoFatura = xml.ValorDesconto;
            }
            else
            {
                crm.AddNullProperty("ValorDescontoFatura");
            }

            if (xml.PercentualDesconto.HasValue)
            {
                crm.DescontoGlobalTotal = xml.PercentualDesconto;
            }
            else
            {
                crm.AddNullProperty("DescontoGlobalTotal");
            }

            //Service Lista Preço
            ListaPreco ObjListaPreco = new Intelbras.CRM2013.Domain.Servicos.ListaPrecoService(this.Organizacao, this.IsOffline).BuscaListaPreco(xml.ListaPreco);

            if (ObjListaPreco != null)
            {
                crm.ListaPrecos = new Lookup((Guid)ObjListaPreco.ID, "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador da Lista de Preço não encontrado.";
                return(crm);
            }

            crm.Prioridade = xml.Prioridade;

            if (xml.ValorTotal.HasValue)
            {
                crm.ValorTotal = xml.ValorTotal;
            }
            else
            {
                crm.AddNullProperty("ValorTotal");
            }

            if (xml.ValorTotalImpostos.HasValue)
            {
                crm.TotalImpostos = xml.ValorTotalImpostos;
            }
            else
            {
                crm.AddNullProperty("TotalImpostos");
            }

            //if (xml.ValorTotalProdutosSemImposto.HasValue)
            //    crm.ValorTotalProdutosSemIPIST = xml.ValorTotalProdutosSemImposto;

            if (xml.ValorTotalSemFrete.HasValue)
            {
                crm.ValorTotalSemFrete = xml.ValorTotalSemFrete;
            }
            else
            {
                crm.AddNullProperty("ValorTotalSemFrete");
            }

            if (xml.ValorTotalDesconto.HasValue)
            {
                crm.DescontoTotal = xml.ValorTotalDesconto;
            }
            else
            {
                crm.AddNullProperty("DescontoTotal");
            }

            if (xml.ValorTotalProdutos.HasValue)
            {
                crm.TotalProdutosComIPIST = xml.ValorTotalProdutos;
            }
            else
            {
                crm.AddNullProperty("TotalProdutosComIPIST");
            }

            if (xml.ValorTotalProdutosSemImposto.HasValue)
            {
                crm.ValorTotalProdutosSemIPIST = xml.ValorTotalProdutosSemImposto;
            }
            else
            {
                crm.AddNullProperty("ValorTotalProdutosSemIPIST");
            }

            //Service Endereco Entrega

            if (!string.IsNullOrEmpty(xml.EnderecoEntrega.CaixaPostal))
            {
                crm.EnderecoEntregaCaixaPostal = xml.EnderecoEntrega.CaixaPostal;
            }
            else
            {
                crm.AddNullProperty("EnderecoEntregaCaixaPostal");
            }

            if (!string.IsNullOrEmpty(xml.EnderecoEntrega.NomeEndereco))
            {
                crm.NomeEntrega = xml.EnderecoEntrega.NomeEndereco;
            }
            else
            {
                crm.AddNullProperty("NomeEntrega");
            }

            crm.CEPEntrega            = xml.EnderecoEntrega.CEP;
            crm.EnderecoEntregaRua    = xml.EnderecoEntrega.Logradouro;
            crm.EnderecoEntregaNumero = xml.EnderecoEntrega.Numero;
            crm.BairroEntrega         = xml.EnderecoEntrega.Bairro;
            crm.ComplementoEntrega    = xml.EnderecoEntrega.Complemento;
            crm.TipoNotaFiscal        = xml.TipoNotaFiscal;
            crm.NotaDevolucao         = xml.NotaDevolucao;
            crm.IdentificadorUnicoNfe = xml.IdentificadorUnicoNFE;

            if (!string.IsNullOrEmpty(xml.EnderecoEntrega.Complemento))
            {
                crm.ComplementoEntrega = xml.EnderecoEntrega.Complemento;
            }
            else
            {
                crm.AddNullProperty("ComplementoEntrega");
            }


            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.Cidade))
            {
                Model.Municipio cidade = new Model.Municipio(this.Organizacao, this.IsOffline);
                cidade = new Intelbras.CRM2013.Domain.Servicos.EnderecoServices(this.Organizacao, this.IsOffline).BuscaMunicipio(xml.EnderecoEntrega.Cidade);

                if (cidade != null && cidade.ID.HasValue)
                {
                    crm.EnderecoEntregaCidade = new Lookup(cidade.ID.Value, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador da Cidade não encontrado!";
                    return(crm);
                }
            }

            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.Estado))
            {
                Model.Estado estado = new Model.Estado(this.Organizacao, this.IsOffline);
                estado = new Intelbras.CRM2013.Domain.Servicos.EnderecoServices(this.Organizacao, this.IsOffline).BuscaEstado(xml.EnderecoEntrega.Estado);

                if (estado != null && estado.ID.HasValue)
                {
                    crm.EnderecoEntregaEstado = new Lookup(estado.ID.Value, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador do Estado não encontrado!";
                    return(crm);
                }
            }

            ///Service Pais
            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.Pais))
            {
                Model.Pais pais = new Model.Pais(this.Organizacao, this.IsOffline);
                pais = new Intelbras.CRM2013.Domain.Servicos.EnderecoServices(this.Organizacao, this.IsOffline).BuscaPais(xml.EnderecoEntrega.Pais);

                if (pais != null && pais.ID.HasValue)
                {
                    crm.EnderecoEntregaPais = new Lookup(pais.ID.Value, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador do País não encontrado.";
                    return(crm);
                }
            }

            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.NomeContato))
            {
                crm.NomeEntrega = xml.EnderecoEntrega.NomeContato;
            }
            else
            {
                crm.AddNullProperty("NomeEntrega");
            }


            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.Telefone))
            {
                crm.TelefoneEntrega = xml.EnderecoEntrega.Telefone;
            }
            else
            {
                crm.AddNullProperty("TelefoneEntrega");
            }


            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.Fax))
            {
                crm.FaxEntrega = xml.EnderecoEntrega.Fax;
            }
            else
            {
                crm.AddNullProperty("FaxEntrega");
            }


            #region Representante

            crm.IntegradoRepresentanteComErro = false;
            crm.IntegradoComErros             = false;
            crm.RepresentanteOriginal         = xml.Representante.ToString();

            Contato ObjRepresentante = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline)
                                       .BuscaContatoPorCodigoRepresentante(xml.Representante.ToString());

            if (ObjRepresentante != null)
            {
                crm.KARepresentante = new Lookup(ObjRepresentante.ID.Value, "");
            }
            else
            {
                crm.IntegradoRepresentanteComErro = true;
                crm.IntegradoComErros             = true;
                crm.KARepresentante = new Lookup(ObterRepresentatePadrao(), "");
            }

            #endregion

            return(crm);
        }
コード例 #27
0
 public override void Editar()
 {
     ICondicaoPagamento condicaoPagamento = new CondicaoPagamento(GUID);
     condicaoPagamento.Descricao = "Condição de pagamento [editado]";
     condicaoPagamento.Save();
 }
コード例 #28
0
ファイル: MSG0004.cs プロジェクト: ertprs/crm_fonte
        public CondicaoPagamento DefinirPropriedades(Intelbras.Message.Helper.MSG0004 xml)
        {
            var crm = new CondicaoPagamento(this.Organizacao, this.IsOffline);

            crm.Codigo = xml.CodigoCondicaoPagamento;

            if (!String.IsNullOrEmpty(xml.Nome))
            {
                crm.Nome = xml.Nome;
            }

            if (xml.NumeroParcelas.HasValue)
            {
                crm.NumeroParcelas = xml.NumeroParcelas;
            }

            if (xml.ChaveIntegracaoIndice != null && xml.ChaveIntegracaoIndice != String.Empty)
            {
                var IntegracaoIndice = _Repository.Indice.ObterPor(xml.ChaveIntegracaoIndice);
                if (IntegracaoIndice != null)
                {
                    crm.Indice = new SDKore.DomainModel.Lookup(IntegracaoIndice.ID.Value, IntegracaoIndice.Nome, SDKore.Crm.Util.Utility.GetEntityName(IntegracaoIndice));
                }
            }

            if (xml.NumeroTabelaFinanciamento != null && xml.NumeroTabelaFinanciamento != String.Empty)
            {
                var IntegracaoTabelaFinanciamento = _Repository.TabelaFinanciamento.ObterPor(xml.NumeroTabelaFinanciamento);
                if (IntegracaoTabelaFinanciamento != null)
                {
                    crm.TabelaFinanciamento = new SDKore.DomainModel.Lookup(IntegracaoTabelaFinanciamento.ID.Value, IntegracaoTabelaFinanciamento.Nome, SDKore.Crm.Util.Utility.GetEntityName(IntegracaoTabelaFinanciamento));
                }
            }

            if (xml.PercentualDesconto.HasValue)
            {
                crm.PercDesconto = xml.PercentualDesconto;
            }

            if (xml.Prazo.HasValue)
            {
                crm.Prazos = xml.Prazo;
            }

            if (xml.Situacao.HasValue)
            {
                crm.Status = xml.Situacao;
            }

            crm.SupplierCard = xml.SupplierCard;

            crm.IntegradoEm               = DateTime.Now;
            crm.IntegradoPor              = usuarioIntegracao.NomeCompleto;
            crm.UsuarioIntegracao         = xml.LoginUsuario;
            crm.UtilizadoParaB2B          = xml.UtilizadoB2B;
            crm.UtilizadoParaCanais       = xml.UtilizadoCanais;
            crm.UtilizadoParaFornecedores = xml.UtilizadoFornecedores;
            crm.UtilizadoParaSdcv         = xml.UtilizadoSDCV;
            crm.UtilizadoRevenda          = xml.UtilizadoRevenda;

            return(crm);
        }
コード例 #29
0
ファイル: MSG0004.cs プロジェクト: ertprs/crm_fonte
 public string Enviar(CondicaoPagamento objModel)
 {
     throw new NotImplementedException();
 }
コード例 #30
0
 public CondicaoPagamento Atualizar(CondicaoPagamento condicaoPagamento)
 {
     _context.Entry(condicaoPagamento).State = System.Data.Entity.EntityState.Modified;
     _context.SaveChanges();
     return(_context.Entry(condicaoPagamento).Entity);
 }
コード例 #31
0
 public CondicaoPagamento CriarCondicaoPagamento(CondicaoPagamento condicaoPagamento)
 {
     condicaoPagamento.Validar();
     return(_condicaoPagamentoRepository.Criar(condicaoPagamento));
 }
コード例 #32
0
        /// <summary>
        /// Método utilizado para preencher esta instância com os dados do dataReader
        /// </summary>
        /// <param name="dataReader">DataReader com os dados que deverão ser passados para esta instância</param>
        public override void Populate(DataReader dataReader)
        {
            #region base
            base.Populate(dataReader);
            #endregion

            #region desta classe
            CondicaoPagamento = new CondicaoPagamento(dataReader.GetValue<string>("p_GUIDCondPgto"));
            Parcela = dataReader.GetValue<int>("p_Parcela");
            Percentual = dataReader.GetValue<double>("p_Percentual");
            PeriodoVencimento = new Periodo(dataReader.GetValue<string>("p_GUIDPeriodoVenc"));
            ApartirDataEmissao = dataReader.GetValue<int>("p_ApartirDtEmissao");
            ApartirDataVencimentoAnterior = dataReader.GetValue<int>("p_ApartirDtVenctoAnterior");
            #endregion
        }