public void AddAvisos(Avisos pAviso)
        {
            pAviso.UsuarioCriacao   = UsuarioRobo();
            pAviso.UsuarioCriacaoId = pAviso.UsuarioCriacao.Id;
            pAviso.DtCriacao        = DateTime.Now;

            _avisosRep.Add(pAviso);
            _unitOfWork.Commit();
        }
        /// <summary>
        /// Enviar Email
        /// </summary>
        /// <param name="to">Message to address</param>
        /// /// <param name="cc">Message to address</param>
        /// <param name="body">Text of message to send</param>
        /// <param name="subject">Subject line of message</param>
        public void EnviaSms(string numero, string mensagem, TipoOrigemSms?origemSms = null, int?idEntidadeOrigemSms = null)
        {
            try
            {
                var usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);
                var sms     = new Sms
                {
                    Numero           = numero,
                    Mensagem         = mensagem,
                    OrigemSms        = origemSms,
                    IdEntidadeOrigem = idEntidadeOrigemSms,
                    UsuarioCriacao   = usuario,
                    DtCriacao        = DateTime.Now,
                    Ativo            = true,
                    Status           = StatusSms.NaoEnviado
                };

                _smsRep.Add(sms);
                _unitOfWork.Commit();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
        public HttpResponseMessage Inserir(HttpRequestMessage request, FabricanteViewModel fabricanteVM)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                    Fabricante novoFabricante = new Fabricante()
                    {
                        UsuarioCriacao = usuario,
                        DtCriacao = DateTime.Now,
                        DescFabricante = fabricanteVM.DescFabricante,
                        Ativo = fabricanteVM.Ativo
                    };
                    _Fabricante.Add(novoFabricante);

                    _unitOfWork.Commit();

                    // Update view model
                    fabricanteVM = Mapper.Map <Fabricante, FabricanteViewModel>(novoFabricante);
                    response = request.CreateResponse(HttpStatusCode.Created, fabricanteVM);
                }

                return response;
            }));
        }
示例#4
0
        public HttpResponseMessage Inserir(HttpRequestMessage request, workflowStatusViewModel workflowStatusViewModel)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                    WorkflowStatus novoStatus = new WorkflowStatus()
                    {
                        UsuarioCriacao = usuario,
                        DtCriacao = DateTime.Now,
                        DescWorkslowStatus = workflowStatusViewModel.DescWorkslowStatus,
                        Ativo = workflowStatusViewModel.Ativo
                    };
                    _workflowStatus.Add(novoStatus);

                    _unitOfWork.Commit();

                    // Update view model
                    workflowStatusViewModel = Mapper.Map <WorkflowStatus, workflowStatusViewModel>(novoStatus);
                    response = request.CreateResponse(HttpStatusCode.Created, workflowStatusViewModel);
                }

                return response;
            }));
        }
示例#5
0
        public void InserirHistoricoPedido(HistStatusPedido histPedido)
        {
            Usuario usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);

            histPedido.UsuarioCriacao = usuario;

            _histStatusPedidoRep.Add(histPedido);
            _unitOfWork.Commit();
        }
示例#6
0
        public void EmailNotificacaoFornecedor(List <Usuario> fornecedores, int CotacaoId)
        {
            try
            {
                Usuario usuario    = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);
                var     corpoEmail = _templateEmail.FindBy(e => e.Id == 16).Select(e => e.Template).FirstOrDefault();

                if (fornecedores.Count > 0)
                {
                    if (corpoEmail != null)
                    {
                        foreach (var fornecedor in fornecedores)
                        {
                            string corpoEmailFornecedor = corpoEmail.Replace("#IDCotacao#", CotacaoId.ToString());

                            if (_notificacoesAlertasService.PodeEnviarNotificacao(fornecedor.Id, 16, TipoAlerta.EMAIL))
                            {
                                Emails emails = new Emails
                                {
                                    Ativo             = true,
                                    UsuarioCriacao    = usuario,
                                    DtCriacao         = DateTime.Now,
                                    AssuntoEmail      = "Cotação - Você teve o melhor preco na cotação " + CotacaoId + "",
                                    EmailDestinatario = fornecedor.UsuarioEmail,
                                    CorpoEmail        = corpoEmailFornecedor.Trim(),
                                    Status            = Status.NaoEnviado,
                                    Origem            = Origem.MembroSolicitaFornecedor
                                };

                                //Envia EMAIL para fornecedor
                                _emailsNotificaoRep.Add(emails);

                                //Commit
                                _unitOfWork.Commit();
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public HttpResponseMessage EnviarEmailMembro(HttpRequestMessage request, int idMembro)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;



                if (idMembro > 0)
                {
                    var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
                    Membro membroAtual = _membroRep.GetSingle(idMembro);
                    _utilEmailService.MembroInserirUsuarioEnviarEmail(idMembro, usuario.Id);


                    //pega o telefone do primeiro usuario
                    var membroTel = membroAtual.Pessoa.Usuarios.FirstOrDefault();

                    //Inserir SMS de boas vindas
                    Sms sms = new Sms
                    {
                        UsuarioCriacao = usuario,
                        DtCriacao = DateTime.Now,
                        Numero = membroTel.Telefones.Select(t => t.DddCel).FirstOrDefault() + membroTel.Telefones.Select(t => t.Celular).FirstOrDefault(),
                        Mensagem = "Economiza Já - BEM VINDO. Acesse membro.economizaja.com.br a senha são os 8 primeiros digitos do seu CNPJ ou CPF e email, ou siga instruções enviada no email",
                        Status = StatusSms.NaoEnviado,
                        OrigemSms = TipoOrigemSms.PedidoPromocionalPendenteAprovacao,
                        Ativo = true
                    };
                    _smsRep.Add(sms);
                    _unitOfWork.Commit();


                    response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
                }
                else
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest, new { success = false });
                }

                return response;
            }));
        }
示例#8
0
        public void InserirHistoricoCotacao(HistStatusCotacao histCotacao)
        {
            Usuario usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);

            histCotacao.UsuarioCriacao   = usuario;
            histCotacao.UsuarioCriacaoId = usuario.Id;

            _histStatusCotacaoRep.Add(histCotacao);
            _unitOfWork.Commit();
        }
示例#9
0
        public void SmsNotificacaoFornecedor(List <Usuario> fornecedores, int CotacaoId)
        {
            try
            {
                Usuario usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);
                if (fornecedores.Count > 0)
                {
                    foreach (var userFornecedor in fornecedores)
                    {
                        //Verifica os numeros de celulares cadastrados para o usuario.
                        var NumTel = userFornecedor.Pessoa.Telefones.Where(t => t.UsuarioTelId == userFornecedor.Id && !string.IsNullOrEmpty(t.Celular.Trim()));
                        //valida se tem permissão de enviar SMS para usuario
                        if (_notificacoesAlertasService.PodeEnviarNotificacao(userFornecedor.Id, 16, TipoAlerta.SMS) && NumTel != null)
                        {
                            foreach (var itemNumTel in NumTel)
                            {
                                Sms sms = new Sms
                                {
                                    UsuarioCriacao = usuario,
                                    DtCriacao      = DateTime.Now,
                                    Numero         = itemNumTel.DddCel + itemNumTel.Celular,
                                    Mensagem       = "Economiza Já - Cotação. Você teve o melhor preço na cotação " + CotacaoId + ".",
                                    Status         = StatusSms.NaoEnviado,
                                    OrigemSms      = TipoOrigemSms.NovaCotacao,
                                    Ativo          = true
                                };

                                //Envia SMS para fonecedor
                                _smsRep.Add(sms);
                                _unitOfWork.Commit();
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
示例#10
0
        public HttpResponseMessage AtualizarGrupo(HttpRequestMessage request, int UsuarioId, IEnumerable <UsuarioGrupoViewModel> gruposXusuarios)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;



                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest, new { success = false });
                }
                else
                {
                    Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                    var gruposdelete = _usuarioGrupoRep.GetAll().Where(x => x.UsuarioId == UsuarioId);

                    if (gruposdelete.Any())
                    {
                        _usuarioGrupoRep.DeleteAll(gruposdelete);
                        _unitOfWork.Commit();
                    }

                    if (gruposXusuarios.Any())
                    {
                        foreach (UsuarioGrupoViewModel item in gruposXusuarios)
                        {
                            if (item.Selecionado)
                            {
                                var novoUsuarioGrupo = new UsuarioGrupo
                                {
                                    UsuarioId = UsuarioId,
                                    DtCriacao = DateTime.Now,
                                    UsuarioCriacao = usuario,
                                    GrupoId = item.GrupoId
                                };
                                _usuarioGrupoRep.Add(novoUsuarioGrupo);
                                _unitOfWork.Commit();
                            }
                        }
                    }


                    response = request.CreateResponse(HttpStatusCode.OK);
                }

                return response;
            }));
        }
        public void GravaExecucaoRotina(int pTipoAviso, string pNomeRotina)
        {
            Usuario      usuario  = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);
            ExecucaoRobo execRobo = new ExecucaoRobo();

            execRobo.Ativo            = true;
            execRobo.UsuarioCriacaoId = usuario.Id;
            execRobo.DtCriacao        = DateTime.Now;

            execRobo.NomeRotina = pNomeRotina;
            execRobo.TipoAviso  = pTipoAviso;

            _execucaoRoboRep.Add(execRobo);
            this._unitOfWork.Commit();
        }
        public HttpResponseMessage Inserir(HttpRequestMessage request, CategoriaViewModel CategoriaViewModel)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                    var descCategoria =
                        _categoriaRep.GetAll()
                        .Where(c => c.DescCategoria.ToLower() == CategoriaViewModel.DescCategoria.ToLower()).
                        Select(c => c.DescCategoria).FirstOrDefault();

                    if (descCategoria == null)
                    {
                        Categoria novaCategoria = new Categoria()
                        {
                            UsuarioCriacao = usuario,
                            DtCriacao = DateTime.Now,
                            Ativo = CategoriaViewModel.Ativo,
                            DescCategoria = CategoriaViewModel.DescCategoria
                        };

                        _categoriaRep.Add(novaCategoria);

                        _unitOfWork.Commit();
                        // Update view model
                        CategoriaViewModel = Mapper.Map <Categoria, CategoriaViewModel>(novaCategoria);

                        response = request.CreateResponse(HttpStatusCode.Created, CategoriaViewModel);
                    }
                    else
                    {
                        response = request.CreateResponse(HttpStatusCode.NotModified);
                    }
                }

                return response;
            }));
        }
        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;
            }));
        }
示例#14
0
        public void EnviarEmailViaRobo(Usuario pUsu, string pAssuntoEmail, string pEmailDestino, string pCorpoEmail, Origem pOrigrem)
        {
            Emails emails = new Emails
            {
                UsuarioCriacaoId  = pUsu.Id,
                DtCriacao         = DateTime.Now,
                AssuntoEmail      = pAssuntoEmail,
                EmailDestinatario = pEmailDestino,
                CorpoEmail        = pCorpoEmail.Trim(),
                Status            = Status.NaoEnviado,
                Origem            = pOrigrem
            };

            //Envia EMAIL
            _emailsRep.Add(emails);
            _unitOfWork.Commit();
        }
        public HttpResponseMessage Inserir(HttpRequestMessage request, MarcaViewModel marcaVM)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    if (_marcaRep.FindBy(x => x.DescMarca == marcaVM.DescMarca).Any())
                    {
                        ModelState.AddModelError("Marca Existente", "Marca: " + marcaVM.DescMarca + " já existe .");
                        response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                          ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                          .Select(m => m.ErrorMessage).ToArray());
                    }
                    else
                    {
                        Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                        Marca novaMarca = new Marca()
                        {
                            UsuarioCriacao = usuario,
                            DtCriacao = DateTime.Now,
                            DescMarca = marcaVM.DescMarca,
                            Ativo = marcaVM.Ativo
                        };
                        _marcaRep.Add(novaMarca);

                        _unitOfWork.Commit();

                        // Update view model
                        marcaVM = Mapper.Map <Marca, MarcaViewModel>(novaMarca);
                        response = request.CreateResponse(HttpStatusCode.Created, marcaVM);
                    }
                }

                return response;
            }));
        }
示例#16
0
        private void LogError(Exception ex)
        {
            try
            {
                Erro _erro = new Erro()
                {
                    Mensagem = ex.Message,

                    DtCriacao      = DateTime.Now,
                    UsuarioCriacao = _usuarioRepository.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId())),
                    Ativo          = true
                };

                _errosRepository.Add(_erro);
                _unitOfWork.Commit();
            }
            catch { }
        }
        public HttpResponseMessage Inserir(HttpRequestMessage request, EstoqueViewModel estoqueViewModel)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));


                    Estoque novoItemEstoque = new Estoque()
                    {
                        UsuarioCriacao = usuario,
                        DtCriacao = DateTime.Now,
                        ProdutoId = estoqueViewModel.ProdutoId,
                        MembroId = estoqueViewModel.MembroId,
                        EnderecoId = estoqueViewModel.EnderecoId,
                        MinimoEstoque = estoqueViewModel.MinimoEstoque,
                        MaximoEstoque = estoqueViewModel.MaximoEstoque,
                        QtdEstoque = estoqueViewModel.QtdEstoque,
                        QtdEstoqueReceber = estoqueViewModel.QtdEstoqueReceber,
                        Ativo = estoqueViewModel.Ativo
                    };

                    _estoqueRep.Add(novoItemEstoque);

                    _unitOfWork.Commit();

                    // Update view model
                    EstoqueViewModel estoqueVM = Mapper.Map <Estoque, EstoqueViewModel>(novoItemEstoque);

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

                return response;
            }));
        }
        private void LogError(Exception ex)
        {
            try
            {
                var erro = new Erro()
                {
                    Mensagem       = ex.Message,
                    StackTrace     = ex.StackTrace.Replace('\\', ' ').Replace(':', ' ').Replace('/', ' ').Replace('\r', ' ').Replace('\n', ' '),
                    DtCriacao      = DateTime.Now,
                    UsuarioCriacao = _usuarioRepository.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId())),
                    Ativo          = true
                };

                _errosRepository.Add(erro);
                _unitOfWork.Commit();
            }
            catch
            {
            }
        }
示例#19
0
        public HttpResponseMessage Inserir(HttpRequestMessage request, SubCategoriaViewModel SubCategoriaViewModel)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                    SubCategoria novaSubCategoria = new SubCategoria()
                    {
                        UsuarioCriacao = usuario,
                        DtCriacao = DateTime.Now,
                        Ativo = SubCategoriaViewModel.Ativo,
                        DescSubCategoria = SubCategoriaViewModel.DescSubCategoria,
                        CategoriaId = SubCategoriaViewModel.CategoriaId
                    };

                    _subCategoriaRep.Add(novaSubCategoria);

                    _unitOfWork.Commit();

                    //Cria Diretório quando se cadastra um nova subcategoria
                    CriarDiretorioImagens(SubCategoriaViewModel, novaSubCategoria);


                    // Update view model
                    SubCategoriaViewModel = Mapper.Map <SubCategoria, SubCategoriaViewModel>(novaSubCategoria);
                    response = request.CreateResponse(HttpStatusCode.Created, SubCategoriaViewModel);
                }

                return response;
            }));
        }
        public HttpResponseMessage Inserir(HttpRequestMessage request, MembroDemandaViewModel membroDemandaViewModel)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (ModelState.IsValid)
                {
                    Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                    MembroDemanda novoMembroDemanda = new MembroDemanda()
                    {
                        MembroId = membroDemandaViewModel.MembroId,
                        UsuarioCriacao = usuario,
                        DtCriacao = DateTime.Now,
                        PeriodicidadeId = membroDemandaViewModel.PeriodicidadeId,
                        UnidadeMedidaId = membroDemandaViewModel.UnidadeMedidaId,
                        SubCategoriaId = membroDemandaViewModel.SubCategoriaId,
                        Quantidade = membroDemandaViewModel.Quantidade,
                        Observacao = membroDemandaViewModel.Observacao,
                        Ativo = membroDemandaViewModel.Ativo
                    };
                    _membroDemandaRep.Add(novoMembroDemanda);

                    _unitOfWork.Commit();

                    // Update view model
                    membroDemandaViewModel = Mapper.Map <MembroDemanda, MembroDemandaViewModel>(novoMembroDemanda);
                    response = request.CreateResponse(HttpStatusCode.Created, membroDemandaViewModel);
                }
                else
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }

                return response;
            }));
        }
        public HttpResponseMessage Inserir(HttpRequestMessage request, StatusSistemaViewModel statusSistemaViewModel)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                    StatusSistema novoStatusSistema = new StatusSistema()
                    {
                        UsuarioCriacao = usuario,
                        DtCriacao = DateTime.Now,
                        Ativo = statusSistemaViewModel.Ativo,
                        DescStatus = statusSistemaViewModel.DescStatus,
                        Ordem = statusSistemaViewModel.Ordem,
                        WorkflowStatusId = statusSistemaViewModel.WorkflowStatusId
                    };
                    _statusSistema.Add(novoStatusSistema);

                    _unitOfWork.Commit();

                    // Update view model
                    statusSistemaViewModel = Mapper.Map <StatusSistema, StatusSistemaViewModel>(novoStatusSistema);
                    response = request.CreateResponse(HttpStatusCode.Created, statusSistemaViewModel);
                }

                return response;
            }));
        }
示例#22
0
        public void InserirAvisos(Usuario usuario, TipoAviso tipoAviso,
                                  string tituloAviso, string descricaoAviso, string tooltip, string urlDestino,
                                  int modulo, int idReferencia)
        {
            var inserirAvisos = new Avisos
            {
                UsuarioCriacao      = usuario,
                DtCriacao           = DateTime.Now,
                DataUltimoAviso     = DateTime.Now,
                TipoAvisosId        = (int)tipoAviso,
                ExibeNaTelaAvisos   = true,
                TituloAviso         = tituloAviso,
                DescricaoAviso      = descricaoAviso,
                ToolTip             = tooltip,
                URLPaginaDestino    = urlDestino,
                ModuloId            = modulo,
                UsuarioNotificadoId = usuario.Id,
                IdReferencia        = idReferencia,
                Ativo = true
            };

            _avisosRep.Add(inserirAvisos);
            _unitOfWork.Commit();
        }
        public HttpResponseMessage Inserir(HttpRequestMessage request, EnderecoViewModel enderecoViewModel)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (enderecoViewModel.BairroDescNew != null ||
                    enderecoViewModel.BairroDescNew != "")
                {
                    //remove a validação do bairro quase não tenha achado, pois nesse caso vamos cadastro o digitado manualmente
                    ModelState.Remove("enderecoViewModel.BairroId");
                }

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    if (_enderecoRep.VerificaEnderecoJaCadastrado(enderecoViewModel.Cep, enderecoViewModel.PessoaId) > 0)
                    {
                        ModelState.AddModelError("CEP Existente", "CEP:" + enderecoViewModel.Cep + " já existe.");
                        response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                          ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                          .Select(m => m.ErrorMessage).ToArray());
                    }
                    else
                    {
                        Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                        if (!string.IsNullOrEmpty(enderecoViewModel.BairroDescNew))
                        {
                            //var cit = _cidadeRep.GetSingle(fornecedorViewModel.Endereco.CidadeId);
                            Bairro bairroCad = new Bairro()
                            {
                                DescBairro = enderecoViewModel.BairroDescNew,
                                CidadeId = enderecoViewModel.CidadeId,
                                DtCriacao = DateTime.Now,
                                UsuarioCriacao = usuario
                            };

                            _bairroRep.Add(bairroCad);
                            _unitOfWork.Commit();

                            enderecoViewModel.BairroId = bairroCad.Id;
                        }

                        if (_enderecoRep.GetAll().Count(x => x.Pessoa.Id == enderecoViewModel.PessoaId) == 0)
                        {
                            enderecoViewModel.EnderecoPadrao = true;
                        }

                        Endereco novoEndereco = new Endereco()
                        {
                            UsuarioCriacao = usuario,
                            DtCriacao = DateTime.Now,
                            PessoaId = enderecoViewModel.PessoaId,
                            EstadoId = enderecoViewModel.EstadoId,
                            CidadeId = enderecoViewModel.CidadeId,
                            BairroId = enderecoViewModel.BairroId,
                            LogradouroId = enderecoViewModel.LogradouroId,
                            Numero = enderecoViewModel.NumEndereco,
                            Complemento = enderecoViewModel.Complemento,
                            DescEndereco = enderecoViewModel.Endereco.Trim(),
                            Cep = enderecoViewModel.Cep,
                            Ativo = enderecoViewModel.Ativo,
                            EnderecoPadrao = enderecoViewModel.EnderecoPadrao,
                            Referencia = enderecoViewModel.Referencia
                        };

                        novoEndereco.LocalizacaoGoogle();

                        _enderecoRep.Add(novoEndereco);

                        _unitOfWork.Commit();

                        foreach (var itemPeriodo in enderecoViewModel.PeriodoEntrega)
                        {
                            HorasEntregaMembro horarioEntrega = new HorasEntregaMembro()
                            {
                                UsuarioCriacao = usuario,
                                DtCriacao = DateTime.Now,
                                PeriodoId = itemPeriodo.Id,
                                EnderecoId = novoEndereco.Id,
                                DescHorarioEntrega = enderecoViewModel.DescHorarioEntrega
                            };

                            _horarioEntregaMembroRep.Add(horarioEntrega);
                        }

                        _unitOfWork.Commit();


                        Membro membroAtual = _membroRep.FindBy(p => p.PessoaId == enderecoViewModel.PessoaId).FirstOrDefault();


                        // Update view model
                        enderecoViewModel = Mapper.Map <Endereco, EnderecoViewModel>(novoEndereco);
                        response = request.CreateResponse(HttpStatusCode.Created, enderecoViewModel);
                    }
                }

                return response;
            }));
        }
        public List <CotacaoUsuarios> PrecificarCotacaoFornecedor()
        {
            // Verificar se existe fatura em atraso, para não precificar para este fornecedor
            List <KeyValuePair <int, DateTime> > listCotacaoId = new List <KeyValuePair <int, DateTime> >();
            List <int> categoriasFornecedores = new List <int>();

            var fornecedores = _fornecedorProdutoRep.GetAll()
                               .Where(x => x.Fornecedor.Ativo && x.Ativo)
                               .Select(f => f.Fornecedor).Distinct().ToList();

            fornecedores.ForEach(f =>
            {
                listCotacaoId.Clear();
                categoriasFornecedores.Clear();

                var membrosForn = _membroFornecedor.GetAll()
                                  .Where(m => m.FornecedorId == f.Id && m.Ativo)
                                  .Select(o => o.Membro.Id)
                                  .ToList();

                var indispProdutoFornecedor = _indisponibilidadeProdutoRep.GetAll()
                                              .Where(i => i.FornecedorId == f.Id &&
                                                     i.InicioIndisponibilidade <= DateTime.Now &&
                                                     i.FimIndisponibilidade >= DateTime.Now)
                                              .Select(c => c.Produto.Id).ToList();


                var resultCotacao = _resultadoCotacao.GetAll()
                                    .Where(x => x.Cotacao.DtFechamento >= DateTime.Now && x.FornecedorId == f.Id)
                                    .Select(c => c.CotacaoId)
                                    .ToList();

                var fornecedorCategorias = f.FornecedorCategorias.Select(x => x.CategoriaId).ToList();


                //pega todos os pedido da tabela remover fornecedor que estaja na cotação = ProdutoId
                var itemPedidos = _cotacaoPedidos.GetAll()
                                  .Where(x => !resultCotacao.Contains(x.CotacaoId) &&
                                         x.Cotacao.DtFechamento >= DateTime.Now)
                                  .SelectMany(i => i.Pedido.ItemPedidos
                                              .Where(r => !indispProdutoFornecedor.Contains(r.ProdutoId) &&
                                                     fornecedorCategorias.Contains(r.Produto.SubCategoria.CategoriaId))
                                              .Select(p => p.Id))
                                  .ToList();

                // Verifica se o fornecedor foi removido para dar preço no item
                var intensPedidoRemoveItemForn = _removeFornPedidoRep
                                                 .FindBy(x => x.FonecedorId == f.Id && itemPedidos.Contains(x.ItemPedidoId))
                                                 .Select(p => p.ItemPedidoId)
                                                 .ToList();

                var cotacaoPedidos = _cotacaoPedidos.GetAll()
                                     .Where(x => !resultCotacao.Contains(x.CotacaoId) &&
                                            membrosForn.Contains(x.Pedido.Membro.Id) &&
                                            x.Cotacao.DtFechamento >= DateTime.Now &&
                                            x.Pedido.ItemPedidos.Any(p => !intensPedidoRemoveItemForn.Contains(p.Id) &&
                                                                     fornecedorCategorias.Contains(p.Produto.SubCategoria.CategoriaId)))
                                     .GroupBy(g => g.CotacaoId)
                                     .ToList();

                for (int i = 0; i < cotacaoPedidos.Count; i++)
                {
                    var pedidos = cotacaoPedidos[i].Select(x => x.Pedido).ToList();

                    var prod = f.Produtos.Select(x => x.ProdutoId).ToList();

                    var itensCotacao = cotacaoPedidos[i].SelectMany(x => x.Pedido.ItemPedidos.Where(p => prod.Contains(p.ProdutoId)))
                                       .Select(c => new { c.ProdutoId, c.Quantidade })
                                       .GroupBy(s => s.ProdutoId)
                                       .Select(p => new { ProdutoId = p.Key, Quantidade = p.Sum(t => t.Quantidade) })
                                       .ToList();

                    itensCotacao.ForEach(z =>
                    {
                        var categoria = f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId).Produto.SubCategoria.CategoriaId;

                        var existeProduto = f.Produtos.Count(x => x.ProdutoId == z.ProdutoId) > 0;

                        var existeProdutosFornecedor = f.Produtos.Count(x => x.ProdutoId == z.ProdutoId) > 0 &&
                                                       f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId).ListaQuantidadeDesconto
                                                       .Count(p => p.ValidadeQtdDesconto >= DateTime.Now && p.QuantidadeMinima <= z.Quantidade) > 0;

                        if (existeProduto)
                        {
                            var resultadoCotacao = new ResultadoCotacao();

                            resultadoCotacao.UsuarioCriacao = f.UsuarioCriacao;
                            resultadoCotacao.DtCriacao      = DateTime.Now;
                            resultadoCotacao.Ativo          = true;
                            resultadoCotacao.FornecedorId   = f.Id;
                            //resultadoCotacao.Observacao = "Precificação automática";
                            resultadoCotacao.CotacaoId          = cotacaoPedidos[i].FirstOrDefault().CotacaoId;
                            resultadoCotacao.ProdutoId          = z.ProdutoId;
                            resultadoCotacao.PrecoNegociadoUnit = !f.Produtos.Any() ? 0 :
                                                                  existeProdutosFornecedor
                                ?
                                                                  Math.Round((f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId).Valor -
                                                                              (f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId)
                                                                               .ListaQuantidadeDesconto.Where(w => w.QuantidadeMinima <= z.Quantidade).OrderByDescending(ob
                                                                                                                                                                         =>
                                                                                                                                                                         ob.QuantidadeMinima).FirstOrDefault().PercentualDesconto *
                                                                               f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId).Valor
                                                                              ) / 100), 2)
                                :
                                                                  f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId).Valor;

                            resultadoCotacao.Qtd = z.Quantidade;

                            _resultadoCotacao.Add(resultadoCotacao);


                            if (!listCotacaoId.Select(x => x.Key).Contains(resultadoCotacao.CotacaoId))
                            {
                                listCotacaoId.Add(new KeyValuePair <int, DateTime>(resultadoCotacao.CotacaoId, cotacaoPedidos[i].FirstOrDefault().Cotacao.DtFechamento));
                            }

                            if (!categoriasFornecedores.Contains(categoria))
                            {
                                categoriasFornecedores.Add(categoria);
                            }
                        }
                    });


                    Emails emailPrecificacao = new Emails()
                    {
                        EmailDestinatario = f.Pessoa.Usuarios.FirstOrDefault().UsuarioEmail,
                        CorpoEmail        = _templateEmail.GetSingle(34).Template.Replace("#CotacaoId#", cotacaoPedidos[i].FirstOrDefault().CotacaoId.ToString()),
                        AssuntoEmail      = $"Cotação {cotacaoPedidos[i].FirstOrDefault().CotacaoId} respondida automaticamente.",
                        Status            = Status.NaoEnviado,
                        Origem            = Origem.PrecificacaoAutomaticaCotacaoFornecedor,
                        DtCriacao         = DateTime.Now,
                        UsuarioCriacao    = f.Pessoa.Usuarios.FirstOrDefault(),
                        Ativo             = true
                    };

                    _emailsRep.Add(emailPrecificacao);

                    _unitOfWork.Commit();
                }
            });

            var listCotacaoUsuarios = new List <CotacaoUsuarios>();
            var fornecedor          = this._fornecedoRep.FindBy(x => x.FornecedorCategorias.Any(y => categoriasFornecedores.Contains(y.CategoriaId))).Select(x => x.PessoaId).ToList();
            var usuarios            = this._usuarioRep.FindBy(x => fornecedor.Contains(x.PessoaId) && !string.IsNullOrEmpty(x.TokenSignalR)).ToList();

            if (listCotacaoId.Count > 0 && usuarios.Count > 0)
            {
                listCotacaoId.ForEach(x =>
                {
                    usuarios.ForEach(u =>
                    {
                        var cotacaoGroup = CotacaoProdsGroup(u.Id, (int)x.Key);

                        listCotacaoUsuarios.Add(new CotacaoUsuarios
                        {
                            CotacaoId             = x.Key,
                            TokenUsuario          = u.TokenSignalR,
                            CotacaoGrupo          = cotacaoGroup,
                            DataFechamentoCotacao = x.Value
                        });
                    });
                });
            }

            return(listCotacaoUsuarios);
        }
        public Usuario CreateUser(string nome,
                                  string email,
                                  string senha,
                                  int perfilId,
                                  int pessoaId,
                                  int usuarioCriacaoId,
                                  bool flgMaster,
                                  string DddTelComl   = null,
                                  string TelefoneComl = null,
                                  string DddCel       = null,
                                  string Celular      = null,
                                  string Contato      = null)
        {
            var existingUser = _usuarioRep.GetSingleByEmail(email, perfilId);

            if (existingUser != null)
            {
                throw new Exception("E-mail já cadastrado!");
            }

            var senhaChave = _encryptionService.CriaChave();


            var usuario = new Usuario()
            {
                UsuarioNome      = nome,
                Chave            = senhaChave,
                UsuarioEmail     = email,
                Ativo            = true,
                Senha            = _encryptionService.EncryptSenha(senha, senhaChave),
                DtCriacao        = DateTime.Now,
                UsuarioCriacaoId = usuarioCriacaoId,
                PessoaId         = pessoaId,
                PerfilId         = perfilId,
                FlgMaster        = flgMaster
            };

            _usuarioRep.Add(usuario);
            _unitOfWork.Commit();

            //usuario.Senha = senha;

            var telefone = new Telefone
            {
                UsuarioCriacao = usuario,
                DtCriacao      = DateTime.Now,
                DddTelComl     = DddTelComl,
                TelefoneComl   = TelefoneComl,
                DddCel         = DddCel,
                Celular        = Celular,
                Ativo          = true,
                Contato        = Contato,
                UsuarioTel     = usuario,
                PessoaId       = usuario.PessoaId
            };

            _telefoneRep.Add(telefone);
            _unitOfWork.Commit();


            return(usuario);
        }
 public void CreateRecuperaSenha(RecuperaSenha objRecuperaSenha)
 {
     _recuperaSehnaRep.Add(objRecuperaSenha);
     _unitOfWork.Commit();
 }
示例#27
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;
            }
        }
        public List <Usuario> EnviarEmailSmsFornecedorAceitarMembro()
        {
            var usuarios = new List <Usuario>();

            var membrosFornecedores = _membroFornecedorRep.FindBy(x => !x.Ativo).ToList();

            membrosFornecedores.ForEach(x =>
            {
                var nomeMembro = string.Empty;

                if (x.Membro.Pessoa.TipoPessoa == TipoPessoa.PessoaFisica)
                {
                    nomeMembro = x.Membro.Pessoa.PessoaFisica.Nome;
                }
                else
                {
                    nomeMembro = x.Membro.Pessoa.PessoaJuridica.NomeFantasia;
                }

                x.Fornecedor.Pessoa.Usuarios.ToList().ForEach(u =>
                {
                    if (PodeEnviarNotificacao(u.Id, (int)TipoAviso.NovoFornecedorAvisoMembro, TipoAlerta.EMAIL))
                    {
                        Emails email1 = new Emails()
                        {
                            EmailDestinatario = u.UsuarioEmail,

                            CorpoEmail = this.GetCorpoEmail(36)
                                         .Replace("#NomeFornecedor#", x.Fornecedor.Pessoa.PessoaJuridica.NomeFantasia)
                                         .Replace("#Membro#", nomeMembro),

                            AssuntoEmail   = "Solicitação de membro pendente de aceite",
                            Status         = Status.NaoEnviado,
                            Origem         = Origem.LembreteFornecedorAceiteMembro,
                            DtCriacao      = DateTime.Now,
                            UsuarioCriacao = u,
                            Ativo          = true
                        };

                        _emailsRep.Add(email1);
                    }

                    if (PodeEnviarNotificacao(u.Id, (int)TipoAviso.NovoFornecedorAvisoMembro, TipoAlerta.SMS))
                    {
                        var sms = new Sms
                        {
                            UsuarioCriacao = u,
                            DtCriacao      = DateTime.Now,
                            Numero         = u.Telefones.Select(t => t.DddCel).FirstOrDefault() + u.Telefones.Select(t => t.Celular).FirstOrDefault(),
                            Mensagem       = $"Economiza Já - Membro {nomeMembro} - Está querendo comprar com você. Corra para aceitar e comece a fazer novos negocios.",
                            Status         = StatusSms.NaoEnviado,
                            OrigemSms      = TipoOrigemSms.LembreteFornecedorAceiteMembro,
                            Ativo          = true
                        };

                        _smsRep.Add(sms);
                    }

                    usuarios.Add(u);
                    _unitOfWork.Commit();
                });
            });

            return(usuarios);
        }
示例#29
0
        public HttpResponseMessage Inserir(HttpRequestMessage request, InserirListaComprasViewModel listaCompras)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                if (_listaComprasRep.FindBy(x => x.NomeLista == listaCompras.NomeLista && x.Ativo && x.UsuarioCriacaoId == usuario.Id).Any())
                {
                    ModelState.AddModelError("Lista já Existente", "Lista: " + listaCompras.NomeLista + " já existe .");
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                      ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                      .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    var membro = _membroRep.GetAll().FirstOrDefault(x => x.PessoaId == usuario.PessoaId);

                    var lista = new ListaCompras
                    {
                        NomeLista = listaCompras.NomeLista,
                        UsuarioCriacao = usuario,
                        DtCriacao = DateTime.Now,
                        Ativo = true
                    };
                    _listaComprasRep.Add(lista);


                    foreach (var item in listaCompras.ListaCompras)
                    {
                        var itemLista = new ListaComprasItem
                        {
                            UsuarioCriacao = usuario,
                            DtCriacao = DateTime.Now,
                            Quantidade = item.quantity,
                            ProdutoId = item.sku,
                            Ativo = true,
                            FlgOutraMarca = item.flgOutraMarca,
                            QtdForne = item.qtdForn
                        };

                        lista.ListaComprasItens.Add(itemLista);
                    }

                    _unitOfWork.Commit();

                    foreach (var item in listaCompras.RemFornPedCot)
                    {
                        var removeFornLista = new ListaComprasRemoveForn
                        {
                            UsuarioCriacao = usuario,
                            DtCriacao = DateTime.Now,
                            FonecedorId = item.forn,
                            ProdutoId = item.prd,
                            ListaComprasId = lista.Id,
                            Ativo = true
                        };

                        _listaComprasRemoveFornRep.Add(removeFornLista);
                    }


                    _unitOfWork.Commit();
                    response = request.CreateResponse(HttpStatusCode.OK);
                }

                return response;
            }));
        }
        public CepEndereco PesquisaCep(string cep)
        {
            var cepEndereco = new CepEndereco();
            var cepService  = new AtendeClienteService();
            var result      = cepService.consultaCEP(cep);

            var usuario = _usuarioRep.GetSingle(1);

            if (result == null)
            {
                return(cepEndereco);
            }

            //Pega o id do estado.
            var estado = _estadoRep.GetAll().FirstOrDefault(x => x.Uf == result.uf);

            //Se não existir o estado, cadastrar
            if (estado == null)
            {
                estado = new Estado
                {
                    Ativo          = true,
                    DtCriacao      = DateTime.Now,
                    UsuarioCriacao = usuario,
                    Uf             = result.uf,
                    DescEstado     = result.uf
                };

                //Cadastrando a cidade.
                _estadoRep.Add(estado);
                _unitOfWork.Commit();
            }

            cepEndereco.Estado   = estado;
            cepEndereco.EstadoId = estado.Id;

            //Pega o id da cidade.
            var cidade = _cidadeRep.GetAll().FirstOrDefault(x => x.EstadoId == cepEndereco.EstadoId && x.DescCidade.Trim() == result.cidade.Trim());

            // Se não existir a cidade, cadastramos.
            if (cidade == null)
            {
                cidade = new Cidade
                {
                    Ativo          = true,
                    RegiaoId       = 0, //TODO: Revisitar vai gravar zero pq a cidade é do correio e nao esta cadastrado portanto nao tem o id regiao ainda
                    EstadoId       = cepEndereco.EstadoId,
                    DescCidade     = result.cidade,
                    DtCriacao      = DateTime.Now,
                    UsuarioCriacao = usuario
                };

                //Cadastrando a cidade.
                _cidadeRep.Add(cidade);
                _unitOfWork.Commit();
            }

            cepEndereco.Cidade   = cidade;
            cepEndereco.CidadeId = cidade.Id;

            //Pega o id do bairro.
            var bairro = _bairroRep.GetAll().FirstOrDefault(x => x.CidadeId == cepEndereco.CidadeId && x.DescBairro.Trim() == result.bairro.Trim());

            // Se não existir o bairro, cadastramos.
            if (bairro == null)
            {
                if (result.bairro != "")
                {
                    bairro = new Bairro
                    {
                        Ativo    = true,
                        CidadeId = cepEndereco.CidadeId,
                        //Cidade = cepEndereco.Cidade,
                        DescBairro     = result.bairro,
                        DtCriacao      = DateTime.Now,
                        UsuarioCriacao = usuario
                    };

                    //Cadastrando a cidade.
                    _bairroRep.Add(bairro);
                    _unitOfWork.Commit();
                }
            }

            var lograCc = result.end.Split(' ')[0];

            var logradouro = _logradouroRep.GetAll();
            var lograPesq  = logradouro.FirstOrDefault(x => x.DescLogradouro.Trim() == lograCc.Trim());

            logradouro.ForEach(x => { result.end = result.end.Replace(x.DescLogradouro, ""); });
            result.end = result.end.Trim();

            if (bairro != null && result.end != "" && result.cep != "" && lograPesq != null)
            {
                //Preenche o restante dos dados e cadastramos o endereço.
                //cepEndereco.Bairro = bairro;
                cepEndereco.BairroId       = bairro.Id;
                cepEndereco.LogradouroId   = lograPesq.Id;
                cepEndereco.Cep            = result.cep;
                cepEndereco.DescLogradouro = result.end;
                cepEndereco.Complemento    = !string.IsNullOrEmpty(cepEndereco.Complemento)
                    ? result.complemento
                    : result.complemento2;
                cepEndereco.DtCriacao      = DateTime.Now;
                cepEndereco.UsuarioCriacao = usuario;

                _cepEnderecoRep.Add(cepEndereco);
                _unitOfWork.Commit();
            }

            return(cepEndereco);
        }