Пример #1
0
        public static void Remover(int idCategoria)
        {
            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var categoria_ = from CategoriaEquipamento ce in context.Categorias.Include("Reservas").Include("Equipamentos")
                                 where ce.Id == idCategoria
                                 select ce;

                if (categoria_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.CATEGORIAINEXISTENTE, idCategoria.ToString());
                }

                if (categoria_.First().Reservas.Count > 0)
                {
                    string info = "";
                    foreach (var r in categoria_.First().Reservas)
                    {
                        info += String.Format("[{0} {1} {2}] ", r.Data.ToShortDateString(),
                                              r.Turno, r.Horario);
                    }
                    throw new EntidadesException(EntityExcCode.CATEGORIAPOSSUIRESERVAS, info);
                }

                int equips = categoria_.First().Equipamentos.Count();
                if (equips > 0)
                {
                    throw new EntidadesException(EntityExcCode.CATEGORIAPOSSUIEQUIPAMENTOS, equips.ToString());
                }

                context.Categorias.Remove(categoria_.First());
                context.SaveChanges();
            }
        }
        public static int Cadastrar(string modelo, string serie, bool disponivel, int idCategoria)
        {
            Equipamento equipamento = null;

            if (modelo == null || modelo.Length == 0)
            {
                throw new EntidadesException(EntityExcCode.MODELOEQUIPAMENTOVAZIO, "");
            }

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var categoria_ = from CategoriaEquipamento ce in context.Categorias
                                 where ce.Id == idCategoria
                                 select ce;

                if (categoria_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.CATEGORIAINEXISTENTE, idCategoria.ToString());
                }

                equipamento                      = new Equipamento();
                equipamento.Modelo               = modelo;
                equipamento.Serie                = serie;
                equipamento.Disponivel           = disponivel;
                equipamento.CategoriaEquipamento = categoria_.First();

                context.Equipamentos.Add(equipamento);
                context.SaveChanges();
            }

            return(equipamento.Id);
        }
Пример #3
0
        public static void Atualizar(int id, string nome, string detalhes, DateTime?vencimento, TIPORECURSO tipo)
        {
            if (nome == null || nome.Length == 0)
            {
                throw new EntidadesException(EntityExcCode.NOMERECURSOVAZIO, "");
            }

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var recurso_ = from Recurso r in context.Recursos
                               where r.Id == id
                               select r;

                if (recurso_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.RECURSOINEXISTENTE, id.ToString());
                }

                Recurso recurso = recurso_.First();
                recurso.Nome       = nome;
                recurso.Detalhes   = detalhes;
                recurso.Vencimento = vencimento;
                recurso.Tipo       = tipo;

                context.SaveChanges();
            }
        }
Пример #4
0
        public static List <Reserva> ConsultarPorFiltro(DateTime?dataDe, DateTime?dataAte, int tipo, int idLocal,
                                                        int idCategoria, string obs)
        {
            List <Reserva> Reservas = new List <Reserva>();

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                if (!dataDe.HasValue)
                {
                    dataDe = DateTime.MinValue;
                }
                if (!dataAte.HasValue)
                {
                    dataAte = DateTime.MaxValue;
                }

                var reservas_ = from Reserva r in context.Reservas.Include("Local")
                                .Include("CategoriasEquipamentos.Equipamentos").Include("Usuario")
                                where r.Data >= dataDe && r.Data <= dataAte
                                select r;

                string[] customOrder = { "M", "T", "N" };

                Reservas = reservas_.ToList()
                           .OrderBy(res => res.Data)
                           .ThenBy(res => Array.IndexOf(customOrder, res.Turno))
                           .ThenBy(res => res.Horario).ToList();

                //Somente laboratórios
                if (tipo == 1)
                {
                    Reservas = Reservas.Where(r => r.Local.Reservavel).ToList();
                }
                //Equipamentos
                else if (tipo == 2)
                {
                    Reservas = Reservas.Where(r => r.CategoriasEquipamentos.Count() > 0).ToList();
                }
                //Local e/ou equipamento específico
                else if (tipo == 3)
                {
                    if (idLocal > 0)
                    {
                        Reservas = Reservas.Where(r => r.Local.Id == idLocal).ToList();
                    }

                    if (idCategoria > 0)
                    {
                        Reservas = Reservas.Where(r => r.CategoriasEquipamentos.Where(c => c.Id == idCategoria).Count() > 0).ToList();
                    }
                }

                if (obs != null && obs.Length > 0)
                {
                    Reservas = Reservas.Where(r => r.Obs != null && r.Obs.Contains(obs)).ToList();
                }
            }

            return(Reservas);
        }
Пример #5
0
        public static void RemoverRestricao(int idLocal, int idCategoria)
        {
            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var local_ = from Local l in context.Locais.Include("RestricoesCategoriaEquipamento")
                             where l.Id == idLocal
                             select l;

                if (local_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.LOCALINEXISTENTE, idLocal.ToString());
                }

                Local local = local_.First();

                var categoria_ = from CategoriaEquipamento c in context.Categorias
                                 where c.Id == idCategoria
                                 select c;

                if (categoria_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.CATEGORIAINEXISTENTE, idCategoria.ToString());
                }

                if (!local.RestricoesCategoriaEquipamento.Contains(categoria_.First()))
                {
                    throw new EntidadesException(EntityExcCode.RESTRICAOINEXISTENTE, categoria_.First().Nome + " em " + local.Nome);
                }

                local.RestricoesCategoriaEquipamento.Remove(categoria_.First());
                context.SaveChanges();
            }
        }
Пример #6
0
        public static int Cadastrar(string nome, string comentarioReserva)
        {
            CategoriaEquipamento categoria = null;

            if (nome == null || nome.Length == 0)
            {
                throw new EntidadesException(EntityExcCode.NOMECATEGORIAVAZIO, "");
            }

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var categoria_ = from CategoriaEquipamento ce in context.Categorias
                                 where ce.Nome == nome
                                 select ce;

                if (categoria_.Count() > 0)
                {
                    throw new EntidadesException(EntityExcCode.CATEGORIAJACADASTRADA, nome);
                }

                categoria      = new CategoriaEquipamento();
                categoria.Nome = nome;
                categoria.ComentarioReserva = comentarioReserva;

                context.Categorias.Add(categoria);
                context.SaveChanges();
            }

            return(categoria.Id);
        }
Пример #7
0
        /// <summary>
        /// Remove o recurso do local específico.
        /// </summary>
        /// <param name="idRecurso"></param>
        /// <param name="idLocal"></param>
        public static void RemoverPorLocal(int idRecurso, int idLocal)
        {
            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var recurso_ = from Recurso r in context.Recursos
                               where r.Id == idRecurso
                               select r;

                if (recurso_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.RECURSOINEXISTENTE, idRecurso.ToString());
                }

                var local_ = from Local l in context.Locais
                             where l.Id == idLocal
                             select l;

                if (local_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.LOCALINEXISTENTE, idLocal.ToString());
                }

                var recursolocal_ = from RecursoLocal rl in context.RecursosLocais
                                    where rl.Recurso.Id == idLocal && rl.Local.Id == idLocal
                                    select rl;

                if (recursolocal_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.RECURSOLOCALINEXISTENTE, "");
                }

                context.RecursosLocais.Remove(recursolocal_.First());
                context.SaveChanges();
            }
        }
Пример #8
0
        /// <summary>
        /// Locais disponíveis para reserva.
        /// </summary>
        /// <param name="data"></param>
        /// <param name="horario"></param>
        /// <param name="turno"></param>
        /// <param name="reservaveis">Somente os reserváveis (true) ou todos (false)</param>
        /// <returns></returns>
        public static List <CategoriaEquipamento> ConsultarCategoriasDisponiveis(DateTime data, string horario, string turno)
        {
            List <CategoriaEquipamento> categorias = new List <CategoriaEquipamento>();

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var categoria_ = from CategoriaEquipamento ce in context.Categorias.Include("Equipamentos")
                                 select ce;
                List <CategoriaEquipamento> catCandidatas = categoria_.ToList();

                foreach (CategoriaEquipamento ce in catCandidatas)
                {
                    //Reservas daquela categoria
                    var reserva_ = from Reserva r in context.Reservas
                                   where r.Data.Equals(data) && r.Turno.Equals(turno) && r.Horario.Equals(horario) &&
                                   ((from CategoriaEquipamento cer in r.CategoriasEquipamentos
                                     where cer.Id == ce.Id
                                     select cer).Count() > 0)
                                   select r;

                    if (reserva_.Count() < ce.Equipamentos.Where(e => e.Disponivel).Count())
                    {
                        categorias.Add(ce);
                    }
                }
            }

            return(categorias);
        }
Пример #9
0
        public static void Atualizar(int id, string nome, bool reservavel, bool disponivel, TIPOLOCAL tipo, string comentarioReserva)
        {
            if (nome == null || nome.Length == 0)
            {
                throw new EntidadesException(EntityExcCode.NOMELOCALVAZIO, "");
            }

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var local_ = from Local l in context.Locais
                             where l.Id == id
                             select l;

                if (local_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.LOCALINEXISTENTE, id.ToString());
                }

                Local local = local_.First();
                local.Nome              = nome;
                local.Reservavel        = reservavel;
                local.Disponivel        = disponivel;
                local.Tipo              = tipo;
                local.ComentarioReserva = comentarioReserva;

                context.SaveChanges();
            }
        }
Пример #10
0
        public static void Remover(int id)
        {
            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var recurso_ = from Recurso r in context.Recursos.Include("Locais.RecursoLocal")
                               where r.Id == id
                               select r;

                if (recurso_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.RECURSOINEXISTENTE, id.ToString());
                }

                if (recurso_.First().Locais.Count > 0)
                {
                    string info = "";
                    foreach (var r in recurso_.First().Locais)
                    {
                        info += String.Format("[{0}] ", r.Local.Nome);
                    }
                    throw new EntidadesException(EntityExcCode.RECURSOPOSSUILOCAIS, info);
                }


                context.Recursos.Remove(recurso_.First());
                context.SaveChanges();
            }
        }
Пример #11
0
        public static void Remover(int id)
        {
            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var local_ = from Local l in context.Locais.Include("Reservas")
                             where l.Id == id
                             select l;

                if (local_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.LOCALINEXISTENTE, id.ToString());
                }

                if (local_.First().Reservas.Count > 0)
                {
                    string info = "";
                    foreach (var r in local_.First().Reservas)
                    {
                        info += String.Format("[{0} {1} {2}] ", r.Data.ToShortDateString(),
                                              r.Turno, r.Horario);
                    }
                    throw new EntidadesException(EntityExcCode.LOCALPOSSUIRESERVAS, info);
                }


                context.Locais.Remove(local_.First());
                context.SaveChanges();
            }
        }
Пример #12
0
        public static void Atualizar(int idCategoria, string nome, string comentarioReserva)
        {
            if (nome == null || nome.Length == 0)
            {
                throw new EntidadesException(EntityExcCode.NOMECATEGORIAVAZIO, "");
            }

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var categoria_ = from CategoriaEquipamento ce in context.Categorias
                                 where ce.Id == idCategoria
                                 select ce;

                if (categoria_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.CATEGORIAINEXISTENTE, idCategoria.ToString());
                }

                CategoriaEquipamento categoria = categoria_.First();
                categoria.Nome = nome;
                categoria.ComentarioReserva = comentarioReserva;

                context.SaveChanges();
            }
        }
Пример #13
0
        public static bool ValidarToken(int id, string token)
        {
            bool tokenValido = false;

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var usuario_ = from Usuario u in context.Usuarios
                               where u.Id == id
                               select u;

                if (usuario_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.IDUSUARIONAOCADASTRADO, id.ToString());
                }
                else
                {
                    Usuario  usuario = usuario_.First();
                    byte[]   data    = Convert.FromBase64String(token);
                    DateTime hora    = DateTime.FromBinary(BitConverter.ToInt64(data, 0));

                    //Token coincide e hora não expirou
                    if (usuario.Token.Equals(token) && DateTime.UtcNow < hora.AddMinutes(TEMPOSESSAO))
                    {
                        tokenValido = true;
                    }
                }
            }

            return(tokenValido);
        }
Пример #14
0
        /// <summary>
        /// Locais disponíveis para reserva.
        /// </summary>
        /// <param name="data"></param>
        /// <param name="horario"></param>
        /// <param name="turno"></param>
        /// <param name="reservaveis">Somente os reserváveis (true) ou todos (false)</param>
        /// <returns></returns>
        public static List <Local> ConsultarLocaisDisponiveis(DateTime data, string horario, string turno, bool somenteReservaveis)
        {
            List <Local> Locais = new List <Local>();

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                if (somenteReservaveis)
                {
                    var local1_ = from Local l in context.Locais
                                  where l.Disponivel && l.Reservavel &&
                                  !(from Reserva r in context.Reservas
                                    where r.Data.Equals(data) && r.Turno.Equals(turno) && r.Horario.Equals(horario)
                                    select r.Local.Id).Contains(l.Id)
                                  select l;

                    Locais = local1_.ToList();
                }
                else
                {
                    //Inclui não reserváveis mesmo que estejam em algum reserva
                    var local2_ = from Local l in context.Locais
                                  where l.Disponivel && (!l.Reservavel || (l.Reservavel &&
                                                                           !(from Reserva r in context.Reservas
                                                                             where r.Data.Equals(data) && r.Turno.Equals(turno) && r.Horario.Equals(horario)
                                                                             select r.Local.Id).Contains(l.Id)))
                                  select l;

                    Locais = local2_.ToList();
                }
            }

            return(Locais);
        }
Пример #15
0
        public static void Remover(int idUsuario)
        {
            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var usuario_ = from Usuario u in context.Usuarios.Include("Reservas").Include("ReservasBolsista").Include("Chamados")
                               where u.Id == idUsuario
                               select u;

                if (usuario_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.IDUSUARIONAOCADASTRADO, idUsuario.ToString());
                }

                if (usuario_.First().ReservasBolsista.Count() > 0)
                {
                    throw new EntidadesException(EntityExcCode.USUARIOPOSSUIRESERVASBOLSISTA, usuario_.First().ReservasBolsista.Count().ToString());
                }

                //Consulta reservas futuras
                List <Reserva> reservas = usuario_.First().Reservas.Where(r => r.Data > DateTime.Now.AddDays(-1)).ToList();
                if (reservas.Count() > 0)
                {
                    throw new EntidadesException(EntityExcCode.USUARIOPOSSUIRESERVAS, reservas.Count().ToString());
                }

                //Remove as reservas antigas
                context.Reservas.RemoveRange(usuario_.First().Reservas);
                context.Usuarios.Remove(usuario_.First());
                context.SaveChanges();
            }
        }
Пример #16
0
        public static void AtualizarSenha(int idUsuario, string oldPassword, string newPassword)
        {
            if (newPassword.Length < TAMANHOSENHA)
            {
                throw new EntidadesException(EntityExcCode.SENHACURTA, "tamanho mínimo é " + TAMANHOSENHA);
            }


            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var usuario_ = from Usuario u in context.Usuarios
                               where u.Id == idUsuario
                               select u;

                if (usuario_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.IDUSUARIONAOCADASTRADO, idUsuario.ToString());
                }

                if (Util.GerarHashMd5(oldPassword) != Util.GerarHashMd5(usuario_.First().Senha))
                {
                    throw new EntidadesException(EntityExcCode.SENHANAOCONFERE, "");
                }

                usuario_.First().Senha = Util.GerarHashMd5(newPassword);
                context.SaveChanges();
            }
        }
Пример #17
0
        public static List <CategoriaEquipamento> ConsultarNaoRestricoes(int idLocal)
        {
            List <CategoriaEquipamento> Categorias = new List <CategoriaEquipamento>();

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var categoria_ = from CategoriaEquipamento ce in context.Categorias
                                 select ce;

                Categorias = categoria_.ToList();

                var local_ = from Local l in context.Locais.Include("RestricoesCategoriaEquipamento")
                             where l.Id == idLocal
                             select l;

                if (local_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.LOCALINEXISTENTE, idLocal.ToString());
                }

                foreach (CategoriaEquipamento c in local_.First().RestricoesCategoriaEquipamento.ToList())
                {
                    Categorias.Remove(c);
                }
            }

            return(Categorias);
        }
Пример #18
0
        public static void CadastrarPorLocal(int idRecurso, int idLocal, int qtde)
        {
            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var recurso_ = from Recurso r in context.Recursos
                               where r.Id == idRecurso
                               select r;

                if (recurso_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.RECURSOINEXISTENTE, idRecurso.ToString());
                }

                var local_ = from Local l in context.Locais
                             where l.Id == idLocal
                             select l;

                if (local_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.LOCALINEXISTENTE, idLocal.ToString());
                }

                RecursoLocal rl = new RecursoLocal();
                rl.Recurso = recurso_.First();
                rl.Local   = local_.First();
                rl.Qtde    = qtde;
                context.RecursosLocais.Add(rl);
                context.SaveChanges();
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <param name="verificaQtde">Verifica se existe algum dia/turno/horário com o limite de reservas daquele equipamento.</param>
        public static void Remover(int id, bool verificaQtde)
        {
            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var equipamento_ = from Equipamento e in context.Equipamentos.Include("CategoriaEquipamento")
                                   where e.Id == id
                                   select e;

                if (equipamento_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.EQUIPAMENTOINEXISTENTE, id.ToString());
                }

                int idCategoria = equipamento_.First().CategoriaEquipamento.Id;

                if (verificaQtde)
                {
                    var categoria_ = from CategoriaEquipamento ce in context.Categorias.Include("Equipamentos")
                                     where ce.Id == idCategoria
                                     select ce;

                    if (categoria_.Count() == 0)
                    {
                        throw new EntidadesException(EntityExcCode.CATEGORIAINEXISTENTE, id.ToString());
                    }

                    CategoriaEquipamento categoria = categoria_.First();
                    int      qtdeCategoria         = categoria_.First().Equipamentos.Where(e => e.Disponivel).Count();
                    DateTime ontem = DateTime.Today.AddDays(-1);

                    var reservas_ = from Reserva r in context.Reservas
                                    where r.Data > ontem &&
                                    (from c in r.CategoriasEquipamentos
                                     where c.Id == categoria.Id
                                     select c).Count() > 0
                                    group r by new { r.Data, r.Turno, r.Horario } into g
                    where g.Count() >= qtdeCategoria
                        select new { Reserva = g.Key, Qtde = g.Count() };

                    if (reservas_.Count() > 0)
                    {
                        string info = "";
                        foreach (var r in reservas_)
                        {
                            info += String.Format("[{0} {1} {2}] ", r.Reserva.Data.ToShortDateString(),
                                                  r.Reserva.Turno, r.Reserva.Horario);
                        }
                        throw new EntidadesException(EntityExcCode.EQUIPAMENTONOLIMITEDERESERVAS, info);
                    }
                }

                context.Equipamentos.Remove(equipamento_.First());
                context.SaveChanges();
            }
        }
Пример #20
0
        public static int Cadastrar(string nome, string email, TIPOUSUARIO tipo)
        {
            Usuario usuario = null;

            if (nome == null || nome.Length == 0)
            {
                throw new EntidadesException(EntityExcCode.NOMEUSUARIOVAZIO, "");
            }

            Regex regexEmail = new Regex(@"^(([^<>()[\]\\.,;:\s@\""]+"
                                         + @"(\.[^<>()[\]\\.,;:\s@\""]+)*)|(\"".+\""))@"
                                         + @"((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}"
                                         + @"\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+"
                                         + @"[a-zA-Z]{2,}))$");

            if (!regexEmail.IsMatch(email))
            {
                throw new EntidadesException(EntityExcCode.EMAILINVALIDO, email);
            }

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var usuario_ = from Usuario u in context.Usuarios
                               where u.Email == email
                               select u;

                if (usuario_.Count() > 0)
                {
                    throw new EntidadesException(EntityExcCode.EMAILJACADASTRADO, email);
                }
                else
                {
                    usuario       = new Usuario();
                    usuario.Nome  = nome;
                    usuario.Email = email;
                    usuario.Tipo  = tipo;
                    usuario.Senha = Util.GerarHashMd5("123456"); //Senha temparária até envio do e-mail com nova senha

                    context.Usuarios.Add(usuario);
                    context.SaveChanges();
                }
            }

            try
            {
                EnviarNovaSenha(email);
            }
            catch (Exception ex)
            {
                throw new EntidadesException(EntityExcCode.SENHANAOENVIADA, ex.Message);
            }

            return(usuario.Id);
        }
Пример #21
0
        public static List <Usuario> ConsultarUsuarios()
        {
            List <Usuario> Usuarios = new List <Usuario>();

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var usuarios_ = from Usuario u in context.Usuarios
                                select u;

                Usuarios = usuarios_.ToList();
            }

            return(Usuarios);
        }
Пример #22
0
        public static List <CategoriaEquipamento> ConsultarCategorias()
        {
            List <CategoriaEquipamento> Categorias = new List <CategoriaEquipamento>();

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var categorias_ = from CategoriaEquipamento ce in context.Categorias
                                  select ce;

                Categorias = categorias_.ToList();
            }

            return(Categorias);
        }
Пример #23
0
        public static List <Local> Consultar()
        {
            List <Local> Locais = new List <Local>();

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var local_ = from Local l in context.Locais
                             select l;

                Locais = local_.ToList();
            }

            return(Locais);
        }
Пример #24
0
        public static List <Recurso> Consultar()
        {
            List <Recurso> Recursos = new List <Recurso>();

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var recurso_ = from Recurso r in context.Recursos
                               select r;

                Recursos = recurso_.ToList();
            }

            return(Recursos);
        }
        public static List <Equipamento> Consultar()
        {
            List <Equipamento> Equipamentos = new List <Equipamento>();

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var equipamento_ = from Equipamento e in context.Equipamentos.Include("CategoriaEquipamento")
                                   select e;

                Equipamentos = equipamento_.ToList();
            }

            return(Equipamentos);
        }
Пример #26
0
        public static List <Local> ConsultarReservaveis(bool disponivel)
        {
            List <Local> Locais = new List <Local>();

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var equipamento_ = from Local l in context.Locais
                                   where l.Reservavel && l.Disponivel == disponivel
                                   select l;

                Locais = equipamento_.ToList();
            }

            return(Locais);
        }
Пример #27
0
        public static void Atualizar(int idUsuario, string nome, string email, TIPOUSUARIO tipo)
        {
            if (nome == null || nome.Length == 0)
            {
                throw new EntidadesException(EntityExcCode.NOMEUSUARIOVAZIO, "");
            }

            Regex regexEmail = new Regex(@"^(([^<>()[\]\\.,;:\s@\""]+"
                                         + @"(\.[^<>()[\]\\.,;:\s@\""]+)*)|(\"".+\""))@"
                                         + @"((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}"
                                         + @"\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+"
                                         + @"[a-zA-Z]{2,}))$");

            if (!regexEmail.IsMatch(email))
            {
                throw new EntidadesException(EntityExcCode.EMAILINVALIDO, email);
            }

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var usuario1_ = from Usuario u in context.Usuarios
                                where u.Id == idUsuario
                                select u;

                if (usuario1_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.IDUSUARIONAOCADASTRADO, idUsuario.ToString());
                }

                var usuario2_ = from Usuario u in context.Usuarios
                                where u.Email == email
                                select u;

                if (usuario2_.Count() > 0 && !usuario1_.First().Email.Equals(email))
                {
                    throw new EntidadesException(EntityExcCode.EMAILJACADASTRADO, email);
                }

                Usuario usuario = usuario1_.First();
                usuario.Nome  = nome;
                usuario.Email = email;
                usuario.Tipo  = tipo;

                context.SaveChanges();
            }
        }
Пример #28
0
        public static List <Reserva> Consultar()
        {
            List <Reserva> Reservas = new List <Reserva>();

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                DateTime ontem     = DateTime.Today.AddDays(-1);
                var      reservas_ = from Reserva r in context.Reservas.Include("Local")
                                     .Include("CategoriasEquipamentos").Include("Usuario")
                                     where r.Data > ontem
                                     select r;

                Reservas = reservas_.ToList();
            }

            return(Reservas);
        }
Пример #29
0
        public static CategoriaEquipamento ConsultarCategoriaPorId(int idCategoria)
        {
            CategoriaEquipamento categoria = null;

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var categoria_ = from CategoriaEquipamento ce in context.Categorias
                                 where ce.Id == idCategoria
                                 select ce;

                if (categoria_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.CATEGORIAINEXISTENTE, idCategoria.ToString());
                }

                categoria = categoria_.First();
            }

            return(categoria);
        }
Пример #30
0
        public static Local ConsultarPorId(int id)
        {
            Local local = null;

            using (Uni7ReservasEntities context = new Uni7ReservasEntities())
            {
                var local_ = from Local l in context.Locais
                             where l.Id == id
                             select l;

                if (local_.Count() == 0)
                {
                    throw new EntidadesException(EntityExcCode.LOCALINEXISTENTE, id.ToString());
                }

                local = local_.First();
            }

            return(local);
        }