public void LimparTabelAvisosPorMembro(List <Pedido> ListaPedidosPendentes, int pTipoAviso)
        {
            List <int> vAvisos = new List <int>();

            // Identifica Pedidos que estão na tabela de Avisos, porém já foram respondidos
            vAvisos = _avisosRep.GetAll().Where(w => w.TipoAvisosId == pTipoAviso && w.ModuloId == 3).Select(s => s.IdReferencia).ToList();
            if (vAvisos != null && vAvisos.Any())
            {
                List <int> PedidosDeletar = vAvisos.Except(ListaPedidosPendentes.Select(s => s.Id)).ToList();
                // Consulta Avisos por Pedidos
                var AvisosDeletar = _avisosRep.GetAll().Where(w => w.TipoAvisosId == pTipoAviso && w.ModuloId == 3 && PedidosDeletar.Contains(w.IdReferencia));

                if (AvisosDeletar != null && AvisosDeletar.Any())
                {
                    _avisosRep.DeleteAll(AvisosDeletar);
                    _unitOfWork.Commit();
                }
            }
        }
        public HttpResponseMessage InserirMembroCategoria(HttpRequestMessage request, int membroId, int[] listCategoria)
        {
            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
                {
                    var usuario = _usuarioRep.GetSingle(1);
                    Membro _membro = _membroRep.GetSingle(membroId);


                    var membroCategorias =
                        _membeoCategoriaRep.GetAll().Where(x => x.MembroId == membroId);

                    if (membroCategorias.Any())
                    {
                        _membeoCategoriaRep.DeleteAll(membroCategorias);
                    }


                    foreach (var item in listCategoria)
                    {
                        MembroCategoria membroCategoria = new MembroCategoria()
                        {
                            UsuarioCriacao = usuario,
                            DtCriacao = DateTime.Now,
                            MembroId = membroId,
                            CategoriaId = item,
                            Ativo = true
                        };

                        _membro.MembroCategorias.Add(membroCategoria);
                    }

                    _membroRep.Edit(_membro);
                    _unitOfWork.Commit();



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

                return response;
            }));
        }
Ejemplo n.º 3
0
        public HttpResponseMessage AtualizarGrupo(HttpRequestMessage request, int UsuarioId, IEnumerable <UsuarioGrupoViewModel> gruposXusuarios)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;



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

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

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

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


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

                return response;
            }));
        }
        public HttpResponseMessage InserirCategoriaSegmento(HttpRequestMessage request, int categoriaId, int[] listSegmento)
        {
            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()));
                    //Fornecedor _forencedor = _fornecedorRep.GetSingle(fornecedorId);
                    Categoria _categoria = _categoriaRep.GetSingle(categoriaId);

                    var categoriaSegmentos =
                        _segmentoCategoriaRep.GetAll().Where(x => x.CategoriaId == categoriaId);

                    if (categoriaSegmentos.Any())
                    {
                        _segmentoCategoriaRep.DeleteAll(categoriaSegmentos);
                    }

                    foreach (var item in listSegmento)
                    {
                        SegmentoCategoria SegmentoCategoria = new SegmentoCategoria()
                        {
                            UsuarioCriacao = usuario,
                            DtCriacao = DateTime.Now,
                            SegmentoId = item,
                            CategoriaId = categoriaId,
                            Ativo = true
                        };
                        _categoria.SegmentosCategoria.Add(SegmentoCategoria);
                    }

                    _categoriaRep.Edit(_categoria);
                    _unitOfWork.Commit();
                    response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
                }

                return response;
            }));
        }
        public HttpResponseMessage Atualizar(HttpRequestMessage request, EnderecoViewModel enderecoViewModel)
        {
            return(CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                HorasEntregaMembro horasEntrega = new HorasEntregaMembro();
                List <PeriodoEntrega> listaPeriodo = new List <PeriodoEntrega>();

                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);
                    var usuario = new Usuario();

                    if (HttpContext.Current.User.Identity.GetUserId() != null)
                    {
                        usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
                    }
                    else
                    {
                        usuario = _usuarioRep.GetSingle(1);
                    }

                    #region Atualiza Período de Entrega

                    var pegarTodosHorariosEntrega = _horarioEntregaMembroRep.GetAll().Where(x => x.EnderecoId == enderecoViewModel.Id).ToList();

                    if (pegarTodosHorariosEntrega.Count > 0)
                    {
                        _horarioEntregaMembroRep.DeleteAll(pegarTodosHorariosEntrega);
                        _unitOfWork.Commit();

                        foreach (var periodo in enderecoViewModel.PeriodoEntrega)
                        {
                            horasEntrega.UsuarioCriacao = usuario;
                            horasEntrega.DtCriacao = DateTime.Now;
                            horasEntrega.PeriodoId = periodo.Id;
                            horasEntrega.EnderecoId = enderecoViewModel.Id;
                            horasEntrega.DescHorarioEntrega = enderecoViewModel.DescHorarioEntrega;
                            horasEntrega.Ativo = true;


                            _horarioEntregaMembroRep.Add(horasEntrega);
                            _unitOfWork.Commit();
                        }
                    }
                    else
                    {
                        foreach (var periodo in enderecoViewModel.PeriodoEntrega)
                        {
                            horasEntrega.UsuarioCriacao = usuario;
                            horasEntrega.DtCriacao = DateTime.Now;
                            horasEntrega.PeriodoId = periodo.Id;
                            horasEntrega.EnderecoId = enderecoViewModel.Id;
                            horasEntrega.DescHorarioEntrega = enderecoViewModel.DescHorarioEntrega;
                            horasEntrega.Ativo = true;

                            _horarioEntregaMembroRep.Add(horasEntrega);
                            _unitOfWork.Commit();
                        }
                    }

                    #endregion

                    _endereco.AtualizarEndereco(enderecoViewModel, usuario);

                    _unitOfWork.Commit();

                    // Update view model

                    // enderecoViewModel = Mapper.Map<Endereco, EnderecoViewModel>(_endereco);

                    // enderecoViewModel.PeriodoEntrega.Clear();

                    // enderecoViewModel.PeriodoEntrega.AddRange(listaPeriodo);

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

                return response;
            }));
        }
        public HttpResponseMessage AtualizarPermissao(HttpRequestMessage request, int GrupoID, IEnumerable <MenuPermissaoViewModel> menuPermissaoVM)
        {
            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
                {
                    var grupoPermissao = _grupoPermissaoRep.GetAll().Where(x => x.GrupoId == GrupoID);

                    if (grupoPermissao.Any())
                    {
                        _grupoPermissaoRep.DeleteAll(grupoPermissao);
                        _unitOfWork.Commit();
                    }


                    IEnumerable <MenuViewModel> menuVM = null;
                    List <PermissaoGrupo> lstPermissaoGrupo = new List <PermissaoGrupo>();

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

                    var menu = _menuRep.GetAll().Where(m => m.ModuloId == 1 && m.Ativo);
                    int IdMenuPai;
                    menuVM = Mapper.Map <IEnumerable <Menu>, IEnumerable <MenuViewModel> >(menu);


                    PermissaoGrupo permissaoGrupo = null;
                    PermissaoGrupo permissaoGrupoItem = null;

                    foreach (MenuPermissaoViewModel mnp in menuPermissaoVM)
                    {
                        if (mnp.selected)
                        {
                            permissaoGrupo = new PermissaoGrupo();
                            permissaoGrupo.UsuarioCriacao = usuario;
                            permissaoGrupo.DtCriacao = DateTime.Now;
                            permissaoGrupo.Ativo = true;

                            permissaoGrupo.GrupoId = GrupoID;
                            permissaoGrupo.MenuId = mnp.Id;
                            permissaoGrupo.PerfilId = 1;

                            permissaoGrupo.FlgVisualizarMenu = mnp.selected;
                            // TODO: Incluir permissões de Consultar, Alterar, Incluir e Excluir


                            IdMenuPai = (int)(menu.Single(m => m.Id == mnp.Id).MenuPaiId == null ? 0 : menu.Single(m => m.Id == mnp.Id).MenuPaiId);
                            if (IdMenuPai > 0)
                            {
                                var lstPG = Util.PermissaoIdPai(IdMenuPai, lstPermissaoGrupo, menuVM);

                                foreach (PermissaoGrupoViewModel item in lstPG)
                                {
                                    permissaoGrupoItem = new PermissaoGrupo();
                                    permissaoGrupoItem.UsuarioCriacao = usuario;
                                    permissaoGrupoItem.DtCriacao = DateTime.Now;
                                    permissaoGrupoItem.Ativo = true;

                                    permissaoGrupoItem.GrupoId = GrupoID;
                                    permissaoGrupoItem.MenuId = item.MenuId;
                                    permissaoGrupoItem.PerfilId = 1;

                                    permissaoGrupoItem.FlgVisualizarMenu = mnp.selected;
                                    // TODO: Incluir permissões de Consultar, Alterar, Incluir e Excluir
                                    lstPermissaoGrupo.Add(permissaoGrupoItem);
                                }
                            }
                            lstPermissaoGrupo.Add(permissaoGrupo);
                        }
                    }
                    //_grupoPermissaoRep.Add();
                    foreach (var item in lstPermissaoGrupo)
                    {
                        _grupoPermissaoRep.Add(item);
                    }
                    _unitOfWork.Commit();

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

                return response;
            }));
        }