public HttpResponseMessage Atualizar(HttpRequestMessage request, StatusSistemaViewModel StatusSistemaVM)
        {
            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
                {
                    StatusSistema novoStatus = _statusSistema.GetSingle(StatusSistemaVM.Id);

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

                    _unitOfWork.Commit();

                    // Update view model
                    StatusSistemaVM = Mapper.Map <StatusSistema, StatusSistemaViewModel>(novoStatus);
                    response = request.CreateResponse(HttpStatusCode.OK, StatusSistemaVM);
                }

                return response;
            }));
        }
        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;
            }));
        }
        /// <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);
            }
        }
示例#4
0
        public HttpResponseMessage Atualizar(HttpRequestMessage request, EnderecoViewModel enderecoViewModel)
        {
            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
                {
                    Endereco _endereco = _enderecoRep.GetSingle(enderecoViewModel.Id);

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

                    _endereco.AtualizarEndereco(enderecoViewModel, usuario);

                    _unitOfWork.Commit();


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

                return response;
            }));
        }
示例#5
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;
            }));
        }
        public HttpResponseMessage GetAvisosUsuarioEmpresa(HttpRequestMessage request, int perfilModulo)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));



                var avisos = _avisosRep.GetAll()
                             .Where(x => x.UsuarioNotificadoId == usuario.Id && x.ModuloId == perfilModulo)
                             .GroupBy(x => new { x.TipoAvisosId, x.TipoAviso.Nome, x.TipoAviso.FontIcon, x.TipoAviso.Id })
                             .Select(g => new { g.Key.Nome, g.Key.FontIcon, qtd = g.Count(), g.Key.Id });

                int totalAvisos = 0;

                if (avisos.Any())
                {
                    totalAvisos = avisos.Sum(x => x.qtd);
                }
                else
                {
                    avisos = null;
                }

                response = request.CreateResponse(HttpStatusCode.OK, new { avisos, totalAvisos });

                return response;
            }));
        }
示例#7
0
        public void SalvarPedido(Pedido pedidoSalvar)
        {
            Usuario usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);

            pedidoSalvar.UsuarioAlteracao = usuario;
            pedidoSalvar.DtAlteracao      = DateTime.Now;

            _pedidoRep.Edit(pedidoSalvar);
            _unitOfWork.Commit();
        }
        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;
            }));
        }
示例#10
0
        /// <summary>
        /// Criar usuário para ADM Franquia e Enviar Email.
        /// </summary>
        /// <param name="FranquiaId">Passar Id da Franquia</param>
        /// <param name="usu">Passar usuário de Criação.</param>
        /// <param name="telefone">Passar objeto telefone.</param>
        public Franquia FranquiaInserirUsuarioEnviarEmail(int FranquiaId, Usuario usu, Telefone telefone)
        {
            bool booValidaUsuario = false;

            Franquia franquiaAtual = _franquiaRep.GetSingle(FranquiaId);


            //Verifica se já foi completo o cadastro para criar Usuário Master e Enviar Email de Boas vindas.

            //inserir usuario
            int PerfilId = 4;

            Usuario _user = _membershipService.CreateUser(
                franquiaAtual.Pessoa.PessoaJuridica.NomeFantasia,
                franquiaAtual.Pessoa.PessoaJuridica.Email,
                franquiaAtual.Pessoa.PessoaJuridica.Cnpj.Substring(0, 8),
                PerfilId,
                franquiaAtual.PessoaId,
                usu.Id,
                true,
                telefone.DddTelComl,
                telefone.TelefoneComl,
                telefone.DddCel,
                telefone.Celular,
                telefone.Contato);

            //Enviar Email
            var template = _templateEmailRep.GetSingle(29).Template;

            _emailService.EnviaEmail(franquiaAtual.Pessoa.PessoaJuridica.Email, "",
                                     _emailService.MontaEmail(franquiaAtual.Pessoa.PessoaJuridica, template), "Bem-Vindo à Economiza Já");

            return(franquiaAtual);
        }
        public HttpResponseMessage Atualizar(HttpRequestMessage request, SegmentoViewModel segmentoVM)
        {
            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
                {
                    Segmento novasegmento = _segmentoRep.GetSingle(segmentoVM.Id);

                    Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
                    //if (novasegmento.Produtos.Count > 0 && segmentoVM.Ativo == false)
                    //   return request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, "Não é possível ser desativado");
                    //else
                    novasegmento.AtualizarSegmento(segmentoVM, usuario);

                    _unitOfWork.Commit();

                    // Update view model
                    segmentoVM = Mapper.Map <Segmento, SegmentoViewModel>(novasegmento);
                    response = request.CreateResponse(HttpStatusCode.OK, segmentoVM);
                }

                return response;
            }));
        }
        public HttpResponseMessage Atualizar(HttpRequestMessage request, MembroDemandaViewModel membroDemandaViewModel)
        {
            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
                {
                    MembroDemanda _membroDemanda = _membroDemandaRep.GetSingle(membroDemandaViewModel.Id);

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

                    _unitOfWork.Commit();

                    // Update view model
                    membroDemandaViewModel = Mapper.Map <MembroDemanda, MembroDemandaViewModel>(_membroDemanda);
                    response = request.CreateResponse(HttpStatusCode.OK, membroDemandaViewModel);

                    //TODO: Verificar se deve enviar e-mail ao cadastrar demanda.
                    //_utilService.MembroInserirUsuarioEnviarEmail(membroDemandaViewModel.Id, usuario.Id);
                }

                return response;
            }));
        }
示例#13
0
        public HttpResponseMessage PermissaoUrl(HttpRequestMessage request, string url)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

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

                var UsuarioGrupos = _usuarioGrupoRep.GetAll().Where(ug => ug.UsuarioId == usuario.Id).ToList();
                var menuVMPermissao = _grupoPermissaoRep.GetAll().Where(x => x.Menu.Url != null &&
                                                                        x.Menu.Url.ToUpper() == "#/" + url.ToUpper() &&
                                                                        x.Menu.Ativo == true);

                var menus = from ug in UsuarioGrupos
                            join mp in menuVMPermissao
                            on ug.GrupoId equals mp.GrupoId
                            //where mp.Menu.Url.ToUpper() == "#/" + url.ToUpper()
                            select mp;


                if (menus.Any())
                {
                    booTemAcesso = true;
                }

                response = request.CreateResponse(HttpStatusCode.OK, new { success = true, temacesso = booTemAcesso, novaurl = url });

                return response;
            }));
        }
示例#14
0
        public HttpResponseMessage EnviarEmail(HttpRequestMessage request, LoginViewModel usuario)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                //remove a validacao da propriedade da senha, pois a propriedade esta sendo validada
                //lá no fluent validator e neste caso não prcisa validar
                ModelState.Remove("usuario.Senha");

                if (ModelState.IsValid)
                {
                    RecuperaSenha recuperaSenha = new RecuperaSenha();

                    recuperaSenha.Chave = Guid.NewGuid();

                    Usuario userRecupera = _membershipService.GetUserPorEmail(usuario.UsuarioEmail, usuario.perfilModulo);

                    if (userRecupera != null)
                    {
                        recuperaSenha.UsuarioCriacao = userRecupera;
                        recuperaSenha.UsuarioCriacaoId = userRecupera.Id;
                        recuperaSenha.DtCriacao = DateTime.Now;
                        recuperaSenha.UsuarioId = userRecupera.Id;
                        recuperaSenha.DtExpira = DateTime.Now.AddDays(1); // tem um dia para trocar a senha
                        recuperaSenha.Usuario = userRecupera;
                        _membershipService.CreateRecuperaSenha(recuperaSenha);

                        // Update view model
                        string strAmbiente = Environment.GetEnvironmentVariable("Amb_EconomizaJa").ToUpper();
                        string localCodigo = $"URL_Mod{usuario.perfilModulo}_Amb{strAmbiente}".ToString();
                        string URL_Modulo_Ambiente = _parametroSistema.GetAll().FirstOrDefault(fd => fd.Codigo == localCodigo).Valor;

                        RecuperaSenhaViewModel recuperaSenhaVM = AutoMapper.Mapper.Map <RecuperaSenha, RecuperaSenhaViewModel>(recuperaSenha);

                        //	recuperaSenhaVM.URL = "http://localhost:1312/#/recuperasenha?Q="; //ADM local
                        recuperaSenhaVM.URL = $"{URL_Modulo_Ambiente}/#/recuperasenha?Q=";

                        //Envia email de Recuperar Senha para o Usuário
                        var template = _templateEmailRep.GetSingle(2).Template;
                        _emailService.EnviarEmailViaRobo(userRecupera, "Recuperar Senha - Economiza Já", recuperaSenhaVM.Usuarioemail,
                                                         _emailService.MontaEmail(recuperaSenhaVM, template), Origem.RecuperarSenha);


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

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

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

                var enderecos = _enderecoRep.GetAll().Where(x => x.Pessoa.Id == usuario.PessoaId);;

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

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

                return response;
            }));
        }
        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;
            }));
        }
        public void AtualizaDataAviso(Avisos avisos, int usuarioId)
        {
            Avisos AtuAviso = _avisosRep.GetSingle(avisos.Id);

            AtuAviso.DataUltimoAviso    = DateTime.Now;
            AtuAviso.UsuarioAlteracaoId = usuarioId;
            AtuAviso.DtAlteracao        = DateTime.Now;
            _unitOfWork.Commit();
        }
        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;
            }));
        }
示例#19
0
        public void Salvar(Emails email)
        {
            Usuario usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);

            email.UsuarioAlteracao = usuario;
            email.DtAlteracao      = DateTime.Now;

            _emailsRep.Edit(email);
            _unitOfWork.Commit();
        }
示例#20
0
        public void FornecedorInserirUsuarioEnviarEmail(int FornecedorId, int UsuarioId)
        {
            bool booValidaUsuario = false;

            Fornecedor fornecedorAtual = _fornecedorRep.GetSingle(FornecedorId);

            //Verifica se tem usuario Master
            //Usuario u = fornecedorAtual.Pessoa.Usuarios.FirstOrDefault(x => x.FlgMaster);

            //if (u == null)
            //    booValidaUsuario = true;

            //Verifica se já foi completo o cadastro para criar Usuário Master e Enviar Email de Boas vindas.
            if (fornecedorAtual.Pessoa.Enderecos.Any() &&
                fornecedorAtual.FornecedorCategorias.Any() &&
                fornecedorAtual.FornecedorRegiao.Any() &&
                fornecedorAtual.FornecedorFormaPagtos.Any()
                // &&  booValidaUsuario
                )
            {
                //inserir usuario
                int     PerfilId = 3;
                Usuario usuario  = _usuarioRep.GetSingle(UsuarioId);

                Usuario _user = _membershipService.CreateUser(
                    fornecedorAtual.Pessoa.PessoaJuridica.NomeFantasia,
                    fornecedorAtual.Pessoa.PessoaJuridica.Email,
                    fornecedorAtual.Pessoa.PessoaJuridica.Cnpj.Substring(0, 8),
                    PerfilId,
                    fornecedorAtual.PessoaId,
                    usuario.Id,
                    true, fornecedorAtual.DddTel, fornecedorAtual.Telefone, fornecedorAtual.DddCel, fornecedorAtual.Celular);

                //Enviar Email
                var template = _templateEmailRep.GetSingle(19).Template;



                Emails email1 = new Emails()
                {
                    EmailDestinatario = fornecedorAtual.Pessoa.PessoaJuridica.Email,
                    CorpoEmail        = _emailService.MontaEmail(fornecedorAtual.Pessoa.PessoaJuridica, template),
                    AssuntoEmail      = "Bem-Vindo à Economiza Já",
                    Status            = Status.NaoEnviado,
                    Origem            = Origem.CriarUsuarioFornecedorMembro,
                    DtCriacao         = DateTime.Now,
                    UsuarioCriacao    = usuario,
                    Ativo             = true
                };

                _emailsRep.Add(email1);
                _unitOfWork.Commit();
            }
        }
示例#21
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;
            }));
        }
示例#22
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;
            }));
        }
        private List <ResultadoPrecoCotacaoFornecedor> CotacaoProdsGroup(int usuarioId, int cotacaoId)
        {
            var usuario    = _usuarioRep.GetSingle(usuarioId);
            var fornecedor = _fornecedoRep.GetAll().FirstOrDefault(x => x.PessoaId == usuario.PessoaId);

            var _param = new SqlParameter {
                ParameterName = "@FORNECEDORID", SqlDbType = System.Data.SqlDbType.BigInt, Value = fornecedor.Id
            };
            var cotacaoProdsGroup = _usuarioRep.ExecWithStoreProcedure <ResultadoPrecoCotacaoFornecedor>("stp_fornecedor_preco_cotacao @FORNECEDORID", _param).ToList();

            return(cotacaoProdsGroup);
        }
        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;
            }));
        }
示例#25
0
        public HttpResponseMessage GetTipoNotificacao(HttpRequestMessage request)
        {
            return(CreateHttpResponse(request, () =>
            {
                var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                var modulo = 0;
                switch (usuario.PerfilId)
                {
                case 1:
                    modulo = 1;
                    break;

                case 2:
                    modulo = 3;
                    break;

                case 3:
                    modulo = 4;
                    break;
                }

                var notificacao = _tipoAvisosRep.GetAll().Where(x => x.Ativo && x.ModuloId.Equals(modulo) && x.Notificacoes.Any(y => y.Ativo)).ToList();

                var notificacaoVM = Mapper.Map <IEnumerable <TipoAvisos>, IEnumerable <TipoNotificacaoViewModel> >(notificacao);

                notificacaoVM.ForEach(x =>
                {
                    x.Notificacoes.ForEach(y =>
                    {
                        y.Checked = !usuario.Notificacoes.Any(z => z.Ativo && z.NotificacaoId.Equals(y.Id));
                    });
                });

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

                return response;
            }));
        }
        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;
            }));
        }
        public HttpResponseMessage FornCotacaoEveolucao(HttpRequestMessage request)
        {
            return(CreateHttpResponse(request, () =>
            {
                var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
                var fornecedor = _fornecedorRep.FirstOrDefault(x => x.Pessoa.Id == usuario.Pessoa.Id);

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


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

                _unitOfWork.Commit();

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


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



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

                var response = request.CreateResponse(HttpStatusCode.OK, new { relatCe, relatCp, relatCped });
                return response;
            }));
        }
        public 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;
            }));
        }
        public HttpResponseMessage SalvaTrocaItemFornecedor(HttpRequestMessage request, List <TrocaItemFornecedorViewModel> itensTroca)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));

                foreach (var item in itensTroca)
                {
                    var itemToChange = _itemPedidoRep.GetSingle(item.ItemId);

                    itemToChange.Observacao = item.Observacao;
                    itemToChange.FornecedorId = item.FornecedorId;
                    itemToChange.PrecoNegociadoUnit = item.ValorItemFornecedor;
                    itemToChange.UsuarioAlteracaoId = usuario.Id;
                    _itemPedidoRep.Edit(itemToChange);
                    _unitOfWork.Commit();
                }

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

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