Example #1
0
        public ActionResult SendMessage(Int32 idGroup, String txMessage)
        {
            try
            {
                Mensagem sentMessage = new Mensagem
                {
                    IdUsuario  = Convert.ToInt32(HttpContext.User.Identity.Name),
                    TxMensagem = txMessage,
                    IdGrupo    = idGroup,
                    DtMensagem = DateTime.Now
                };

                sentMessage.Encrypt(idGroup, _context);

                _context.Mensagens.Add(sentMessage);
                _context.SaveChanges();

                sentMessage.Grupo = _context.Grupos.Where(g => g.IdGrupo == sentMessage.IdGrupo).FirstOrDefault().Decrypt();
                new Chat().Send(sentMessage);

                return(new HttpStatusCodeResult(HttpStatusCode.OK));
            }
            catch (Exception ex)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ex)));
            }
        }
Example #2
0
        public ActionResult Edit(Int32 idArtigo, String nmObjeto, String txDescricao, String txArtigo, List <InteresseVM> tags)
        {
            try
            {
                if (tags == null || tags.Count == 0)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, "É necessário selecionar ao menos 1 tema para o artigo"));
                }

                Artigo artigo = _context.Artigos.Where(a => a.IdArtigo == idArtigo).Include(a => a.Objeto).FirstOrDefault().Decrypt(_context);
                artigo.Objeto.NmObjeto    = nmObjeto;
                artigo.Objeto.TxDescricao = txDescricao;

                artigo.TxArtigo = txArtigo;
                artigo.Encrypt(_context);

                artigo.Objeto.Temas = new List <Tema>();
                foreach (InteresseVM interesse in tags)
                {
                    artigo.Objeto.Temas.Add(_context.Temas.Where(t => t.NmTema == interesse.NmInteresse).FirstOrDefault());
                }


                _context.Entry(artigo).State = EntityState.Modified;
                _context.SaveChanges();
                return(new HttpStatusCodeResult(HttpStatusCode.OK));
            }
            catch (Exception ex)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ex)));
            }
        }
Example #3
0
        public ActionResult Create(String nmObjeto, String txDescricao, String txArtigo, List <InteresseVM> tags)
        {
            try
            {
                if (tags == null || tags.Count == 0)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, "É necessário selecionar ao menos 1 tema para o artigo"));
                }

                Usuario usuarioLogado = AccountFacade.GetLoggedInUser();

                List <Objeto> objetos = (new CoeusProjectContext()).Objetos.Where(o => o.IdUsuario == usuarioLogado.IdUsuario).Decrypt();

                if (objetos.Where(o => o.NmObjeto == nmObjeto).Count() > 0)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.OK));
                }

                Artigo artigo = new Artigo()
                {
                    Objeto = new Objeto()
                    {
                        IdUsuario   = usuarioLogado.IdUsuario,
                        Salt        = Salt.GetSalt(),
                        NmObjeto    = nmObjeto,
                        TxDescricao = txDescricao
                    },
                    TxArtigo = txArtigo
                };

                artigo.Objeto.Temas = new List <Tema>();

                foreach (InteresseVM interesse in tags)
                {
                    artigo.Objeto.Temas.Add(_context.Temas.Where(t => t.NmTema == interesse.NmInteresse).FirstOrDefault());
                }

                _context.Artigos.Add(artigo.Encrypt(_context));

                Grupo artigoGrupo = new Grupo()
                {
                    IdObjeto = artigo.IdObjeto,
                    Salt     = Salt.GetSalt(),
                    Usuarios = new List <Usuario> {
                        _context.Usuarios.Where(u => u.IdUsuario == usuarioLogado.IdUsuario).FirstOrDefault()
                    },
                    NmGrupo = nmObjeto
                };

                _context.Grupos.Add(artigoGrupo.Encrypt(_context));
                _context.SaveChanges();
                return(new HttpStatusCodeResult(HttpStatusCode.OK));
            }
            catch (Exception ex)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ex)));
            }
        }
        public ActionResult Edit(Int32 idGrupo, String nmGrupo, List <Usuario> usuarios)
        {
            try
            {
                Grupo grupo = _context.Grupos.Where(g => g.IdGrupo == idGrupo).Include(g => g.Usuarios).FirstOrDefault().Decrypt();
                if (grupo == null)
                {
                    throw new Exception("Grupo inexistente");
                }

                List <Usuario> usuariosGrupo = grupo.Usuarios.ToList();

                if (String.IsNullOrEmpty(nmGrupo))
                {
                    throw new Exception("Nome inválido para o grupo");
                }

                if (usuarios == null || usuarios.Count() == 0)
                {
                    throw new Exception("É necessário selecionar algum usuário para o grupo");
                }

                grupo.NmGrupo = nmGrupo;

                for (int i = usuariosGrupo.Count() - 1; i >= 0; i--)
                {
                    if (usuarios.Where(u => u.IdUsuario == usuariosGrupo[i].IdUsuario).Count() == 0)
                    {
                        grupo.Usuarios.Remove(usuariosGrupo[i]);
                    }
                }

                for (int i = usuarios.Count() - 1; i >= 0; i--)
                {
                    if (usuariosGrupo.Where(ug => ug.IdUsuario == usuarios[i].IdUsuario).Count() == 0)
                    {
                        Int32 idUsuarioAdded = usuarios[i].IdUsuario;
                        grupo.Usuarios.Add(_context.Usuarios.Where(u => u.IdUsuario == idUsuarioAdded).FirstOrDefault());
                    }
                }

                Usuario usuarioLogado = AccountFacade.GetLoggedInUser();
                if (grupo.Usuarios.Where(u => u.IdUsuario == usuarioLogado.IdUsuario).Count() == 0)
                {
                    grupo.Usuarios.Add(_context.Usuarios.Where(u => u.IdUsuario == usuarioLogado.IdUsuario).FirstOrDefault());
                }

                grupo.Encrypt();
                _context.Entry(grupo).State = EntityState.Modified;
                _context.SaveChanges();
                return(new HttpStatusCodeResult(HttpStatusCode.OK));
            }
            catch (Exception ex)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ex)));
            }
        }
        public ActionResult Create(String nmGrupo, List <Usuario> usuarios)
        {
            try
            {
                if (String.IsNullOrEmpty(nmGrupo))
                {
                    throw new Exception("O nome do grupo é obrigatório");
                }

                if (usuarios == null || usuarios.Count() == 0)
                {
                    throw new Exception("É necessário selecionar algum usuário para o grupo");
                }

                Grupo grupo = new Grupo
                {
                    NmGrupo  = nmGrupo,
                    Usuarios = new List <Usuario>(),
                    Salt     = Salt.GetSalt()
                };

                foreach (Usuario usuario in usuarios)
                {
                    Usuario grupoUser = _context.Usuarios.Where(u => u.IdUsuario == usuario.IdUsuario).FirstOrDefault();
                    if (grupoUser == null || grupo.Usuarios.Contains(grupoUser))
                    {
                        continue;
                    }

                    grupo.Usuarios.Add(grupoUser);
                }

                Usuario usuarioLogado = AccountFacade.GetLoggedInUser();
                if (grupo.Usuarios.Where(u => u.IdUsuario == usuarioLogado.IdUsuario).Count() == 0)
                {
                    grupo.Usuarios.Add(_context.Usuarios.Where(u => u.IdUsuario == usuarioLogado.IdUsuario).FirstOrDefault());
                }

                grupo.Encrypt();
                _context.Grupos.Add(grupo);
                _context.SaveChanges();

                return(new HttpStatusCodeResult(HttpStatusCode.OK));
            }
            catch (Exception ex)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ex)));
            }
        }
        public ActionResult Create(String nmObjeto, String txDescricao, String txUrl, String txUrlPoster, List <InteresseVM> tags)
        {
            try
            {
                if (tags == null || tags.Count == 0)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, "É necessário selecionar ao menos 1 tema para o vídeo"));
                }

                Usuario usuarioLogado = AccountFacade.GetLoggedInUser();

                List <Objeto> objetos = (new CoeusProjectContext()).Objetos.Where(o => o.IdUsuario == usuarioLogado.IdUsuario).Decrypt();

                if (objetos.Where(o => o.NmObjeto == nmObjeto).Count() > 0)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.OK));
                }

                Video video = new Video()
                {
                    Objeto = new Objeto()
                    {
                        IdUsuario   = usuarioLogado.IdUsuario,
                        Salt        = Salt.GetSalt(),
                        NmObjeto    = nmObjeto,
                        TxDescricao = txDescricao
                    },
                    TxUrl       = txUrl,
                    TxUrlPoster = (new FileController()).FormatPoster(txUrlPoster)
                };

                video.Objeto.Temas = new List <Tema>();

                foreach (InteresseVM interesse in tags)
                {
                    video.Objeto.Temas.Add(_context.Temas.Where(t => t.NmTema == interesse.NmInteresse).FirstOrDefault());
                }

                _context.Videos.Add(video.Encrypt(_context));
                _context.SaveChanges();
                return(new HttpStatusCodeResult(HttpStatusCode.OK));
            }
            catch (Exception ex)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ex)));
            }
        }
Example #7
0
        public ActionResult Login(Usuario usuario, Boolean flContinuarConectado)
        {
            if (ModelState.IsValid)
            {
                List <Usuario> usuarios = _context.Usuarios.Include(u => u.Salt).Decrypt();

                Usuario user = usuarios.Where(u => u.TxEmail == usuario.TxEmail).FirstOrDefault();

                if (user == null || user.PwUsuario != SecurityFacade.Encrypt(usuario.PwUsuario, user.Salt.BtSalt))
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, "E-mail ou senha inválidos"));
                }

                AccountFacade.Login(user, flContinuarConectado);
                return(Content(Url.Action("Index", "Home")));
            }
            return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ModelState)));
        }
        public ActionResult Edit(Int32 idArtigo, String nmObjeto, String txDescricao, String txArtigo)
        {
            try
            {
                Artigo artigo = _context.Artigos.Where(a => a.IdArtigo == idArtigo).Include(a => a.Objeto).FirstOrDefault().Decrypt(_context);
                artigo.Objeto.NmObjeto    = nmObjeto;
                artigo.Objeto.TxDescricao = txDescricao;

                artigo.TxArtigo = txArtigo;
                artigo.Encrypt(_context);

                _context.Entry(artigo).State = EntityState.Modified;
                _context.SaveChanges();
                return(new HttpStatusCodeResult(HttpStatusCode.OK));
            }
            catch (Exception ex)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ex)));
            }
        }
Example #9
0
        public ActionResult Register(Usuario usuario, List <InteresseVM> interesses)
        {
            if ((new CoeusProjectContext()).Usuarios.Decrypt().Where(u => u.TxEmail == usuario.TxEmail).Count() > 0)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, "O e-mail informado já pertence à outro usuário"));
            }

            if (interesses == null || interesses.Count() == 0)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.Forbidden, "É necessário selecionar ao menos um interesse"));
            }

            usuario.Temas = new List <Tema>();
            foreach (InteresseVM interesse in interesses)
            {
                usuario.Temas.Add(_context.Temas.Where(t => t.NmTema == interesse.NmInteresse).FirstOrDefault());
            }

            usuario.NmFoto = (new FileController()).FormatImage(usuario.NmFoto);
            usuario.Salt   = Salt.GetSalt(0, _context);

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Usuarios.Add(usuario.Encrypt(_context));
                    _context.SaveChanges();

                    AccountFacade.Login(usuario, false);
                    return(Content(Url.Action("Index", "Home")));
                }
                catch (Exception ex)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ex)));
                }
            }

            return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ModelState)));
        }
Example #10
0
        public ActionResult Edit(Usuario usuario, List <InteresseVM> interesses)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    Usuario usuarioEdit = _context.Usuarios.Include(u => u.Temas).Where(u => u.IdUsuario == usuario.IdUsuario).FirstOrDefault().Decrypt();
                    usuarioEdit.TxEmail   = usuario.TxEmail;
                    usuarioEdit.NmPessoa  = usuario.NmPessoa;
                    usuarioEdit.SnPessoa  = usuario.SnPessoa;
                    usuarioEdit.PwUsuario = usuario.PwUsuario;

                    if (interesses != null && interesses.Count() > 0)
                    {
                        if (usuarioEdit.Temas == null)
                        {
                            usuarioEdit.Temas = new List <Tema>();
                        }

                        usuarioEdit.Temas.Clear();

                        foreach (InteresseVM interesse in interesses)
                        {
                            usuarioEdit.Temas.Add(_context.Temas.Where(t => t.NmTema == interesse.NmInteresse).FirstOrDefault());
                        }
                    }

                    _context.Entry(usuarioEdit.Encrypt()).State = EntityState.Modified;
                    _context.SaveChanges();
                    return(Content(Url.Action("Index", "Home")));
                }
                catch (Exception ex)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ex)));
                }
            }
            return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ModelState)));
        }