public void PopularPublicacoesProjeto(UsuarioProfissional autor)
        {
            string            connectionString;
            StringBuilder     query             = null;
            SqlConnection     connection        = null;
            SqlCommand        command           = null;
            SqlDataReader     dataReader        = null;
            PublicacaoProjeto publicacaoProjeto = null;

            try
            {
                autor.Publicacoes = new List <Publicacao>();

                query = new StringBuilder();
                query.Append("SELECT ");
                query.Append("  PP.Id, ");
                query.Append("	PP.Titulo, ");
                query.Append("	PP.Conteudo, ");
                query.Append("  PU.DataHoraPublicado ");
                query.Append("FROM PublicacoesProjeto PP ");
                query.Append("    INNER JOIN Publicacoes PU ON PP.Id = PU.Id ");
                query.Append("    INNER JOIN Usuarios US ON PU.IdUsuario = US.Id ");
                query.Append("WHERE US.Id = @Id");

                connectionString = WebConfigurationManager.ConnectionStrings["ConnectionEstudo"].ConnectionString;
                using (connection = new SqlConnection(connectionString))
                {
                    using (command = connection.CreateCommand())
                    {
                        command.CommandType = CommandType.Text;
                        command.CommandText = query.ToString();
                        command.Parameters.AddWithValue("@Id", autor.Id);

                        connection.Open();
                        using (dataReader = command.ExecuteReader())
                        {
                            if (dataReader.HasRows)
                            {
                                dataReader.Read();
                                publicacaoProjeto                   = new PublicacaoProjeto();
                                publicacaoProjeto.Id                = (int)dataReader["Id"];
                                publicacaoProjeto.Titulo            = dataReader["Titulo"].ToString();
                                publicacaoProjeto.Conteudo          = JsonConvert.DeserializeObject <List <ItemPublicacao> >(dataReader["Conteudo"].ToString());
                                publicacaoProjeto.DataHoraPublicado = (DateTime)dataReader["DataHoraPublicado"];
                                autor.Publicacoes.Add(publicacaoProjeto);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
            }
        }
        public ActionResult AbrirPublicacaoProjeto(int id)
        {
            Usuario usuario = null;
            DAOPublicacaoProjeto daoPublicacaoProjeto = null;
            PublicacaoProjeto    publicacaoProjeto    = null;
            string masterName = null;

            try
            {
                daoPublicacaoProjeto = new DAOPublicacaoProjeto();
                publicacaoProjeto    = daoPublicacaoProjeto.ObterPublicacaoProjeto(id);

                usuario = (Usuario)Session["Usuario"];
                if (usuario == null)
                {
                    if (publicacaoProjeto != null)
                    {
                        return(View("PublicacaoProjetoVisitante", "_LayoutVisitante", publicacaoProjeto));
                    }
                    else
                    {
                        return(Json("Deu ruim aqui")); // Tratar este caso.
                    }
                }

                switch (usuario.Perfil)
                {
                case Usuario.TipoPerfil.UsuarioParticular:
                    masterName = "_LayoutUsuarioParticular";
                    break;

                case Usuario.TipoPerfil.UsuarioProfissional:
                    masterName = "_LayoutUsuarioProfissional";
                    break;

                default:
                    masterName = "_LayoutVisitante";
                    break;
                }

                if (publicacaoProjeto != null)
                {
                    return(View("PublicacaoProjeto", masterName, publicacaoProjeto));
                }
                else
                {
                    return(Json("Deu ruim aqui")); // Tratar esse caso.
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public PublicacaoProjeto ObterPublicacaoProjeto(int idPublicacaoProjeto)
        {
            string            connectionString;
            StringBuilder     query             = null;
            SqlConnection     connection        = null;
            SqlCommand        command           = null;
            SqlDataReader     dataReader        = null;
            PublicacaoProjeto publicacaoProjeto = null;
            Usuario           usuario           = null;

            try
            {
                query = new StringBuilder();
                query.Append("SELECT ");
                query.Append("  PP.Id, ");
                query.Append("	PP.Titulo, ");
                query.Append("	PP.Conteudo, ");
                query.Append("  PU.DataHoraPublicado, ");
                query.Append("  US.Id AS IdAutor, ");
                query.Append("  US.Nome AS NomeAutor, ");
                query.Append("  US.Email AS EmailAutor ");
                query.Append("FROM PublicacoesProjeto PP ");
                query.Append("    INNER JOIN Publicacoes PU ON PP.Id = PU.Id ");
                query.Append("    INNER JOIN Usuarios US ON PU.IdUsuario = US.Id ");
                query.Append("WHERE PP.Id = @Id");

                connectionString = WebConfigurationManager.ConnectionStrings["ConnectionEstudo"].ConnectionString;
                using (connection = new SqlConnection(connectionString))
                {
                    using (command = connection.CreateCommand())
                    {
                        command.CommandType = CommandType.Text;
                        command.CommandText = query.ToString();
                        command.Parameters.AddWithValue("@Id", idPublicacaoProjeto);

                        connection.Open();
                        using (dataReader = command.ExecuteReader())
                        {
                            if (dataReader.HasRows)
                            {
                                dataReader.Read();
                                publicacaoProjeto                   = new PublicacaoProjeto();
                                publicacaoProjeto.Id                = (int)dataReader["Id"];
                                publicacaoProjeto.Titulo            = dataReader["Titulo"].ToString();
                                publicacaoProjeto.Conteudo          = JsonConvert.DeserializeObject <List <ItemPublicacao> >(dataReader["Conteudo"].ToString());
                                publicacaoProjeto.DataHoraPublicado = (DateTime)dataReader["DataHoraPublicado"];

                                usuario                 = new Usuario();
                                usuario.Id              = (int)dataReader["IdAutor"];
                                usuario.Nome            = dataReader["NomeAutor"].ToString();
                                usuario.Email           = dataReader["EmailAutor"].ToString();
                                publicacaoProjeto.Autor = usuario;
                            }
                        }
                    }
                }

                return(publicacaoProjeto);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
            }
        }
        public bool IncluirPublicacaoProjeto(PublicacaoProjeto novaPublicacaoProjeto)
        {
            SqlConnection         connection = null;
            StringBuilder         query      = null;
            SqlCommand            command    = null;
            DateTime              dataHoraRegistrada;
            string                connectionString;
            DAOEtiquetaPublicacao daoEtiquetaPublicacao = null;
            EtiquetaPublicacao    etiquetaPublicacao    = null;

            try
            {
                dataHoraRegistrada = DateTime.Now;

                query = new StringBuilder();
                query.Append("BEGIN TRANSACTION ");
                query.Append("INSERT INTO Publicacoes ( ");
                query.Append("	IdTipo, ");
                query.Append("	DataHoraPublicado, ");
                query.Append("	IdUsuario ");
                query.Append(") VALUES ( ");
                query.Append("	@IdTipo, ");
                query.Append("	@DataHoraPublicado, ");
                query.Append("	@IdUsuario); ");
                query.Append("SET @IdPublicacao = SCOPE_IDENTITY(); ");
                query.Append("INSERT INTO PublicacoesProjeto ( ");
                query.Append("	Id, ");
                query.Append("	Titulo, ");
                query.Append("	PathImagemCapa, ");
                query.Append("	Conteudo ");
                query.Append(") VALUES ( ");
                query.Append("	@IdPublicacao, ");
                query.Append("	@Titulo, ");
                query.Append("	@PathImagemCapa, ");
                query.Append("	@Conteudo); ");
                query.Append("COMMIT");

                connectionString = WebConfigurationManager.ConnectionStrings["ConnectionEstudo"].ConnectionString;
                using (connection = new SqlConnection(connectionString))
                {
                    using (command = connection.CreateCommand())
                    {
                        command.CommandType = CommandType.Text;
                        command.CommandText = query.ToString();

                        command.Parameters.AddWithValue("@IdTipo", (int)novaPublicacaoProjeto.Tipo);
                        command.Parameters.AddWithValue("@DataHoraPublicado", dataHoraRegistrada);
                        command.Parameters.AddWithValue("@IdUsuario", novaPublicacaoProjeto.Autor.Id);
                        command.Parameters.AddWithValue("@Titulo", novaPublicacaoProjeto.Titulo);
                        command.Parameters.AddWithValue("@PathImagemCapa", novaPublicacaoProjeto.PathImagemCapa);
                        command.Parameters.AddWithValue("@Conteudo", JsonConvert.SerializeObject(novaPublicacaoProjeto.Conteudo));
                        command.Parameters.Add("@IdPublicacao", SqlDbType.Int).Direction = ParameterDirection.Output;

                        connection.Open();
                        if (command.ExecuteNonQuery() > 0)
                        {
                            novaPublicacaoProjeto.Id = (int)command.Parameters["@IdPublicacao"].Value;
                            novaPublicacaoProjeto.DataHoraPublicado = dataHoraRegistrada;
                        }
                        else
                        {
                            return(false);
                        }
                    }
                }

                daoEtiquetaPublicacao = new DAOEtiquetaPublicacao();
                foreach (EtiquetaPublicacao etiqueta in novaPublicacaoProjeto.Etiquetas)
                {
                    etiquetaPublicacao = daoEtiquetaPublicacao.ObterEtiqueta(etiqueta.Nome);
                    if (etiquetaPublicacao == null)
                    {
                        etiquetaPublicacao      = new EtiquetaPublicacao();
                        etiquetaPublicacao.Nome = etiqueta.Nome;
                        daoEtiquetaPublicacao.IncluirEtiqueta(etiquetaPublicacao);
                    }
                    daoEtiquetaPublicacao.IncluirAssociacao(novaPublicacaoProjeto.Id, etiquetaPublicacao.Id);
                }

                return(true);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public JsonResult SalvarPublicacaoProjeto()
        {
            DAOPublicacaoProjeto daoPublicacaoProjeto = null;
            Usuario            usuario = null;
            PublicacaoProjeto  novaPublicacaoProjeto = null;
            string             pathImagem;
            string             pathImagemCapa;
            ItemPublicacao     itemPublicacao = null;
            HttpPostedFile     postedFile     = null;
            Image              imagem         = null;
            EtiquetaPublicacao etiqueta       = null;

            try
            {
                usuario = (Usuario)Session["Usuario"];

                novaPublicacaoProjeto        = new PublicacaoProjeto();
                novaPublicacaoProjeto.Autor  = usuario;
                novaPublicacaoProjeto.Titulo = System.Web.HttpContext.Current.Request.Form["txtTitulo"];

                postedFile     = System.Web.HttpContext.Current.Request.Files["fileImagemCapa"];
                imagem         = Bitmap.FromStream(postedFile.InputStream);
                pathImagemCapa = @"\ImagensPublicacoes\" + postedFile.FileName;
                imagem.Save(System.Web.HttpContext.Current.Server.MapPath("~") + @"\ImagensPublicacoes\" + postedFile.FileName);
                novaPublicacaoProjeto.PathImagemCapa = pathImagemCapa;

                int postedFilePosition;
                foreach (string elementName in Request.Form.AllKeys)
                {
                    if (elementName.StartsWith("txtParagrafo"))
                    {
                        itemPublicacao = new ItemPublicacao("Paragrafo", Request.Form[elementName]);
                        novaPublicacaoProjeto.Conteudo.Add(itemPublicacao);
                    }
                    else if (elementName.StartsWith("hiddenImagePosition"))
                    {
                        postedFilePosition = Int32.Parse(Request.Form[elementName]);
                        postedFile         = System.Web.HttpContext.Current.Request.Files[postedFilePosition];
                        imagem             = Bitmap.FromStream(postedFile.InputStream);
                        pathImagem         = @"\ImagensPublicacoes\" + postedFile.FileName;
                        imagem.Save(System.Web.HttpContext.Current.Server.MapPath("~") + @"\ImagensPublicacoes\" + postedFile.FileName);
                        itemPublicacao = new ItemPublicacao("Imagem", pathImagem);
                        novaPublicacaoProjeto.Conteudo.Add(itemPublicacao);
                    }
                }

                string etiquetas = System.Web.HttpContext.Current.Request.Form["etiquetas"].ToString();
                foreach (string tagName in etiquetas.Split(','))
                {
                    etiqueta      = new EtiquetaPublicacao();
                    etiqueta.Nome = tagName;
                    novaPublicacaoProjeto.Etiquetas.Add(etiqueta);
                }

                daoPublicacaoProjeto = new DAOPublicacaoProjeto();
                if (daoPublicacaoProjeto.IncluirPublicacaoProjeto(novaPublicacaoProjeto))
                {
                    return(Json("Aew salvou!"));
                }
                else
                {
                    return(Json("Deu ruim pra salvar a imagem hein..."));
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Esempio n. 6
0
        public List <Publicacao> ObterPublicacoes()
        {
            string                connectionString;
            StringBuilder         query                 = null;
            SqlConnection         connection            = null;
            SqlCommand            command               = null;
            SqlDataReader         dataReader            = null;
            Usuario               autor                 = null;
            Imagem                imagem                = null;
            PublicacaoImagem      publicacaoImagem      = null;
            PublicacaoProjeto     publicacaoProjeto     = null;
            PublicacaoAntesDepois publicacaoAntesDepois = null;
            List <Publicacao>     listaPublicacoes      = null;

            try
            {
                listaPublicacoes = new List <Publicacao>();

                query = new StringBuilder();
                query.Append("SELECT ");
                query.Append("    P.Id, ");
                query.Append("    P.IdTipo, ");
                query.Append("    P.DataHoraPublicado, ");
                query.Append("    P.IdUsuario AS IdAutorPublicacao, ");
                query.Append("    U.Nome AS NomeAutor, ");
                query.Append("    U.Email AS EmailAutor, ");
                query.Append("    PI.IdImagem, ");
                query.Append("    I.Legenda AS LegendaImagem, ");
                query.Append("    I.DataHoraInclusao, ");
                query.Append("    I.PathImagem, ");
                query.Append("    PP.Titulo AS TituloProjeto, ");
                query.Append("    PP.Conteudo AS ConteudoPublicacaoProjeto, ");
                query.Append("    PAD.PathImagemAntes, ");
                query.Append("    PAD.PathImagemDepois, ");
                query.Append("    PAD.Titulo AS TituloAntesDepois, ");
                query.Append("    PAD.Texto AS TextoAntesDepois ");
                query.Append("FROM Publicacoes P ");
                query.Append("    LEFT JOIN Usuarios U ON P.Id = U.Id ");
                query.Append("    LEFT JOIN PublicacoesImagem PI ON P.Id = PI.Id ");
                query.Append("    LEFT JOIN Imagens I ON PI.IdImagem = I.Id ");
                query.Append("    LEFT JOIN PublicacoesProjeto PP ON P.Id = PP.Id ");
                query.Append("    LEFT JOIN PublicacoesAntesDepois PAD ON P.Id = PAD.Id");

                connectionString = WebConfigurationManager.ConnectionStrings["ConnectionEstudo"].ConnectionString;
                using (connection = new SqlConnection(connectionString))
                {
                    using (command = connection.CreateCommand())
                    {
                        command.CommandType = CommandType.Text;
                        command.CommandText = query.ToString();

                        connection.Open();
                        using (dataReader = command.ExecuteReader())
                        {
                            listaPublicacoes = new List <Publicacao>();
                            while (dataReader.Read())
                            {
                                switch ((int)dataReader["IdTipo"])
                                {
                                case (int)Publicacao.TipoPublicacao.PublicacaoImagem:
                                    autor       = new Usuario();
                                    autor.Id    = (int)dataReader["IdAutorPublicacao"];
                                    autor.Nome  = dataReader["NomeAutor"].ToString();
                                    autor.Email = dataReader["EmailAutor"].ToString();

                                    imagem                  = new Imagem();
                                    imagem.Id               = (int)dataReader["IdImagem"];
                                    imagem.Legenda          = dataReader["LegendaImagem"].ToString();
                                    imagem.DataHoraInclusao = (DateTime)dataReader["DataHoraInclusao"];
                                    imagem.PathImagem       = dataReader["PathImagem"].ToString();
                                    imagem.Dono             = autor;

                                    publicacaoImagem                   = new PublicacaoImagem();
                                    publicacaoImagem.Id                = (int)dataReader["Id"];
                                    publicacaoImagem.Autor             = autor;
                                    publicacaoImagem.DataHoraPublicado = (DateTime)dataReader["DataHoraPublicado"];
                                    publicacaoImagem.Imagem            = imagem;

                                    listaPublicacoes.Add(publicacaoImagem);
                                    break;

                                case (int)Publicacao.TipoPublicacao.PublicacaoProjeto:
                                    autor       = new Usuario();
                                    autor.Id    = (int)dataReader["IdAutorPublicacao"];
                                    autor.Nome  = dataReader["NomeAutor"].ToString();
                                    autor.Email = dataReader["EmailAutor"].ToString();

                                    publicacaoProjeto                   = new PublicacaoProjeto();
                                    publicacaoProjeto.Id                = (int)dataReader["Id"];
                                    publicacaoProjeto.Autor             = autor;
                                    publicacaoProjeto.DataHoraPublicado = (DateTime)dataReader["DataHoraPublicado"];
                                    publicacaoProjeto.Titulo            = dataReader["TituloProjeto"].ToString();
                                    publicacaoProjeto.Conteudo          = JsonConvert.DeserializeObject <List <ItemPublicacao> >(dataReader["ConteudoPublicacaoProjeto"].ToString());

                                    listaPublicacoes.Add(publicacaoProjeto);
                                    break;

                                case (int)Publicacao.TipoPublicacao.PublicacaoAntesDepois:
                                    autor       = new Usuario();
                                    autor.Id    = (int)dataReader["IdAutorPublicacao"];
                                    autor.Nome  = dataReader["NomeAutor"].ToString();
                                    autor.Email = dataReader["EmailAutor"].ToString();

                                    publicacaoAntesDepois                   = new PublicacaoAntesDepois();
                                    publicacaoAntesDepois.Id                = (int)dataReader["Id"];
                                    publicacaoAntesDepois.Autor             = autor;
                                    publicacaoAntesDepois.DataHoraPublicado = (DateTime)dataReader["DataHoraPublicado"];
                                    publicacaoAntesDepois.PathImagemAntes   = dataReader["PathImagemAntes"].ToString();
                                    publicacaoAntesDepois.PathImagemDepois  = dataReader["PathImagemDepois"].ToString();
                                    publicacaoAntesDepois.Titulo            = dataReader["TituloAntesDepois"].ToString();
                                    publicacaoAntesDepois.Texto             = dataReader["TextoAntesDepois"].ToString();

                                    listaPublicacoes.Add(publicacaoAntesDepois);
                                    break;
                                }
                            }
                        }
                    }
                }

                return(listaPublicacoes);
            }
            finally
            {
                if (query != null)
                {
                    query = null;
                }
            }
        }
Esempio n. 7
0
        public void PopularPublicacoes(UsuarioProfissional autor)
        {
            string                connectionString;
            StringBuilder         query                 = null;
            SqlConnection         connection            = null;
            SqlCommand            command               = null;
            SqlDataReader         dataReader            = null;
            PublicacaoImagem      publicacaoImagem      = null;
            PublicacaoProjeto     publicacaoProjeto     = null;
            PublicacaoAntesDepois publicacaoAntesDepois = null;
            Imagem                imagem                = null;

            try
            {
                autor.Publicacoes = new List <Publicacao>();

                query = new StringBuilder();
                query.Append("SELECT ");
                query.Append("    P.Id, ");
                query.Append("    P.IdTipo, ");
                query.Append("    P.DataHoraPublicado, ");
                query.Append("    P.IdUsuario, ");
                query.Append("    PP.Titulo AS TituloProjeto, ");
                query.Append("    PP.Conteudo AS ConteudoPublicacaoProjeto, ");
                query.Append("    PAD.Titulo AS TituloAntesDepois, ");
                query.Append("    PAD.Texto AS TextoAntesDepois, ");
                query.Append("    PAD.PathImagemAntes, ");
                query.Append("    PAD.PathImagemDepois, ");
                query.Append("    PIM.IdImagem, ");
                query.Append("    IM.Legenda AS LegendaImagem, ");
                query.Append("    IM.DataHoraInclusao AS DataHoraInclusaoImagem, ");
                query.Append("    IM.PathImagem ");
                query.Append("FROM Publicacoes P ");
                query.Append("    LEFT JOIN PublicacoesProjeto PP ON P.Id = PP.Id ");
                query.Append("    LEFT JOIN PublicacoesAntesDepois PAD ON P.Id = PAD.Id ");
                query.Append("    LEFT JOIN PublicacoesImagem PIM ON P.Id = PIM.Id ");
                query.Append("    LEFT JOIN Imagens IM ON PIM.IdImagem = IM.Id ");
                query.Append("WHERE P.IdUsuario = @IdUsuario");

                connectionString = WebConfigurationManager.ConnectionStrings["ConnectionEstudo"].ConnectionString;
                using (connection = new SqlConnection(connectionString))
                {
                    using (command = connection.CreateCommand())
                    {
                        command.CommandType = CommandType.Text;
                        command.CommandText = query.ToString();
                        command.Parameters.AddWithValue("@IdUsuario", autor.Id);

                        connection.Open();
                        using (dataReader = command.ExecuteReader())
                        {
                            if (dataReader.HasRows)
                            {
                                while (dataReader.Read())
                                {
                                    switch ((Publicacao.TipoPublicacao)dataReader["IdTipo"])
                                    {
                                    case Publicacao.TipoPublicacao.PublicacaoImagem:
                                        publicacaoImagem                   = new PublicacaoImagem();
                                        publicacaoImagem.Id                = (int)dataReader["Id"];
                                        publicacaoImagem.Autor             = autor;
                                        publicacaoImagem.DataHoraPublicado = (DateTime)dataReader["DataHoraPublicado"];

                                        imagem                  = new Imagem();
                                        imagem.Id               = (int)dataReader["IdImagem"];
                                        imagem.Legenda          = dataReader["LegendaImagem"].ToString();
                                        imagem.PathImagem       = dataReader["PathImagem"].ToString();
                                        imagem.DataHoraInclusao = (DateTime)dataReader["DataHoraInclusaoImagem"];
                                        publicacaoImagem.Imagem = imagem;

                                        autor.Publicacoes.Add(publicacaoImagem);
                                        break;

                                    case Publicacao.TipoPublicacao.PublicacaoProjeto:
                                        publicacaoProjeto                   = new PublicacaoProjeto();
                                        publicacaoProjeto.Id                = (int)dataReader["Id"];
                                        publicacaoProjeto.Autor             = autor;
                                        publicacaoProjeto.DataHoraPublicado = (DateTime)dataReader["DataHoraPublicado"];
                                        publicacaoProjeto.Titulo            = dataReader["TituloProjeto"].ToString();
                                        publicacaoProjeto.Conteudo          = JsonConvert.DeserializeObject <List <ItemPublicacao> >(dataReader["ConteudoPublicacaoProjeto"].ToString());

                                        autor.Publicacoes.Add(publicacaoProjeto);
                                        break;

                                    case Publicacao.TipoPublicacao.PublicacaoAntesDepois:
                                        publicacaoAntesDepois                   = new PublicacaoAntesDepois();
                                        publicacaoAntesDepois.Id                = (int)dataReader["Id"];
                                        publicacaoAntesDepois.Autor             = autor;
                                        publicacaoAntesDepois.DataHoraPublicado = (DateTime)dataReader["DataHoraPublicado"];
                                        publicacaoAntesDepois.Titulo            = dataReader["TituloAntesDepois"].ToString();
                                        publicacaoAntesDepois.Texto             = dataReader["TextoAntesDepois"].ToString();
                                        publicacaoAntesDepois.PathImagemAntes   = dataReader["PathImagemAntes"].ToString();
                                        publicacaoAntesDepois.PathImagemDepois  = dataReader["PathImagemDepois"].ToString();

                                        autor.Publicacoes.Add(publicacaoAntesDepois);
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
            }
        }