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;
            }));
        }
示例#2
0
        public HttpResponseMessage Get(HttpRequestMessage request, int?page, int?pageSize, string filter = null)
        {
            int currentPage     = page.Value;
            int currentPageSize = pageSize.Value;

            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                List <Usuario> usuarioAdm = null;
                int totalUsuarioAdm = new int();

                if (!string.IsNullOrEmpty(filter))
                {
                    filter = filter.Trim().ToLower();

                    usuarioAdm = _usuarioRep.FindBy(c => c.UsuarioNome.ToLower().Contains(filter) && c.PerfilId == 1)
                                 .OrderBy(c => c.UsuarioNome)
                                 .Skip(currentPage * currentPageSize)
                                 .Take(currentPageSize)
                                 .ToList();

                    totalUsuarioAdm = _usuarioRep
                                      .GetAll().Where(c => c.PerfilId == 1)
                                      .Count(c => c.UsuarioNome.ToLower().Contains(filter));
                }
                else
                {
                    usuarioAdm = _usuarioRep.GetAll().Where(c => c.PerfilId == 1)
                                 .OrderBy(c => c.UsuarioNome)
                                 .Skip(currentPage * currentPageSize)
                                 .Take(currentPageSize)
                                 .ToList();

                    totalUsuarioAdm = _usuarioRep.GetAll().Count(c => c.PerfilId == 1);
                }

                IEnumerable <UsuarioViewModel> usuarioVM = Mapper.Map <IEnumerable <Usuario>, IEnumerable <UsuarioViewModel> >(usuarioAdm);

                PaginacaoConfig <UsuarioViewModel> pagSet = new PaginacaoConfig <UsuarioViewModel>()
                {
                    Page = currentPage,
                    TotalCount = totalUsuarioAdm,
                    TotalPages = (int)Math.Ceiling((decimal)totalUsuarioAdm / currentPageSize),
                    Items = usuarioVM
                };

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

                return response;
            }));
        }
示例#3
0
        public HttpResponseMessage Get(HttpRequestMessage request, int?page, int?pageSize, string filter = null)
        {
            int currentPage     = page.Value;
            int currentPageSize = pageSize.Value;

            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                List <UnidadeMedida> unidadeMedidas = null;
                int totalUnidadeMedida = new int();

                if (!string.IsNullOrEmpty(filter))
                {
                    filter = filter.Trim().ToLower();

                    unidadeMedidas = _unidadeMedidaRep.FindBy(c => c.DescUnidadeMedida.ToLower().Contains(filter))
                                     .OrderBy(c => c.DescUnidadeMedida)
                                     .Skip(currentPage * currentPageSize)
                                     .Take(currentPageSize)
                                     .ToList();

                    totalUnidadeMedida = _unidadeMedidaRep
                                         .GetAll()
                                         .Count(c => c.DescUnidadeMedida.ToLower().Contains(filter));
                }
                else
                {
                    unidadeMedidas = _unidadeMedidaRep.GetAll()
                                     .OrderBy(c => c.DescUnidadeMedida)
                                     .Skip(currentPage * currentPageSize)
                                     .Take(currentPageSize)
                                     .ToList();

                    totalUnidadeMedida = _unidadeMedidaRep.GetAll().Count();
                }

                IEnumerable <UnidadeMedidaViewModel> unidadeMedidasVM = Mapper.Map <IEnumerable <UnidadeMedida>, IEnumerable <UnidadeMedidaViewModel> >(unidadeMedidas);

                PaginacaoConfig <UnidadeMedidaViewModel> pagSet = new PaginacaoConfig <UnidadeMedidaViewModel>()
                {
                    Page = currentPage,
                    TotalCount = totalUnidadeMedida,
                    TotalPages = (int)Math.Ceiling((decimal)totalUnidadeMedida / currentPageSize),
                    Items = unidadeMedidasVM
                };

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

                return response;
            }));
        }
示例#4
0
        public StatusSistema BuscaStatusSistema(int pWorkflowStatusId, int pOrdem)
        {
            StatusSistema retStatusSis;

            retStatusSis = _statusSistemaRep.FindBy(ss => ss.WorkflowStatusId == pWorkflowStatusId && ss.Ordem == pOrdem).FirstOrDefault();
            return(retStatusSis);
        }
        public HttpResponseMessage GetMembro(HttpRequestMessage request)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

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

                Membro membro = _membroRep.FindBy(m => m.PessoaId == usuario.Pessoa.Id).FirstOrDefault();

                MembroViewModel estoqueVM = Mapper.Map <Membro, MembroViewModel>(membro);
                response = request.CreateResponse(HttpStatusCode.OK, estoqueVM);

                return response;
            }));
        }
        public HttpResponseMessage CancelarPlanoMembro(HttpRequestMessage request, int?mensalidadeId)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response;
                bool cancelouPlano = false;

                var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
                Membro membro = _membroRep.FindBy(m => m.Pessoa.Id == usuario.Pessoa.Id).FirstOrDefault();


                if (mensalidadeId != null && mensalidadeId.Value > 0)
                {
                    cancelouPlano = _pagamentoService.CancelarPlano(mensalidadeId.Value);
                }

                if (mensalidadeId.Value == 0)
                {
                    var mensalidade = _mensalidadeRep.FindBy(x => x.MembroId == membro.Id && x.Status == StatusMensalidade.Recebido)
                                      .OrderByDescending(o => o.Id).FirstOrDefault();

                    cancelouPlano = _pagamentoService.CancelarPlano(mensalidade.Id);
                }

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


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

                var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
                var membro = _membroRep.All.FirstOrDefault(x => x.PessoaId == usuario.PessoaId);
                var segmentoMembroId = membro.MembroCategorias.SelectMany(x => x.Categoria.SegmentosCategoria).FirstOrDefault().SegmentoId;
                var listaPlanosMensalidadesId = _planoSegmentoRep.FindBy(x => x.SegmentoId == segmentoMembroId && x.Ativo).Select(x => x.PlanoMensalidadeId).ToList();
                var planosMensalidade = _planosMensalidadeRep.FindBy(x => listaPlanosMensalidadesId.Contains(x.Id) && x.Ativo).ToList();

                var planoMensalidadeVM = new List <PlanoMensalidadeViewModel>();

                planosMensalidade.ForEach(x =>
                {
                    planoMensalidadeVM.Add(new PlanoMensalidadeViewModel
                    {
                        Id = x.Id,
                        Descricao = x.Descricao,
                        QtdMeses = x.QtdMeses,
                        Valor = x.Valor,
                        Ativo = x.Ativo
                    });
                });

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

                return response;
            }));
        }
示例#8
0
        public List <Fornecedor> ListaFornecedoresPorMembro(int MembroID)
        {
            List <Fornecedor> retFornecedor = new List <Fornecedor>();
            var mfor = _membroFornecedorRep.FindBy(mf => mf.MembroId == MembroID);

            retFornecedor = mfor.Select(mf => mf.Fornecedor).ToList();
            return(retFornecedor);
        }
        /// <summary>
        /// Remove os avisos do Fornecedor referente a Cotação.
        /// </summary>
        /// <param name="pessoaId">Passar o ID da Pessoa</param>
        /// <param name="cotacaoId">Passar o ID da Cotação</param>
        /// <param name="tipoAviso">Passar o ID de tipo do Aviso, pode estar no Enum TipoAviso ou senão terá que acessar o banco para saber o ID necessário</param>
        public void RemoverAvisoUsuarioFornecedorCotacao(int pessoaId, int cotacaoId, int tipoAviso)
        {
            var usuarios = _usuarioRep.FindBy(u => u.PessoaId == pessoaId).ToList();

            foreach (var usuario in usuarios)
            {
                var aviso = this._avisosRep.FirstOrDefault(x => x.UsuarioNotificadoId == usuario.Id && x.IdReferencia == cotacaoId && x.TipoAvisosId == tipoAviso);
                if (aviso == null)
                {
                    continue;
                }

                this._avisosRep.Delete(aviso);
            }

            this._unitOfWork.Commit();
        }
示例#10
0
        public Fornecedor BuscaFornecedorById(int FornedecorId)
        {
            Fornecedor retFornecedor = new Fornecedor();
            var        fornec        = _FornecedorRep.FindBy(f => f.Id == FornedecorId);

            retFornecedor = fornec.FirstOrDefault();
            return(retFornecedor);
        }
示例#11
0
        public HttpResponseMessage GetCartaoCredito(HttpRequestMessage request, int cartaoId)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                var cartao = new List <CartaoCredito>();
                var cartaoCreditoVM = new List <CartaoCreditoViewModel>();

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

                var membro = this._membroRep.GetAll().FirstOrDefault(x => x.PessoaId.Equals(usuario.PessoaId));

                if (cartaoId > 0)
                {
                    cartao = _cartaoCreditoRep.FindBy(x => x.Id == cartaoId && x.MembroId == membro.Id && x.Ativo).ToList();
                }
                else
                {
                    cartao = _cartaoCreditoRep.FindBy(x => x.MembroId == membro.Id && x.Ativo).ToList();
                }

                cartao.ForEach(x =>
                {
                    cartaoCreditoVM.Add(new CartaoCreditoViewModel
                    {
                        Id = x.Id,
                        Nome = x.Nome,
                        Numero = x.Numero,
                        DataVencimento = x.DataVencimento.ToString("MM/yyyy"),
                        DescricaoCartaoBandeira = x.CartaoBandeira.Descricao,
                        //Cvv = x.Cvv,
                        Padrao = x.Padrao,
                        Ativo = x.Ativo
                    });
                });

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

                return response;
            }));
        }
示例#12
0
        public HttpResponseMessage GetSubCategoriaPaginacao(HttpRequestMessage request, int?page, int?pageSize, string filter = null)
        {
            int currentPage     = page.Value;
            int currentPageSize = pageSize.Value;

            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                List <SubCategoria> subCategorias = null;
                int totalSubCategorias = new int();

                if (!string.IsNullOrEmpty(filter))
                {
                    filter = filter.Trim().ToLower();

                    subCategorias = _subCategoriaRep.FindBy(c => c.DescSubCategoria.ToLower().Contains(filter) ||
                                                            c.Ativo.ToString() == filter || c.Categoria.DescCategoria.ToLower().Contains(filter) || c.Id.ToString() == filter)
                                    .OrderBy(c => c.Categoria.DescCategoria)
                                    .Skip(currentPage * currentPageSize)
                                    .Take(currentPageSize)
                                    .ToList();

                    totalSubCategorias = _subCategoriaRep
                                         .GetAll()
                                         .Count(c => c.DescSubCategoria.ToLower().Contains(filter));
                }
                else
                {
                    subCategorias = _subCategoriaRep.GetAll()
                                    .OrderBy(c => c.DescSubCategoria)
                                    .Skip(currentPage * currentPageSize)
                                    .Take(currentPageSize)
                                    .ToList();

                    totalSubCategorias = _subCategoriaRep.GetAll().Count();
                }

                IEnumerable <SubCategoriaViewModel> subCategoriasVM = Mapper.Map <IEnumerable <SubCategoria>, IEnumerable <SubCategoriaViewModel> >(subCategorias);

                PaginacaoConfig <SubCategoriaViewModel> pagSet = new PaginacaoConfig <SubCategoriaViewModel>()
                {
                    Page = currentPage,
                    TotalCount = totalSubCategorias,
                    TotalPages = (int)Math.Ceiling((decimal)totalSubCategorias / currentPageSize),
                    Items = subCategoriasVM
                };

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

                return response;
            }));
        }
        public HttpResponseMessage Get(HttpRequestMessage request, int?page, int?pageSize, string filter = null)
        {
            int currentPage     = page.Value;
            int currentPageSize = pageSize.Value;

            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                List <Fabricante> fabricante = null;
                int totalFabricante = new int();

                if (!string.IsNullOrEmpty(filter))
                {
                    filter = filter.Trim().ToLower();

                    fabricante = _Fabricante.FindBy(c => c.DescFabricante.ToLower().Contains(filter))
                                 .OrderBy(c => c.DescFabricante)
                                 .Skip(currentPage * currentPageSize)
                                 .Take(currentPageSize)
                                 .ToList();

                    totalFabricante = _Fabricante
                                      .GetAll()
                                      .Count(c => c.DescFabricante.ToLower().Contains(filter));
                }
                else
                {
                    fabricante = _Fabricante.GetAll()
                                 .OrderBy(c => c.DescFabricante)
                                 .Skip(currentPage * currentPageSize)
                                 .Take(currentPageSize)
                                 .ToList();

                    totalFabricante = _Fabricante.GetAll().Count();
                }

                IEnumerable <FabricanteViewModel> fabricanteVM = Mapper.Map <IEnumerable <Fabricante>, IEnumerable <FabricanteViewModel> >(fabricante);

                PaginacaoConfig <FabricanteViewModel> pagSet = new PaginacaoConfig <FabricanteViewModel>()
                {
                    Page = currentPage,
                    TotalCount = totalFabricante,
                    TotalPages = (int)Math.Ceiling((decimal)totalFabricante / currentPageSize),
                    Items = fabricanteVM
                };

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

                return response;
            }));
        }
        public HttpResponseMessage GetByCategoriaId(HttpRequestMessage request, int?page, int?pageSize, int membroId)
        {
            int currentPage     = page.Value;
            int currentPageSize = pageSize.Value;

            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                List <MembroDemanda> demandas = null;
                int totalMembros = new int();

                if (membroId != 0)
                {
                    demandas = _membroDemandaRep.FindBy(c => c.MembroId.Equals(membroId))
                               .OrderBy(c => c.SubCategoria.DescSubCategoria)
                               .Skip(currentPage * currentPageSize)
                               .Take(currentPageSize)
                               .ToList();

                    totalMembros = _membroDemandaRep
                                   .GetAll()
                                   .Count(c => c.MembroId.Equals(membroId));
                }
                //else
                //{
                //    demandas = _membroDemandaRep.GetAll()
                //        .OrderBy(c => c.SubCategoria.DescSubCategoria)
                //        .Skip(currentPage * currentPageSize)
                //        .Take(currentPageSize)
                //    .ToList();

                //    totalMembros = _membroRep.GetAll().Count();
                //}

                IEnumerable <MembroDemandaViewModel> membroDemandasVM = Mapper.Map <IEnumerable <MembroDemanda>, IEnumerable <MembroDemandaViewModel> >(demandas);

                var pagSet = new PaginacaoConfig <MembroDemandaViewModel>()
                {
                    Page = currentPage,
                    TotalCount = totalMembros,
                    TotalPages = (int)Math.Ceiling((decimal)totalMembros / currentPageSize),
                    Items = membroDemandasVM
                };

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

                return response;
            }));
        }
        public HttpResponseMessage GetCarregaRegiaoPrazo(HttpRequestMessage request, int?idFornecedor)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                var cidades = new List <int>();

                // var fornecedor = _fornecedorRep.FirstOrDefault(x => x.Id == idFornecedor);

                var regiaoPrazoFornecedor = _fornecedorRegiaoRep.FindBy(x => x.Fornecedor.Id == idFornecedor).Select(x => new { x.Id, x.FornecedorId, x.CidadeId, x.Prazo, x.Cidade.DescCidade }).ToList();
                //var regiaoPrazoFornecedorVM = fornecedor?.FornecedorRegiao
                //    .Where(x => x.VlPedMinRegiao != 0).Select(x => new { x.Id, x.FornecedorId, x.CidadeId, x.Prazo, x.Cidade.DescCidade } )
                //    .ToList();
                var regiaoPrazoSemanalFornecedor = _fornecedorPrazoSemanalRep.FindBy(x => x.Fornecedor.Id == idFornecedor).Select(x => new { x.Id, x.FornecedorId, x.CidadeId, x.Cidade.DescCidade, x.DiaSemana, x.VlPedMinRegiao, x.TaxaEntrega, x.Cif }).ToList();

                //var regiaoPrazoSemanalFornecedor = fornecedor?.FornecedorRegiaoSemanal
                //    .Where(x => x.VlPedMinRegiao != 0)
                //    .ToList();



                //IEnumerable<FornecedorRegiaoViewModel> regiaoPrazoFornecedorVM = Mapper.Map<IEnumerable<FornecedorRegiao>, IEnumerable<FornecedorRegiaoViewModel>>(regiaoPrazoFornecedor);
                //  IEnumerable<FornecedorPrazoSemanalViewModel> fornecedorPrazoSemanalVM = Mapper.Map<IEnumerable<FornecedorPrazoSemanal>, IEnumerable<FornecedorPrazoSemanalViewModel>>(regiaoPrazoSemanalFornecedor);

                var regiaoSemanalVM = regiaoPrazoSemanalFornecedor
                                      .GroupBy(g => new { g.DescCidade, g.CidadeId })
                                      .Select(g => new
                {
                    NomeCidade = g.Key.DescCidade,
                    IdCidade = g.Key.CidadeId,
                    DiaSemana = g.Select(d => d.DiaSemana)
                })
                                      .ToList();

                var listaCidadeCorridos = regiaoPrazoFornecedor.Select(c => c.CidadeId).ToList();
                cidades.AddRange(listaCidadeCorridos);
                var listaCidadesSemanal = regiaoSemanalVM.Select(c => c.IdCidade).ToList();
                cidades.AddRange(listaCidadesSemanal);
                var cidadesUnicas = cidades.Distinct();
                var cidadesCorridosSemanal = _cidadeRep.GetAll().Where(c => cidadesUnicas.Contains(c.Id));

                IEnumerable <CidadeViewModel> cidadesVM = Mapper.Map <IEnumerable <Cidade>, IEnumerable <CidadeViewModel> >(cidadesCorridosSemanal);


                response = request.CreateResponse(HttpStatusCode.OK, new { regiaoPrazoFornecedor, regiaoSemanalVM, cidadesVM });

                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();
                });
            }
        }
示例#17
0
        public List <CotacaoPedidos> ListarCotacaoPedidos()
        {
            // Status pedido em cotacao

            var statusId = _statusSistemaRep.GetAll().FirstOrDefault(x => x.WorkflowStatusId == 12 && x.Ordem == 2).Id;

            DateTime dataConsulta = DateTime.Now;

            List <CotacaoPedidos> listaCotacaoPedido = _cotacaoPedidoRep.FindBy(cpr => cpr.Ativo &&
                                                                                cpr.Cotacao.DtFechamento < dataConsulta &&
                                                                                cpr.Pedido.FlgCotado &&
                                                                                cpr.Pedido.StatusSistemaId == statusId
                                                                                ).ToList();

            return(listaCotacaoPedido);
        }
示例#18
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 Atualizar(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
                {
                    Categoria novaCategoria = _categoriaRep.GetSingle(categoriaViewModel.Id);

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


                    var fornecedorCategoria = _fornecedorCategoriaRep.FindBy(x => x.CategoriaId == categoriaViewModel.Id).Count();
                    var membroCategoria = _membroCategoriaRep.FindBy(m => m.CategoriaId == categoriaViewModel.Id).Count();

                    if (fornecedorCategoria == 0 && membroCategoria == 0)
                    {
                        novaCategoria.AtualizarCategoria(categoriaViewModel, usuario);
                        _unitOfWork.Commit();

                        // Update view model
                        categoriaViewModel = Mapper.Map <Categoria, CategoriaViewModel>(novaCategoria);
                        response = request.CreateResponse(HttpStatusCode.OK, categoriaViewModel);
                    }
                    else
                    {
                        response = request.CreateResponse(HttpStatusCode.BadRequest, categoriaViewModel);
                    }
                }
                return response;
            }));
        }
示例#20
0
        public HttpResponseMessage GetEnderecoViaCep(HttpRequestMessage request, string filter = null)
        {
            return(CreateHttpResponse(request, () =>
            {
                var usuario = new Usuario();
                var pessoaId = 0;
                List <Endereco> listaEnderecos;

                if (!string.IsNullOrEmpty(filter))
                {
                    usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));


                    filter = filter.Trim().ToLower();

                    listaEnderecos = _enderecoRep.FindBy(c => c.DescEndereco.ToLower().Contains(filter) ||
                                                         c.Cidade.DescCidade.ToLower().Contains(filter) ||
                                                         c.Complemento.ToLower().Contains(filter) ||
                                                         c.Cep.ToLower().Contains(filter) ||
                                                         c.Bairro.DescBairro.ToLower().Contains(filter) &&
                                                         c.PessoaId == usuario.PessoaId
                                                         ).OrderByDescending(x => x.EnderecoPadrao).ThenByDescending(x => x.Ativo).ToList();
                }
                else
                {
                    usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                    listaEnderecos = _enderecoRep.GetAll().Where(x => x.Pessoa.Id == usuario.PessoaId).OrderByDescending(x => x.EnderecoPadrao).ThenByDescending(x => x.Ativo).ToList();
                }

                var enderecosVM = Mapper.Map <IEnumerable <Endereco>, IEnumerable <EnderecoViewModel> >(listaEnderecos);

                var response = request.CreateResponse(HttpStatusCode.OK, enderecosVM);

                return response;
            }));
        }
示例#21
0
        public HttpResponseMessage GetCartaoBandeira(HttpRequestMessage request)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                var cartaoBandeiraVM = new List <CartaoBandeiraViewModel>();

                var cartaoBandeira = _cartaoBandeiraRep.FindBy(x => x.Ativo).ToList();

                cartaoBandeira.ForEach(x =>
                {
                    cartaoBandeiraVM.Add(new CartaoBandeiraViewModel
                    {
                        Id = x.Id,
                        Descricao = x.Descricao,
                        Ativo = x.Ativo
                    });
                });

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

                return response;
            }));
        }
示例#22
0
 public List <Emails> BuscarPendentes(int limite)
 {
     return(_emailsRep.FindBy(x => x.Status == Status.Pendente).OrderBy(x => x.DtCriacao)
            .Take(limite)
            .ToList());
 }
        public List <RetornoAvisos> TrataNovaCotacaoFornecedor(Cotacao pCotacao, int TipoAvisosId)
        {
            var listaRetorno     = new List <RetornoAvisos>();
            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 lUsu          = _usuarioRep.GetAll().Where(u => pFornecedores.Contains(u.PessoaId)).ToList();


            foreach (var usu in lUsu)
            {
                var retEnviarEmail = false;
                var retEnviarSMS   = false;
                var retNovoAviso   = false;
                //Pega o Registro do Aviso para validar se necessário novo envio de email, caso não tiver deve ser criado um registro
                var novoAviso = _avisosRep.GetAll().FirstOrDefault(av => av.TipoAvisosId == TipoAvisosId &&
                                                                   av.UsuarioNotificadoId == usu.Id &&
                                                                   av.IdReferencia == pCotacao.Id);
                if (novoAviso == null)
                {
                    retNovoAviso = true;
                }

                //Valida Se Necessário enviar email
                if (PodeEnviarNotificacao(usu.Id, TipoAvisosId, TipoAlerta.EMAIL) && (!retNovoAviso && novoAviso.DataUltimoAviso.AddMinutes(30) < DateTime.Now))
                {
                    retEnviarEmail = true;
                }

                //Valida se necessário enviar SMS
                if (PodeEnviarNotificacao(usu.Id, TipoAvisosId, TipoAlerta.SMS) && (!retNovoAviso && novoAviso.DataUltimoAviso.AddMinutes(30) < DateTime.Now))
                {
                    retEnviarSMS = true;
                }

                //Cria lista com dados para envio.
                listaRetorno.Add(new RetornoAvisos
                {
                    EnviarEmail = retEnviarEmail,
                    EnviarSMS   = retEnviarSMS,
                    NovoAviso   = retNovoAviso,
                    Usuario     = usu,
                    Aviso       = novoAviso
                });
            }


            return(listaRetorno);
        }
        public List <Pedido> ListarPedidosPendentes(Enum pCliente)
        {
            bool CotacapoAceiteMembro = true;

            // Status pedido em cotacao
            int statusIdPend     = 0;
            int statusIdPendHist = 0;

            if ((TipoCliente)pCliente == TipoCliente.Membro)
            {
                //Status pedido Aguardando Membro
                statusIdPend     = _statusSistemaRep.GetAll().FirstOrDefault(x => x.WorkflowStatusId == 12 && x.Ordem == 3).Id;
                statusIdPendHist = statusIdPend;
            }
            else
            {
                //Status pedido Aguardando Fornecedor
                statusIdPend     = _statusSistemaRep.GetAll().FirstOrDefault(x => x.WorkflowStatusId == 12 && x.Ordem == 4).Id;
                statusIdPendHist = _statusSistemaRep.GetAll().FirstOrDefault(x => x.WorkflowStatusId == 12 && x.Ordem == 3).Id;
            }

            List <Pedido> lPedidoPendente           = _pedidoRep.FindBy(p => p.StatusSistemaId == statusIdPend).ToList();
            List <Pedido> lPedidoIdPendenteAtrasado = new List <Pedido>();
            Pedido        pedidoAtrasado            = null;

            foreach (Pedido item in lPedidoPendente)
            {
                var objRet = _histStatusPedidoRep.GetAll().FirstOrDefault(hp => hp.PedidoId == item.Id &&
                                                                          hp.StatusSistemaId == statusIdPendHist
                                                                          );

                if (objRet != null)
                {
                    pedidoAtrasado = objRet.Pedido;
                }
                if (pedidoAtrasado != null)
                {
                    CotacapoAceiteMembro = true;

                    if ((TipoCliente)pCliente == TipoCliente.Fornecedor)
                    {
                        //Verifica se Todos os pedidos da cotação foram aceitos pelo membro, para ai sim avisar o fornecedor.
                        CotacaoPedidos        lcotPed = _cotacaoPedidoRep.GetAll().FirstOrDefault(lp => lp.PedidoId == item.Id);
                        List <CotacaoPedidos> lcot    = _cotacaoPedidoRep.GetAll().Where(cpr => cpr.CotacaoId == lcotPed.CotacaoId).ToList();
                        foreach (CotacaoPedidos itemCot in lcot)
                        {
                            if (itemCot.Pedido.StatusSistemaId != statusIdPend)
                            {
                                CotacapoAceiteMembro = false;
                            }
                        }
                    }

                    if (CotacapoAceiteMembro)
                    {
                        lPedidoIdPendenteAtrasado.Add(pedidoAtrasado);
                    }
                }
            }

            return(lPedidoIdPendenteAtrasado);
        }
        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);
        }
        public HttpResponseMessage InserirCadastro(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(1);

                        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();

                        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);
        }
示例#28
0
        public HttpResponseMessage Get(HttpRequestMessage request, int?page, int?pageSize, int?modulo, string filter = null)
        {
            int currentPage     = page.Value;
            int currentPageSize = pageSize.Value;
            int mod             = modulo.Value;

            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                List <Menu> menu = null;
                int totalMenu = new int();

                if (!string.IsNullOrEmpty(filter))
                {
                    filter = filter.Trim().ToLower();

                    if (mod > 0)
                    {
                        menu = _menuRep.FindBy(c => c.ModuloId == mod &&
                                               c.DescMenu.Contains(filter))
                               .OrderBy(c => c.Modulo.DescModulo).ThenBy(c => c.DescMenu)
                               .Skip(currentPage * currentPageSize)
                               .Take(currentPageSize)
                               .ToList();

                        totalMenu = _menuRep.GetAll()
                                    .Count(c => c.ModuloId == mod &&
                                           c.DescMenu.Contains(filter));
                    }
                    else
                    {
                        menu = _menuRep.FindBy(c => c.DescMenu.Contains(filter))
                               .OrderBy(c => c.Modulo.DescModulo)
                               .ThenBy(c => c.DescMenu)
                               .Skip(currentPage * currentPageSize)
                               .Take(currentPageSize)
                               .ToList();

                        totalMenu = _menuRep.GetAll()
                                    .Count(c => c.DescMenu.Contains(filter));
                    }
                }
                else
                {
                    if (mod > 0)
                    {
                        menu = _menuRep.GetAll().Where(c => c.ModuloId == mod)
                               .OrderBy(c => c.Modulo.DescModulo)
                               .ThenBy(c => c.DescMenu)
                               .Skip(currentPage * currentPageSize)
                               .Take(currentPageSize)
                               .ToList();

                        totalMenu = _menuRep.GetAll().Count(x => x.ModuloId == mod);
                    }
                    else
                    {
                        menu = _menuRep.GetAll()
                               .OrderBy(c => c.Modulo.DescModulo)
                               .ThenBy(c => c.DescMenu)
                               .Skip(currentPage * currentPageSize)
                               .Take(currentPageSize)
                               .ToList();

                        totalMenu = _menuRep.GetAll().Count();
                    }
                }

                IEnumerable <MenuViewModel> menuVM = Mapper.Map <IEnumerable <Menu>, IEnumerable <MenuViewModel> >(menu);

                PaginacaoConfig <MenuViewModel> pagSet = new PaginacaoConfig <MenuViewModel>()
                {
                    Page = currentPage,
                    TotalCount = totalMenu,
                    TotalPages = (int)Math.Ceiling((decimal)totalMenu / currentPageSize),
                    Items = menuVM
                };

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

                return response;
            }));
        }
示例#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;
            }));
        }
示例#30
0
        public List <ResultadoCotacao> ListarResultadoCotacao(int cotacaoID)
        {
            List <ResultadoCotacao> lResultCotacao = _resultadoCotacaoRep.FindBy(rc => rc.CotacaoId == cotacaoID).ToList();

            return(lResultCotacao);
        }