public void LimparAvisoPedidoFornecedor(Pedido pedido, int pTipoAviso, int usuarioId)
        {
            // Identifica Pedido que está na tabela de Avisos
            var vAviso = _avisosRep
                         .FirstOrDefault(w => w.IdReferencia == pedido.Id &&
                                         w.UsuarioNotificadoId == usuarioId &&
                                         w.TipoAvisosId == pTipoAviso &&
                                         w.ModuloId == 4);

            if (vAviso != null)
            {
                _avisosRep.Delete(vAviso);
                _unitOfWork.Commit();
            }
        }
        public HttpResponseMessage AtualizarPlano(HttpRequestMessage request, int IdPano, bool TrocarPlanoMembro, int TipoPagamentoId, CartaoCreditoViewModel cartaoCreditoViewModel)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response;

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    var dtTrocaPlano = new DateTime();
                    var mensalidadeCriada = false;
                    var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
                    Membro membro = _membroRep.FindBy(m => m.Pessoa.Id == usuario.Pessoa.Id).FirstOrDefault();
                    var _cartao = _cartaoCreditoRep.FirstOrDefault(x => x.MembroId == membro.Id);

                    var dtVencimento = new DateTime();
                    var dataHoje = DateTime.Now;
                    var dataFimGratuidade = membro.DataFimPeriodoGratuito ?? membro.DtCriacao;
                    var tipoPagamento = (TipoMovimentacao)TipoPagamentoId;

                    if (tipoPagamento == TipoMovimentacao.Boleto)
                    {
                        membro.PlanoMensalidadeId = IdPano;
                        dtVencimento = dataHoje.AddDays(1);
                    }
                    else
                    {
                        membro.PlanoMensalidadeId = IdPano;
                        _cartao.TokenCartaoGerenciaNet = cartaoCreditoViewModel.TokenCartaoGerenciaNet;
                        dtVencimento = DateTime.Now;

                        _cartaoCreditoRep.Edit(_cartao);
                    }

                    _membroRep.Edit(membro);

                    _unitOfWork.Commit();

                    if (!TrocarPlanoMembro)
                    {
                        mensalidadeCriada = _pagamentoService.GerarMensalidadeMembro(usuario, membro, dtVencimento, tipoPagamento);
                    }
                    else
                    {
                        dtTrocaPlano = _pagamentoService.TrocaPlano(usuario, membro, dtVencimento, tipoPagamento);
                        mensalidadeCriada = true;
                    }


                    response = request.CreateResponse(HttpStatusCode.OK, new { criouMensalidade = mensalidadeCriada, dataTrocaPlano = dtTrocaPlano.ToString("dd/MM/yyyy") });
                }

                return response;
            }));
        }
        public HttpResponseMessage GetEnderecoMembroAtivo(HttpRequestMessage request, int pessoaId)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                var listaEnderecosVM = new List <EnderecoViewModel>();

                var membro = _membroRep.FirstOrDefault(x => x.PessoaId == pessoaId);

                var enderecosMembro = membro.Pessoa.Enderecos.Where(a => a.Ativo).ToList();
                var enderecosFornecedor = membro.MembroFornecedores.SelectMany(x => x.Fornecedor.Pessoa.Enderecos).ToList();

                enderecosMembro.ForEach(x =>
                {
                    var listPeriodo = new List <PeriodoEntregaViewModel>();

                    x.HorasEntregaMembro.ForEach(t =>
                    {
                        listPeriodo.Add(new PeriodoEntregaViewModel
                        {
                            Id = t.Id,
                            DescPeriodoEntrega = t.DescHorarioEntrega
                        });
                    });


                    listaEnderecosVM.Add(new EnderecoViewModel
                    {
                        Id = x.Id,
                        EstadoId = x.EstadoId,
                        CidadeId = x.CidadeId,
                        BairroId = x.BairroId,
                        LogradouroId = x.LogradouroId,
                        Bairro = x.Bairro.DescBairro,
                        Cep = x.Cep,
                        Complemento = x.Complemento,
                        Cidade = x.Cidade.DescCidade,
                        Estado = x.Estado.DescEstado,
                        Logradouro = x.Logradouro.DescLogradouro,
                        NumEndereco = x.Numero,
                        Ativo = x.Ativo,
                        EnderecoPadrao = x.EnderecoPadrao,
                        DescHorarioEntrega = x.HorasEntregaMembro.Select(h => h.DescHorarioEntrega).FirstOrDefault(),
                        PeriodoEntrega = listPeriodo,
                        DescAtivo = x.Ativo ? "Ativo" : "Inativo",
                        Endereco = x.DescEndereco,
                        FornecedorNesteEndereco = enderecosFornecedor.Exists(d => d.CidadeId == x.CidadeId)
                    });
                });

                response = request.CreateResponse(HttpStatusCode.OK, listaEnderecosVM);
                return response;
            }));
        }
        public HttpResponseMessage FornCotacaoEveolucao(HttpRequestMessage request)
        {
            return(CreateHttpResponse(request, () =>
            {
                var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
                var fornecedor = _fornecedorRep.FirstOrDefault(x => x.Pessoa.Id == usuario.Pessoa.Id);

                var pFornecedorId = new SqlParameter
                {
                    ParameterName = "@FORNECEDORID",
                    SqlDbType = SqlDbType.BigInt,
                    Value = fornecedor.Id
                };


                var relatCe = _usuarioRep.ExecWithStoreProcedure <IndicadorFornViewModel>("stp_fornecedor_rel_cotacao_evolucao @FORNECEDORID", pFornecedorId);

                _unitOfWork.Commit();

                var pForId = new SqlParameter
                {
                    ParameterName = "@FORN",
                    SqlDbType = SqlDbType.BigInt,
                    Value = fornecedor.Id
                };


                var relatCp = _usuarioRep.ExecWithStoreProcedure <IndicadorFornViewModel>("stp_fornecedor_rel_cotacao_partic @FORN", pForId);



                _unitOfWork.Commit();
                var relatCped = "";

                var response = request.CreateResponse(HttpStatusCode.OK, new { relatCe, relatCp, relatCped });
                return response;
            }));
        }
        public void CancelarPlanoAssinatura()
        {
            var dataHoje           = DateTime.Now.Date;
            var usuariosCancelados = _usuarioCanceladoRep.FindBy(x => x.DataCancelamento < dataHoje && x.Ativo).ToList();
            var pessoa             = new List <int>();


            usuariosCancelados.ForEach(x =>
            {
                var usuario   = _usuarioRep.FirstOrDefault(u => u.Id == x.UsuarioId);
                usuario.Ativo = false;
                _usuarioRep.Edit(usuario);

                var usuarioCancelado   = _usuarioCanceladoRep.FirstOrDefault(c => c.UsuarioId == x.UsuarioId);
                usuarioCancelado.Ativo = false;
                _usuarioCanceladoRep.Edit(usuarioCancelado);


                _unitOfWork.Commit();

                if (!pessoa.Contains(usuario.PessoaId))
                {
                    pessoa.Add(usuario.PessoaId);
                }
            });

            if (pessoa.Count > 0)
            {
                pessoa.ForEach(p =>
                {
                    var membro = _membroRep.FirstOrDefault(m => m.PessoaId == p);
                    if (membro != null)
                    {
                        membro.Ativo = false;
                        _membroRep.Edit(membro);
                    }

                    var fornecedor = _forneceRep.FirstOrDefault(m => m.PessoaId == p);
                    if (fornecedor != null)
                    {
                        fornecedor.Ativo = false;
                        _forneceRep.Edit(fornecedor);
                    }

                    _unitOfWork.Commit();
                });
            }
        }
        public HttpResponseMessage ItensPedidoDespachado(HttpRequestMessage request, List <ItemPedidoViewModel> itenspedidoVm)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
                var fornecedor = _fornecedorRep.FirstOrDefault(x => x.PessoaId == usuario.PessoaId);
                var idPedido = itenspedidoVm?.FirstOrDefault().PedidoId;
                var pedido = _pedidoRep.FirstOrDefault(x => x.Id == idPedido);

                //Pegamos os ítens de pedidos que foram aprovados.
                var itensPedido = pedido.ItemPedidos
                                  .Where(x => x.AprovacaoFornecedor && x.Ativo && x.FornecedorId == fornecedor.Id).ToList();


                foreach (var item in itensPedido)
                {
                    item.UsuarioAlteracao = usuario;
                    item.DataEntregaFornecedor = DateTime.Now;
                    item.FlgDespacho = true;
                    _itemPedidoRep.Edit(item);
                }

                _ultilService.EnviaEmailPedido(pedido.Id, 6, usuario);

                //pega o telefone do usuário q criou o pedido
                var usuariosMembro = pedido.UsuarioCriacao;

                Sms sms = new Sms()
                {
                    UsuarioCriacao = usuario,
                    DtCriacao = DateTime.Now,
                    Numero = usuariosMembro.Telefones.Select(t => t.DddCel).FirstOrDefault() + usuariosMembro.Telefones.Select(t => t.Celular).FirstOrDefault(),
                    Mensagem = "Economiza Já-Fornecedor Despachou para Entrega itens do seu pedido " + pedido.Id,
                    Status = StatusSms.NaoEnviado,
                    OrigemSms = TipoOrigemSms.FornecedorDespachoItensPedido,
                    Ativo = true
                };

                _smsRep.Add(sms);

                _unitOfWork.Commit();

                response = request.CreateResponse(HttpStatusCode.OK, new { success = true, pedidoId = pedido.Id });

                return response;
            }));
        }
示例#7
0
        public HttpResponseMessage GetPai(HttpRequestMessage request, MenuViewModel menuViewModel, string filter = null)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                Menu menu = null;
                var menuPaiId = filter.TryParseInt();

                menu = _menuRep.FirstOrDefault(c => c.Id == menuPaiId);

                menuViewModel = Mapper.Map <Menu, MenuViewModel>(menu);
                response = request.CreateResponse(HttpStatusCode.Created, menuViewModel);

                return response;
            }));
        }
示例#8
0
        public HttpResponseMessage histLancesFornecedorPorPedido(HttpRequestMessage request, int pedidoId)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
                Membro _membro = _membroRep.FirstOrDefault(x => x.PessoaId == usuario.PessoaId);
                List <int> _fornecedoresMembro = _membroFornecedorRep.FindBy(x => x.MembroId == _membro.Id).Select(f => f.FornecedorId).ToList();

                if (pedidoId > 0)
                {
                    Pedido pedidos = this._pedidoRep.GetAll().Where(x => x.Id.Equals(pedidoId)).FirstOrDefault();

                    List <ItemPedidosFornecedores> listaPedidoFornecedor = new List <ItemPedidosFornecedores>();
                    List <FornecedorLance> listaFornecedor = new List <FornecedorLance>();
                    CotacaoPedidos CP = _cotacaoPedidosRep.GetAll().Where(cp => cp.PedidoId == pedidos.Id).FirstOrDefault();
                    foreach (var item in pedidos.ItemPedidos)
                    {
                        listaFornecedor = new List <FornecedorLance>();


                        List <ResultadoCotacao> lResultCotacao = null;


                        lResultCotacao = _resultadoCotacaoRep.FindBy(rc => rc.CotacaoId == CP.CotacaoId &&
                                                                     rc.ProdutoId == item.ProdutoId &&
                                                                     rc.FlgOutraMarca == item.FlgOutraMarca &&
                                                                     _fornecedoresMembro.Contains(rc.FornecedorId)).ToList();



                        foreach (var itemResultado in lResultCotacao)
                        {
                            listaFornecedor.Add(new FornecedorLance
                            {
                                ItemFornecedorLance = itemResultado.Fornecedor,
                                valorLance = itemResultado.PrecoNegociadoUnit,
                                obs = itemResultado.Observacao
                            });
                        }
                        listaPedidoFornecedor.Add(new ItemPedidosFornecedores
                        {
                            ItemPedidos = item,
                            ListFornecedorLance = listaFornecedor
                        });
                    }

                    PedidoFornecedoresPorITem histPedidoCotacao = new PedidoFornecedoresPorITem();

                    histPedidoCotacao.Id = pedidos.Id;
                    histPedidoCotacao.DtPedido = pedidos.DtPedido;
                    histPedidoCotacao.FlgCotado = pedidos.FlgCotado;
                    histPedidoCotacao.StatusSistemaId = pedidos.StatusSistemaId;
                    histPedidoCotacao.MembroId = pedidos.MembroId;
                    histPedidoCotacao.EnderecoId = pedidos.EnderecoId;
                    histPedidoCotacao.ItemPedidosFornecedor = listaPedidoFornecedor;

                    PedidoFornecedoresPorItemViewModel histPedidoCotacaoVM = Mapper.Map <PedidoFornecedoresPorITem, PedidoFornecedoresPorItemViewModel>(histPedidoCotacao);


                    response = request.CreateResponse(HttpStatusCode.OK, new { success = true, lancesFornecedorPedido = histPedidoCotacaoVM });
                }
                else
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest, "Não foi possível devolver a dados de itens do pedido " + pedidoId);
                }

                return response;
            }));
        }
示例#9
0
 public String BuscaTemplate(int id)
 {
     return(_templateEmailRep.FirstOrDefault(x => x.Id == id).Template);
 }
        public List <Usuario> UsuariosFornecedoresResponderCotacao(Cotacao pCotacao, int qtdHoraEnvioNotificacao)
        {
            var listaRetorno     = new List <Usuario>();
            var cotacaoesPedidos = _cotacaoPedidoRep.GetAll().Where(w => w.CotacaoId == pCotacao.Id).ToList();


            //resgatar todos fornecedores que deram lance na cotação
            var fornecedoresDeramLance = _resultadoCotacaoRep.FindBy(rc => rc.CotacaoId == pCotacao.Id).Select(s => s.Fornecedor).ToList();

            //pegar todos fornecedores que podem dar o lance na cotação
            var todosMembrosCotacao = cotacaoesPedidos.Select(s => s.Pedido.MembroId).ToList();
            var todosFornecedores   = _membroFornecedorRep.GetAll().Where(w => todosMembrosCotacao.Contains(w.MembroId)).Select(s => s.Fornecedor).ToList();

            //fazer distinção dos fornecedores que deram o lance e que podiam dar o lance, para separar os que ainda não deram
            var fornecedoresNaoDeramLance = todosFornecedores.Except(fornecedoresDeramLance).ToList();

            //Pegar todos Usuarios dos fornecedores que não deram lance
            var pFornecedores = fornecedoresNaoDeramLance.Select(s => s.Pessoa.Id).ToList();
            var listaUsuariosFornecedoresRespCotacao = _usuarioRep.GetAll().Where(u => pFornecedores.Contains(u.PessoaId)).ToList();

            var horaFechamentoCotcao = _cotacaoRep.FirstOrDefault(x => x.Id == pCotacao.Id).DtFechamento;
            var dataHoraParametro    = new TimeSpan(qtdHoraEnvioNotificacao, 0, 0).Subtract(new TimeSpan(0, 30, 0));

            listaUsuariosFornecedoresRespCotacao.ForEach(x =>
            {
                var enviaNotificacao = false;
                var aviso            = _avisosRep.FirstOrDefault(a => a.UsuarioNotificado.Id == x.Id && a.TipoAviso.Id == (int)TipoAviso.NovaCotacao);

                if (aviso == null)
                {
                    enviaNotificacao = (horaFechamentoCotcao - DateTime.Now) <= dataHoraParametro ? true : false;

                    if (enviaNotificacao)
                    {
                        var _aviso = new Avisos
                        {
                            UsuarioCriacaoId    = 1,
                            DtCriacao           = DateTime.Now,
                            Ativo               = true,
                            IdReferencia        = pCotacao.Id,
                            DataUltimoAviso     = DateTime.Now,
                            ExibeNaTelaAvisos   = true,
                            TipoAvisosId        = (int)TipoAviso.NovaCotacao, //Id TipoAviso para esse aviso
                            URLPaginaDestino    = "/#/cotacoes",
                            TituloAviso         = "Cotação Pendente de Resposta",
                            ToolTip             = "Cotação Pendente de Resposta",
                            DescricaoAviso      = "Cotação " + pCotacao.Id + " Pendente de Resposta",
                            ModuloId            = 4, //Modulo Fornecedor
                            UsuarioNotificadoId = x.Id
                        };

                        _avisosRep.Add(_aviso);
                        _unitOfWork.Commit();
                    }
                }
                else
                {
                    enviaNotificacao = (horaFechamentoCotcao - DateTime.Now) <= dataHoraParametro &&
                                       (DateTime.Now - aviso.DataUltimoAviso) >= dataHoraParametro ? true : false;
                }

                if (enviaNotificacao)
                {
                    listaRetorno.Add(x);
                    if (aviso != null)
                    {
                        AtualizaDataAviso(aviso, x.Id);
                    }
                }
            });

            return(listaRetorno);
        }
示例#11
0
        public HttpResponseMessage CancelarAssinatura(HttpRequestMessage request)
        {
            return(CreateHttpResponse(request, () =>
            {
                if (!ModelState.IsValid)
                {
                    var response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                          ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                          .Select(m => m.ErrorMessage).ToArray());
                    return response;
                }
                else
                {
                    HttpResponseMessage response;

                    var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                    var fornecedor = _fornecedorRep.FirstOrDefault(x => x.PessoaId == usuario.PessoaId);
                    var membro = _membroRep.FirstOrDefault(x => x.PessoaId == usuario.PessoaId);

                    if (fornecedor != null)
                    {
                        // Atualizar usuário como inativo caso não se tenha fatura em aberto
                        // No Client deve-se verificar se voltou faturas, se sim mostrar pop'up falando que assinatura
                        // só será cancelada quando se quitar as dívidas, direcionando usuário para tela de faturas para o mesmo imprimir o boleto.
                        // Quando se pagar a dívida, na notificação enviada pela GerenciaNet deve-se verificar
                        // a tabela de usuário cancelado e mudar o campo ativo do usuário e membro para false.

                        var usuarioCanceladoFornecedor = _usuarioCanceladoRep.FirstOrDefault(u => u.Usuario.PessoaId == fornecedor.PessoaId) != null;

                        if (usuario.FlgMaster)
                        {
                            if (!usuarioCanceladoFornecedor)
                            {
                                var faturas = _faturaRep
                                              .GetAll().Where(x => x.FornecedorId == fornecedor.Id &&
                                                              (x.Status != StatusFatura.Recebido && x.Status != StatusFatura.Link &&
                                                               x.Status != StatusFatura.Cancelado && x.Status != StatusFatura.Devolvido)).ToList();

                                if (faturas.Count == 0)
                                {
                                    var _usuariosDesativados = _usuarioRep.GetAll().Where(x => x.PessoaId == usuario.PessoaId).ToList();

                                    for (int i = 0; i < _usuariosDesativados.Count; i++)
                                    {
                                        _usuariosDesativados[i].Ativo = false;
                                        _usuarioRep.Edit(_usuariosDesativados[i]);
                                    }

                                    fornecedor.Ativo = false;
                                    _fornecedorRep.Edit(fornecedor);

                                    _usuarioCanceladoRep.Add(new UsuarioCancelado
                                    {
                                        UsuarioId = usuario.Id,
                                        DataCancelamento = DateTime.Now,
                                        UsuarioCriacaoId = usuario.Id,
                                        DtCriacao = DateTime.Now,
                                        Ativo = true
                                    });

                                    _unitOfWork.Commit();

                                    var faturasVM = Mapper.Map <IEnumerable <Fatura>, IEnumerable <FaturaViewModel> >(faturas);

                                    response = request.CreateResponse(HttpStatusCode.OK, faturasVM);

                                    return response;
                                }
                                else
                                {
                                    var faturasVM = Mapper.Map <IEnumerable <Fatura>, IEnumerable <FaturaViewModel> >(faturas);

                                    response = request.CreateResponse(HttpStatusCode.OK, faturasVM);

                                    return response;
                                }
                            }
                        }
                        else
                        {
                            var usuarioMaster = _usuarioRep.FirstOrDefault(x => x.PessoaId == usuario.PessoaId && !x.FlgMaster);

                            response = request.CreateResponse(HttpStatusCode.OK, "Somente o usuário " + usuarioMaster.UsuarioNome + " pode cancelar a assinatura, pois o mesmo é usuário Master!");

                            return response;
                        }
                    }
                    else if (membro != null)
                    {
                        // Inserir na tabela de usuário cancelado para se ter histórico de cancelamento, caso
                        // membro esteja em dia e esteja no mês corrente mostrar mensagem no client que a assinatura estara ativa até o dia anterior ao fechar a mensalidade para próximo mês.
                        // Colocar data na mensagem do client Ex: (sua assinatura estara ativa até o dia tal, somente para consultar de pedidos)
                        //colocar data de desabilitação para robô passar e mudar usuário para inativo
                        // na data estipulada no campo desta tabela.

                        // No Client deve-se verificar se voltou mensalidades, se sim mostrar pop'up falando que assinatura
                        // só será cancelada quando se quitar as dívidas, direcionando usuário para tela de mensalidades para o mesmo imprimir o boleto.
                        // Quando se pagar a dívida, na notificação enviada pela GerenciaNet deve-se verificar
                        // a tabela de usuário cancelado e mudar o campo ativo do usuário e membro para false.

                        var usuarioCanceladoMembro = _usuarioCanceladoRep.FirstOrDefault(u => u.Usuario.PessoaId == membro.PessoaId) != null;

                        if (!usuarioCanceladoMembro)
                        {
                            if (usuario.FlgMaster)
                            {
                                var mens = _mensalidadeRep.FindBy(x => x.Membro.PessoaId == usuario.PessoaId &&
                                                                  x.Status == StatusMensalidade.Recebido ||
                                                                  x.Status == StatusMensalidade.AguardandoPagamento)
                                           .OrderByDescending(x => x.Id)
                                           .FirstOrDefault();


                                if (mens != null && mens.Status == StatusMensalidade.Recebido)
                                {
                                    // Cancelar Plano
                                    _pagamentoService.CancelarPlano(mens.Id);

                                    var dataFimAcesso = mens.DtRecebimento != null ?
                                                        mens.DtRecebimento.Value.AddMonths(membro.PlanoMensalidade.QtdMeses) : DateTime.Now;

                                    var _usuariosDesativados = _usuarioRep.FindBy(x => x.PessoaId == usuario.PessoaId).ToList();

                                    if (dataFimAcesso < DateTime.Now)
                                    {
                                        for (int i = 0; i < _usuariosDesativados.Count; i++)
                                        {
                                            _usuariosDesativados[i].Ativo = false;
                                            _usuarioRep.Edit(_usuariosDesativados[i]);
                                        }

                                        membro.Ativo = false;
                                        _membroRep.Edit(membro);
                                    }


                                    _usuarioCanceladoRep.Add(new UsuarioCancelado
                                    {
                                        UsuarioId = usuario.Id,
                                        DataCancelamento = dataFimAcesso,
                                        UsuarioCriacaoId = usuario.Id,
                                        DtCriacao = DateTime.Now,
                                        Ativo = true
                                    });

                                    mens.Ativo = false;
                                    _mensalidadeRep.Edit(mens);

                                    _unitOfWork.Commit();

                                    response = request.CreateResponse(HttpStatusCode.OK,
                                                                      $"Você ainda terá até o dia {dataFimAcesso.ToShortDateString()} para acessar a plataforma, depois deste prazo sua conta será desativada automaticamente.");

                                    return response;
                                }
                                else
                                {
                                    if (!usuarioCanceladoMembro)
                                    {
                                        // Cancelar plano
                                        if (mens != null)
                                        {
                                            _pagamentoService.CancelarPlano(mens.Id);
                                        }

                                        var _usuariosDesativados = _usuarioRep.FindBy(x => x.PessoaId == usuario.PessoaId).ToList();

                                        for (int i = 0; i < _usuariosDesativados.Count; i++)
                                        {
                                            _usuariosDesativados[i].Ativo = false;
                                            _usuarioRep.Edit(_usuariosDesativados[i]);
                                        }

                                        membro.Ativo = false;
                                        _membroRep.Edit(membro);

                                        _usuarioCanceladoRep.Add(new UsuarioCancelado
                                        {
                                            UsuarioId = usuario.Id,
                                            DataCancelamento = DateTime.Now,
                                            UsuarioCriacaoId = usuario.Id,
                                            DtCriacao = DateTime.Now,
                                            Ativo = true
                                        });

                                        _unitOfWork.Commit();

                                        response = request.CreateResponse(HttpStatusCode.Created, "Assinatura cancelada com sucesso!");

                                        return response;
                                    }
                                }
                            }
                            else
                            {
                                var usuarioMaster = _usuarioRep.FirstOrDefault(x => x.PessoaId == usuario.PessoaId && x.FlgMaster);

                                response = request.CreateResponse(HttpStatusCode.OK, "Somente o usuário ''" + usuarioMaster.UsuarioNome + "'' poderá cancelar a assinatura, pois o mesmo é usuário Master!");

                                return response;
                            }
                        }
                    }

                    response = request.CreateResponse(HttpStatusCode.NoContent);

                    return response;
                }
            }));
        }
        /// <summary>
        /// Pega os Parâmetros cadastrados no banco de dados passando o ID do mesmo.
        /// </summary>
        /// <param name="codigoParam">Passar o ID cadastrado no Banco de Dados</param>
        /// <returns></returns>
        public string GetParametroSistema(string codigoParam)
        {
            var paramRet = _parametroSistemaRep.FirstOrDefault(w => w.Codigo == codigoParam);

            return(paramRet != null ? paramRet.Valor : "");
        }
示例#13
0
        public RetornoFeriadoMembro VerificaFeriadoMembro(DateTime data, Membro membro, string descEstado = null)
        {
            var estado      = _utilService.RemoverAcentos(descEstado.Trim().Replace(" ", "_").ToUpper());
            var dataFeriado = new CalendarioFeriado();

            data = new DateTime(data.Year, data.Month, data.Day);
            var tipoFeriado = new TipoRetornoFeriado();

            dataFeriado = _calendarioFeriadoRep
                          .FirstOrDefault(x => x.DtEvento == data && x.Estado == string.Empty && x.Cidade == string.Empty);

            if (dataFeriado == null)
            {
                if (!string.IsNullOrEmpty(estado))
                {
                    dataFeriado = _calendarioFeriadoRep
                                  .FirstOrDefault(x => x.DtEvento == data && x.Estado == estado);

                    if (dataFeriado != null)
                    {
                        var fornecedoresMembro = membro.MembroFornecedores
                                                 .Where(c => c.Fornecedor.Pessoa.Enderecos.Any(p => p.Estado.DescEstado != descEstado))
                                                 .Select(x => x.Fornecedor).ToList();

                        if (fornecedoresMembro.Count > 0)
                        {
                            var fornecedorRegiao = new List <Fornecedor>();

                            fornecedorRegiao = fornecedoresMembro
                                               .Where(c => c.FornecedorRegiao
                                                      .Any(x => _utilService.RemoverAcentos(x.Cidade.Estado.DescEstado)
                                                           .ToUpper().Replace(" ", "_") == dataFeriado.Estado))
                                               .ToList();

                            if (fornecedorRegiao.Count == 0)
                            {
                                fornecedorRegiao = fornecedoresMembro
                                                   .Where(c => c.FornecedorRegiaoSemanal
                                                          .Any(x => _utilService.RemoverAcentos(x.Cidade.Estado.DescEstado)
                                                               .ToUpper().Replace(" ", "_") == dataFeriado.Estado))
                                                   .ToList();
                            }

                            tipoFeriado = fornecedorRegiao.Count > 0 ?
                                          TipoRetornoFeriado.NaoExisteFeriado :
                                          TipoRetornoFeriado.Feriado;
                        }
                        else
                        {
                            tipoFeriado = TipoRetornoFeriado.Feriado;
                        }
                    }
                    else
                    {
                        int totalFornecedorSemFeriado = 0;

                        var fornecedoresAtendem = membro.MembroFornecedores
                                                  .Where(x => x.Fornecedor.FornecedorRegiao.Any(c => c.Cidade.Estado.DescEstado == descEstado))
                                                  .Select(f => f.Fornecedor).ToList();

                        var fornecedoresAtendemSem = membro.MembroFornecedores
                                                     .Where(x => x.Fornecedor.FornecedorRegiaoSemanal.Any(c => c.Cidade.Estado.DescEstado == descEstado))
                                                     .Select(f => f.Fornecedor)
                                                     .ToList();

                        if (fornecedoresAtendemSem.Count > 0)
                        {
                            fornecedoresAtendem.AddRange(fornecedoresAtendemSem);
                        }

                        if (fornecedoresAtendem.Count > 0)
                        {
                            var estadosFornecedores = fornecedoresAtendem.SelectMany(x => x.Pessoa.Enderecos)
                                                      .Select(c => _utilService.RemoverAcentos(c.Estado.DescEstado.ToUpper().Replace(" ", "_")))
                                                      .Distinct()
                                                      .ToList();

                            dataFeriado = _calendarioFeriadoRep
                                          .FirstOrDefault(x => x.DtEvento == data && estadosFornecedores.Contains(x.Estado));

                            if (dataFeriado != null)
                            {
                                totalFornecedorSemFeriado =
                                    estadosFornecedores.Where(x => !dataFeriado.Estado.Equals(x)).ToList().Count;
                            }
                        }

                        if (totalFornecedorSemFeriado > 0)
                        {
                            tipoFeriado = TipoRetornoFeriado.NaoExisteFeriado;
                        }
                        else if (totalFornecedorSemFeriado == 0 && dataFeriado == null)
                        {
                            tipoFeriado = TipoRetornoFeriado.NaoExisteFeriado;
                        }
                        else
                        {
                            tipoFeriado = TipoRetornoFeriado.FeriadoFornecedores;
                        }
                    }
                }
                else
                {
                    dataFeriado = _calendarioFeriadoRep
                                  .FirstOrDefault(x => x.DtEvento == data);

                    tipoFeriado = TipoRetornoFeriado.Feriado;
                }
            }
            else
            {
                tipoFeriado = TipoRetornoFeriado.FeriadoNacional;
            }

            var retornoFeriadoMembro = new RetornoFeriadoMembro
            {
                CalendarioFeriado  = dataFeriado,
                TipoRetornoFeriado = tipoFeriado
            };

            return(retornoFeriadoMembro);
        }
        public GeraCotacaoViewModel GeraCotacaoPedidos()
        {
            GeraCotacaoViewModel cotacao = new GeraCotacaoViewModel();

            var statusId   = _statusSisRep.FirstOrDefault(x => x.WorkflowStatusId == 14 && x.Ordem == 1).Id;
            var qtdPedidos = _pedidoRep.GetAll().Count(x => !x.FlgCotado && x.DtCotacao <= DateTime.Now);


            if (qtdPedidos > 0)
            {
                var pOut = new SqlParameter
                {
                    ParameterName = "@cotacaoId",
                    SqlDbType     = SqlDbType.Int,
                    Direction     = ParameterDirection.Output
                };

                _pedidoRep.ExecuteWithStoreProcedure("stp_upd_pedidos_sem_cotar @cotacaoId out", pOut);


                //Resgata ID da cotação inserida
                var cotacaoID = Convert.ToInt32(pOut.Value);

                //Historico de Cotação
                var cotacaoHistorico = new HistStatusCotacao
                {
                    Ativo            = true,
                    CotacaoId        = cotacaoID,
                    DtCriacao        = DateTime.Now,
                    UsuarioCriacaoId = 1,
                    StatusSistemaId  = statusId
                };
                _histStatusCotacaoRep.Add(cotacaoHistorico);

                var cot          = _cotacaoRep.GetSingle(cotacaoID);
                var naService    = new NotificacoesAlertasService();
                var listaUsuario = naService.TrataNovaCotacaoFornecedor(cot, (int)TipoAviso.NovaCotacao);

                foreach (var retAviso in listaUsuario)
                {
                    var aviso = new Avisos
                    {
                        UsuarioCriacaoId    = 1,
                        DtCriacao           = DateTime.Now,
                        Ativo               = true,
                        IdReferencia        = cot.Id,
                        DataUltimoAviso     = DateTime.Now,
                        ExibeNaTelaAvisos   = true,
                        TipoAvisosId        = (int)TipoAviso.NovaCotacao, //Id TipoAviso para esse aviso
                        URLPaginaDestino    = "/#/cotacoes",
                        TituloAviso         = "Cotação Pendente de Resposta",
                        ToolTip             = "Cotação Pendente de Resposta",
                        DescricaoAviso      = "Cotação " + cot.Id + " Pendente de Resposta",
                        ModuloId            = 4, //Modulo Fornecedor
                        UsuarioNotificadoId = retAviso.Usuario.Id
                    };

                    _avisosRep.Add(aviso);
                }

                _unitOfWork.Commit();

                var usuarios   = listaUsuario.Select(x => x.Usuario).Distinct();
                var listaToken = usuarios.Select(x => x.TokenSignalR).ToList();

                cotacao.CotacaoId          = cot.Id;
                cotacao.ListaTokenUsuarios = listaToken;

                return(cotacao);
            }

            return(cotacao);
        }
示例#15
0
        public void EmailNotificacaoMembro(List <Pedido> pedidos)
        {
            try
            {
                Usuario usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);
                var     corpoEmailComFornecedor = _templateEmail.FirstOrDefault(e => e.Id == 17).Template;
                var     corpoEmailSemFornecedor = _templateEmail.FirstOrDefault(e => e.Id == 33).Template;

                int statusPedidoSemFornecedor = BuscaStatusSistema(12, 9).Id;

                if (pedidos.Count > 0)
                {
                    if (corpoEmailComFornecedor != null && corpoEmailSemFornecedor != null)
                    {
                        foreach (var pedido in pedidos)
                        {
                            List <Usuario> usuarios = _usuarioRep.GetAll().Where(u => u.PessoaId == pedido.Membro.PessoaId).ToList();

                            //Aviso e Email para Membro Pedido sem Fornecedor (Todos os itens sem valor)
                            if (pedido.StatusSistemaId == statusPedidoSemFornecedor)
                            {
                                foreach (var usu in usuarios)
                                {
                                    Emails emails = new Emails
                                    {
                                        Ativo             = true,
                                        UsuarioCriacao    = usuario,
                                        DtCriacao         = DateTime.Now,
                                        AssuntoEmail      = "Pedido " + pedido.Id + " com itens sem estoque.",
                                        EmailDestinatario = usu.UsuarioEmail,
                                        CorpoEmail        = corpoEmailSemFornecedor.Trim(),
                                        Status            = Status.NaoEnviado,
                                        Origem            = Origem.NovaCotacao
                                    };
                                    //Envia EMAIL para fornecedor
                                    _emailsNotificaoRep.Add(emails);
                                }
                            }
                            //Aviso e Email para Membro Pedido Com Fornecedor
                            else
                            {
                                foreach (var usu in usuarios)
                                {
                                    var membro = _membroRep.FirstOrDefault(x => x.PessoaId == usu.PessoaId);

                                    if (_notificacoesAlertasService.PodeEnviarNotificacao(usu.Id, 1, TipoAlerta.EMAIL))
                                    {
                                        Emails emails = new Emails
                                        {
                                            UsuarioCriacao = usuario,
                                            DtCriacao      = DateTime.Now,
                                            //  AssuntoEmail = "Aprovação Pedido - Corra e aprove seu pedido " + pedido.Id + ".",

                                            AssuntoEmail      = "Corra aprove seu pedido " + pedido.Id + " valores validos por 2 dias, evite o cancelamento",
                                            EmailDestinatario = usu.UsuarioEmail,
                                            CorpoEmail        = corpoEmailComFornecedor.Replace("#NomeFantasia#", membro.Pessoa.TipoPessoa == TipoPessoa.PessoaJuridica ? membro.Pessoa.PessoaJuridica.NomeFantasia: membro.Pessoa.PessoaFisica.Nome).Trim(),
                                            Status            = Status.NaoEnviado,
                                            Origem            = Origem.NovaCotacao
                                        };
                                        //Envia EMAIL para fornecedor
                                        _emailsNotificaoRep.Add(emails);
                                    }

                                    // Inserir Alerta Para Membro
                                    Avisos locAviso = new Avisos();
                                    locAviso.UsuarioCriacao = usuario;
                                    locAviso.DtCriacao      = DateTime.Now;
                                    locAviso.Ativo          = true;
                                    //Pedido = item,
                                    locAviso.IdReferencia        = pedido.Id;
                                    locAviso.DataUltimoAviso     = DateTime.Now;
                                    locAviso.ExibeNaTelaAvisos   = true;
                                    locAviso.TipoAvisosId        = (int)TipoAviso.PedidoPendentedeAceiteMembro;
                                    locAviso.URLPaginaDestino    = "/#/meusPedidos";
                                    locAviso.TituloAviso         = "Aceite Pendente";
                                    locAviso.ToolTip             = "";
                                    locAviso.DescricaoAviso      = "Aceite Pendente do pedido " + pedido.Id;
                                    locAviso.ModuloId            = 3; //Modulo Membro
                                    locAviso.UsuarioNotificadoId = usu.Id;

                                    _avisosRep.Add(locAviso);
                                }
                            }

                            //Commit
                            _unitOfWork.Commit();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
示例#16
0
        public void CancelarPedidoMembro()
        {
            var usuarioSistema = _usuarioRep.FirstOrDefault(x => x.Id == 1);
            var diasParametroFechamentoPedido = Convert.ToInt64(_parametroSistemaRep.FindBy(x => x.Codigo.Equals("FECHAMENTO_PEDIDO")).FirstOrDefault().Valor);
            var pedidos = _pedidoRep.FindBy(x => x.StatusSistemaId == 23).ToList();

            if (pedidos.Count > 0)
            {
                pedidos.ForEach(x =>
                {
                    var nomeMembro = x.Membro.Pessoa.TipoPessoa == TipoPessoa.PessoaJuridica ? x.Membro.Pessoa.PessoaJuridica.NomeFantasia
                                                                                             : x.Membro.Pessoa.PessoaFisica.Nome;

                    var diasAguardandoAprovacao = (DateTime.Now - x.DtAlteracao.Value).Days;

                    var templateEmail = _templateEmailRep.GetSingle(44).Template
                                        .Replace("#NomeMembro#", nomeMembro)
                                        .Replace("#Id#", x.Id.ToString())
                                        .Replace("#DiasCancelamento#", diasParametroFechamentoPedido.ToString());

                    if (diasAguardandoAprovacao >= diasParametroFechamentoPedido)
                    {
                        x.StatusSistemaId = 36; //Status do Pedido Cancelado
                        _pedidoRep.Edit(x);

                        var pedidoHistorico = new HistStatusPedido
                        {
                            UsuarioCriacaoId       = usuarioSistema.Id,
                            UsuarioCriacao         = usuarioSistema,
                            DtCriacao              = DateTime.Now,
                            PedidoId               = x.Id,
                            StatusSistemaId        = 36, //Status do Pedido Cancelado
                            DescMotivoCancelamento = $"Cancelamento efetuado pelo sistema, pois passou o prazo de {diasParametroFechamentoPedido} dias para aprovação.",
                            Ativo = true,
                        };

                        _histStatusPedidoRep.Add(pedidoHistorico);


                        Emails emails = new Emails
                        {
                            UsuarioCriacao = usuarioSistema,
                            DtCriacao      = DateTime.Now,
                            AssuntoEmail   = $"Pedido {x.Id} cancelado por falta de aprovação.",

                            //pega o email do usuario q criou o pedido para notifica-lo entidade UsuarioCriacao
                            EmailDestinatario = x.UsuarioCriacao.UsuarioEmail,
                            CorpoEmail        = templateEmail.Trim(),
                            Status            = Status.NaoEnviado,
                            Origem            = Origem.CancelamentoPedidoNaoAprovadoPeloMembro,
                            Ativo             = true
                        };

                        _emailRep.Add(emails);

                        //pega o celular do usuario q criou o pedido, se caso no futuro uma empresa tiver mais de um usuario
                        // manda para o usuario q criou o pedido
                        var Cel = x.UsuarioCriacao.Telefones.Select(c => new { celular = c.DddCel + c.Celular }).FirstOrDefault();

                        Sms sms = new Sms
                        {
                            UsuarioCriacao = usuarioSistema,
                            DtCriacao      = DateTime.Now,
                            Numero         = Cel.celular.ToString(),
                            Mensagem       = $"Pedido {x.Id} cancelado por falta de aprovação.",
                            Status         = StatusSms.NaoEnviado,
                            OrigemSms      = TipoOrigemSms.CancelamentoPedidoNaoAprovadoPeloMembro,
                            Ativo          = true
                        };
                        _smsRep.Add(sms);

                        _unitOfWork.Commit();
                    }
                });
            }
        }
示例#17
0
        public HttpResponseMessage InserirCartaoCredito(HttpRequestMessage request, CartaoCreditoViewModel cartaoCreditoViewModel)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                var cartao = new CartaoCredito();

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
                    var membro = this._membroRep.GetAll().FirstOrDefault(x => x.PessoaId.Equals(usuario.PessoaId));


                    if (cartaoCreditoViewModel.Padrao)
                    {
                        var _param = new[]
                        {
                            new SqlParameter {
                                ParameterName = "@PADRAO", SqlDbType = System.Data.SqlDbType.Bit, Value = 0
                            },
                            new SqlParameter {
                                ParameterName = "@PADRAO1", SqlDbType = System.Data.SqlDbType.Bit, Value = 1
                            }
                        };

                        var sql = "UPDATE CartaoCredito set Padrao = @PADRAO WHERE Padrao = @PADRAO1";
                        _cartaoCreditoRep.ExecuteWithStoreProcedure(sql, _param);
                        _unitOfWork.Commit();
                    }

                    if (cartaoCreditoViewModel.Id != null && cartaoCreditoViewModel.Id > 0)
                    {
                        cartao = _cartaoCreditoRep.FirstOrDefault(x => x.Id == cartaoCreditoViewModel.Id);


                        cartao.Nome = cartaoCreditoViewModel.Nome;
                        cartao.Numero = cartaoCreditoViewModel.Numero;
                        cartao.DataVencimento = Convert.ToDateTime(cartaoCreditoViewModel.DataVencimento);
                        cartao.Cvc = $"{usuario.Chave}|{_encryptionService.EncryptCvv(cartaoCreditoViewModel.Cvc)}";
                        cartao.TokenCartaoGerenciaNet = string.Empty;
                        cartao.CartaoBandeiraId = cartaoCreditoViewModel.CartaoBandeiraId;
                        cartao.Padrao = cartaoCreditoViewModel.Padrao;
                        cartao.MembroId = membro.Id;
                        cartao.Ativo = true;
                        cartao.UsuarioAlteracaoId = usuario.Id;
                        cartao.UsuarioAlteracao = usuario;
                        cartao.DtAlteracao = DateTime.Now;


                        _cartaoCreditoRep.Edit(cartao);
                        _unitOfWork.Commit();
                    }
                    else
                    {
                        cartao = new CartaoCredito
                        {
                            Nome = cartaoCreditoViewModel.Nome,
                            Numero = cartaoCreditoViewModel.Numero,
                            DataVencimento = Convert.ToDateTime(cartaoCreditoViewModel.DataVencimento),
                            CartaoBandeiraId = cartaoCreditoViewModel.CartaoBandeiraId,
                            Cvc = $"{usuario.Chave}|{_encryptionService.EncryptCvv(cartaoCreditoViewModel.Cvc)}",
                            TokenCartaoGerenciaNet = string.Empty,
                            Padrao = true,
                            MembroId = membro.Id,
                            Ativo = true,
                            UsuarioCriacaoId = usuario.Id,
                            UsuarioCriacao = usuario,
                            DtCriacao = DateTime.Now,
                        };

                        _cartaoCreditoRep.Add(cartao);
                        _unitOfWork.Commit();

                        cartaoCreditoViewModel.Id = cartao.Id;
                    }

                    response = request.CreateResponse(HttpStatusCode.Created, cartaoCreditoViewModel);
                }

                return response;
            }));
        }
示例#18
0
        /// <summary>
        /// Enviar pedido do cliente Membro
        /// </summary>
        /// <param name="pedidoId"></param>
        /// <param name="situacao">1 envia pedido gerado e 2 Enviar o pedido com os preços cotados </param>
        ///
        public void EnviaEmailPedido(int pedidoId, int situacao, Usuario Usuario)
        {
            Pedido pedido        = _pedidoRep.GetSingle(pedidoId);
            var    usuarioMembro = _usuarioRep.FirstOrDefault(x => x.Id == pedido.UsuarioCriacaoId);
            PedidoEmailViewModel pedidoEmailVm = null;

            if (usuarioMembro.Pessoa.TipoPessoa == TipoPessoa.PessoaJuridica)
            {
                pedidoEmailVm = new PedidoEmailViewModel()
                {
                    Id           = pedido.Id,
                    NomeFantasia = pedido.Membro.Pessoa.PessoaJuridica.NomeFantasia
                };
            }
            else
            {
                pedidoEmailVm = new PedidoEmailViewModel()
                {
                    Id           = pedido.Id,
                    NomeFantasia = pedido.Membro.Pessoa.PessoaFisica.Nome
                };
            }

            switch (situacao)
            {
            //Depois, talvez precisamos mandar no email do cadastro do membro e no email do usuário ou mandar de acordo com a configuração decidida pelo mesmo no menu configurações do membro
            //Situacao 1 é para quando gerar o pedido
            case 1:

                Emails email1 = new Emails()
                {
                    EmailDestinatario = Usuario.UsuarioEmail,
                    CorpoEmail        = _emailService.MontaEmail(pedidoEmailVm, _templateEmailRep.GetSingle(6).Template.Replace("#Grid#", "" + MontaGridItensPedido(pedido.ItemPedidos.ToList()) + "")),
                    AssuntoEmail      = "Confirmação - Número do Pedido " + pedidoId,
                    Status            = Status.NaoEnviado,
                    Origem            = Origem.PedidoMembroGerado,
                    DtCriacao         = DateTime.Now,
                    UsuarioCriacao    = Usuario,
                    Ativo             = true
                };

                _emailsRep.Add(email1);
                _unitOfWork.Commit();

                break;

            //Situacao 2 é para quando atualizar o valor do item do pedido do cliente nesse email iremos pedir para ele aprovar
            case 2:
                Emails email2 = new Emails()
                {
                    EmailDestinatario = Usuario.UsuarioEmail,
                    CorpoEmail        = _emailService.MontaEmail(pedidoEmailVm, _templateEmailRep.GetSingle(6).Template.Replace("#Grid#", "" + MontaGridItensPedido(pedido.ItemPedidos.ToList()) + "")),
                    AssuntoEmail      = "Aprovação de Preço - Número do Pedido " + pedidoId,
                    Status            = Status.NaoEnviado,
                    Origem            = Origem.PedidoMembroAprovado,
                    DtCriacao         = DateTime.Now,
                    UsuarioCriacao    = Usuario,
                    Ativo             = true
                };

                _emailsRep.Add(email2);
                _unitOfWork.Commit();

                break;

            //Situacao 3 é quando o fornecedor aprova um pedido da Cotação
            case 3:
                var fornecedor  = _fornecedorRep.FirstOrDefault(x => x.PessoaId == Usuario.PessoaId);
                var itensPedido = pedido.ItemPedidos.Where(x => x.FornecedorId == fornecedor.Id &&
                                                           x.AprovacaoMembro && x.AprovacaoFornecedor).ToList();

                Emails email3 = new Emails()
                {
                    EmailDestinatario = usuarioMembro.UsuarioEmail,

                    CorpoEmail = _emailService.MontaEmail(pedidoEmailVm, _templateEmailRep.GetSingle(25).Template
                                                          .Replace("#Grid#", MontaGridItensPedido(itensPedido))
                                                          .Replace("#NomeFornecedor#", fornecedor.Pessoa.PessoaJuridica.NomeFantasia)),
                    AssuntoEmail   = "Itens do Pedido Aprovados - Número do Pedido " + pedidoId,
                    Status         = Status.NaoEnviado,
                    Origem         = Origem.PedidoMembroAprovado,
                    DtCriacao      = DateTime.Now,
                    UsuarioCriacao = Usuario,
                    Ativo          = true
                };

                _emailsRep.Add(email3);
                _unitOfWork.Commit();

                break;

            //Situacao 4 é quando o fornecedor aprova o pedido promocional
            case 4:

                var fornecedorPromocao = _fornecedorRep.FirstOrDefault(x => x.PessoaId == Usuario.PessoaId);

                Emails email4 = new Emails()
                {
                    EmailDestinatario = usuarioMembro.UsuarioEmail,

                    CorpoEmail = _emailService.MontaEmail(pedidoEmailVm, _templateEmailRep.GetSingle(26).Template
                                                          .Replace("#Grid#", MontaGridItensPedidoPromocao(pedido))
                                                          .Replace("#NomeFornecedor#", fornecedorPromocao.Pessoa.PessoaJuridica.NomeFantasia)),

                    AssuntoEmail   = "Pedido promocional aprovado - Número do pedido " + pedidoId,
                    Status         = Status.NaoEnviado,
                    Origem         = Origem.PedidoMembroAprovado,
                    DtCriacao      = DateTime.Now,
                    UsuarioCriacao = Usuario,
                    Ativo          = true
                };

                _emailsRep.Add(email4);
                _unitOfWork.Commit();

                break;

            //Envia email quando fornecedor confirma entrega dos itens do pedido.
            case 5:

                var fornecedorEntrega = _fornecedorRep.FirstOrDefault(x => x.PessoaId == Usuario.PessoaId);

                var itensPedidoEntrega = pedido.ItemPedidos.Where(x => x.FornecedorId == fornecedorEntrega.Id &&
                                                                  x.AprovacaoMembro && x.AprovacaoFornecedor).ToList();

                var tipoPedido = pedido.ItemPedidos
                                 .Any(x => x.FornecedorId == fornecedorEntrega.Id &&
                                      x.AprovacaoMembro && x.AprovacaoFornecedor &&
                                      x.Produto.ProdutoPromocionalId == null);


                var nomeMembro = pedido.Membro.Pessoa.TipoPessoa == TipoPessoa.PessoaJuridica ?
                                 pedido.Membro.Pessoa.PessoaJuridica.NomeFantasia :
                                 pedido.Membro.Pessoa.PessoaFisica.Nome;

                var corpoEmail = _templateEmailRep.GetSingle(32).Template
                                 .Replace("#IdPedido#", pedido.Id.ToString())
                                 .Replace("#NomeMembro#", nomeMembro)
                                 .Replace("#NomeFornecedor#", fornecedorEntrega.Pessoa.PessoaJuridica.NomeFantasia)
                                 .Replace("#Grid#", tipoPedido ? MontaGridItensPedido(itensPedidoEntrega)
                                                      : MontaGridItensPedidoPromocao(pedido));

                var email = new Emails
                {
                    UsuarioCriacao    = Usuario,
                    DtCriacao         = DateTime.Now,
                    AssuntoEmail      = "Fornecedor confirmou a entrega dos itens do pedido " + pedido.Id + ".",
                    EmailDestinatario = usuarioMembro.UsuarioEmail,
                    CorpoEmail        = corpoEmail.Trim(),
                    Status            = Status.NaoEnviado,
                    Origem            = Origem.FornecedorConfirmaEntregaPedido,
                    Ativo             = true
                };

                _emailsRep.Add(email);
                _unitOfWork.Commit();

                break;


            //Envia email quando fornecedor despachar dos itens do pedido.
            case 6:

                var fornecedorDespacho = _fornecedorRep.FirstOrDefault(x => x.PessoaId == Usuario.PessoaId);

                var itensPedidoDespacho = pedido.ItemPedidos.Where(x => x.FornecedorId == fornecedorDespacho.Id &&
                                                                   x.AprovacaoMembro && x.AprovacaoFornecedor).ToList();

                var tipoPedidoDespacho = pedido.ItemPedidos
                                         .Any(x => x.FornecedorId == fornecedorDespacho.Id &&
                                              x.AprovacaoMembro && x.AprovacaoFornecedor &&
                                              x.Produto.ProdutoPromocionalId == null);


                var nomeMembroDespacho = pedido.Membro.Pessoa.TipoPessoa == TipoPessoa.PessoaJuridica ?
                                         pedido.Membro.Pessoa.PessoaJuridica.NomeFantasia :
                                         pedido.Membro.Pessoa.PessoaFisica.Nome;

                var corpoEmailDespacho = _templateEmailRep.GetSingle(40).Template
                                         .Replace("#IdPedido#", pedido.Id.ToString())
                                         .Replace("#NomeMembro#", nomeMembroDespacho)
                                         .Replace("#NomeFornecedor#", fornecedorDespacho.Pessoa.PessoaJuridica.NomeFantasia)
                                         .Replace("#Grid#", tipoPedidoDespacho ? MontaGridItensPedido(itensPedidoDespacho)
                                                      : MontaGridItensPedidoPromocao(pedido));

                var emailDespacho = new Emails
                {
                    UsuarioCriacao    = Usuario,
                    DtCriacao         = DateTime.Now,
                    AssuntoEmail      = "Fornecedor Despachou para Entrega itens do seu pedido " + pedido.Id + ".",
                    EmailDestinatario = usuarioMembro.UsuarioEmail,
                    CorpoEmail        = corpoEmailDespacho.Trim(),
                    Status            = Status.NaoEnviado,
                    Origem            = Origem.FornecedorDespachouItensPedido,
                    Ativo             = true
                };

                _emailsRep.Add(emailDespacho);
                _unitOfWork.Commit();
                break;
            }
        }