protected override void OnPrepareTransactScope(UpvotePublicacaoCommand command)
{
Usuario usuario = _usuarioRepository.Find(_serviceContext.UsuarioAtualId);
Publicacao publicacao = _publicacaoRepository.Find(command.Publicacao.Id);
PublicacaoUpvote upvoteExistente = _publicacaoUpvoteRepository.PodeUpvote(publicacao, usuario);
if (upvoteExistente != null)
{
publicacao.Downvote();
_publicacaoUpvoteRepository.Delete(upvoteExistente);
return;
}
// Excluir downvote caso exista no momento do upvote
PublicacaoDownvote downvoteExistente = _publicacaoDownvoteRepository.PodeDownvote(publicacao, usuario);
if (downvoteExistente != null)
{
publicacao.Upvote();
_publicacaoDownvoteRepository.Delete(downvoteExistente);
}
publicacao.Upvote();
PublicacaoUpvote publicacaoUpvote = new PublicacaoUpvote(publicacao, usuario);
_publicacaoUpvoteRepository.Save(publicacaoUpvote);
}
public static void Executar()
{
Comentario c1 = new Comentario("Tenha uma ótima viagem!");
Comentario c2 = new Comentario("Wow que legal!");
Publicacao p1 = new Publicacao(
DateTime.Parse("07/05/2020 12:20:45"),
"Viajando para Nova Zelândia!",
"Eu estou indo visitar esse incrível país!",
12
);
p1.AdicionarComentario(c1);
p1.AdicionarComentario(c2);
Comentario c3 = new Comentario("Boa noite");
Comentario c4 = new Comentario("May the Force be with you");
Comentario c5 = new Comentario("Tenha cuidado com os pesadelos");
Publicacao p2 = new Publicacao(
DateTime.Parse("23/08/2018 15:30:17"),
"Boa noite pessoal",
"Vejo vocês amanhã",
12
);
p2.AdicionarComentario(c3);
p2.AdicionarComentario(c4);
p2.AdicionarComentario(c5);
Console.WriteLine(p1);
Console.WriteLine(p2);
}
public IActionResult AlterarDados(IFormCollection form)
{
Usuario novoUsuario = MostrarUsuario();
novoUsuario.Nome = form["Nome"];
novoUsuario.Foto = form["Foto"];
if (form.Files.Count > 0)
{
var file = form.Files[0];
var folder = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/img/perfil");
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/img/", folder, file.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
file.CopyTo(stream);
}
novoUsuario.Foto = file.FileName;
}
novoUsuario.DataNascimento = DateTime.Parse(form["DataNascimento"]);
novoUsuario.Email = form["Email"];
novoUsuario.Username = form["Username"];
usuarioModel.Update(novoUsuario);
ViewBag.UsuarioAtualizado = novoUsuario;
//Alterar form posts - início
List <string> posts = publicacaoModel.ReadAllLinesCSV(publicacaoModel._PATH);
var pub = posts.FindAll(x => x.Split(";")[3] == novoUsuario.IdUsuario.ToString());
foreach (string item in pub)
{
var file = form.Files[0];
string[] linha = item.Split(";");
Publicacao publicacao = new Publicacao();
publicacao.IdPublicacao = int.Parse(linha[0]);
publicacao.Imagem = linha[1];
publicacao.Legenda = linha[2];
publicacao.IdUsuario = int.Parse(linha[3]);
publicacao.Likes = int.Parse(linha[4]);
publicacao.FotoUsuario = file.FileName;
publicacaoModel.Update(publicacao);
}
//Alterar form posts - início
return(LocalRedirect("~/EditarPerfil"));
}
public async Task <IActionResult> Edit(int id, [Bind("AvaliacaoId,TurmaId,DataPublicacao,DataInicio,DataFim,ValorProva,Id")] Publicacao publicacao)
{
if (id != publicacao.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(publicacao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PublicacaoExists(publicacao.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AvaliacaoId"] = new SelectList(_context.Avaliacoes, "Id", "Id", publicacao.AvaliacaoId);
ViewData["TurmaId"] = new SelectList(_context.Turmas, "Id", "Id", publicacao.TurmaId);
return(View(publicacao));
}
public static bool ChecarCurtida(Publicacao post)
{
var connectionString = @"Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\DB.mdf";
using (var connection = new SqlConnection(connectionString)) {
var commandText = "SELECT * FROM Curtidas WHERE Id_Usuario=@Id_Usuario AND Post_Id=@Post_Id ";
var selectCommand = new SqlCommand(commandText, connection);// ele é um comando mas ainda não foi executado, tem que ser executado para fazer o comando.
selectCommand.Parameters.AddWithValue("@Id_Usuario", post.Id_Usuario);
selectCommand.Parameters.AddWithValue("@Post_Id", post.Post_Id);
var user = new Usuario();
bool teste = false;
try {
connection.Open();
using (var reader = selectCommand.ExecuteReader(CommandBehavior.CloseConnection)) {
if (reader.HasRows)
{
teste = true;
return(teste);
}
}
}
finally {
connection.Close();
}
return(teste);
}
}
public bool Delete(int id)
{
Publicacao publicacao = new Publicacao();
publicacao.Delete(id);
return(true);
}
public IHttpActionResult PutPublicacao(int id, Publicacao publicacao)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != publicacao.IdPublicacao)
{
return(BadRequest());
}
db.Entry(publicacao).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!PublicacaoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public bool Edit([FromBody] Publicacao f)
{
Publicacao publicacao = new Publicacao();
publicacao.Update(f);
return(true);
}
public void FiltraPublicacoes(int codServidor)
{
LimpaDGV((DataGridView)form.controlHashtable["dgvDadosPublicacoes"]);
List <ServidorPublicacao> servidoresPublicacao = servidorPublicacaoDAO.GetServidor(codServidor);
if (servidoresPublicacao != null)
{
foreach (ServidorPublicacao servpub in servidoresPublicacao)
{
Publicacao pub = publicacaoDAO.Get(servpub.IdPublicacao);
TipoAto tipo = tipoAtoDAO.Get(servpub.IdTipoAto);
string tipoNome = "";
if (tipo != null)
{
tipoNome = tipo.Nome;
}
AdicionaLinhaDGV((DataGridView)form.controlHashtable["dgvDadosPublicacoes"],
new object[] { pub.Id, tipoNome, pub.Titulo,
pub.Data.ToShortDateString(), pub.Edicao, pub.Secao,
pub.Pagina, pub.Orgao, pub.Assinatura,
pub.CargoAssinatura,
pub.Link, pub.Conteudo, pub.Criacao });
}
}
}
public bool Save([FromBody] Publicacao f)
{
Publicacao publicacao = new Publicacao();
publicacao.Create(f);
return(true);
}
protected void Button1_Click(object sender, EventArgs e)
{
var profileData = this.Session["Usuario"] as Pessoa;
using (var context = new MeuContexto())
{
Publicacao c = new Publicacao
{
Conteudo = txtPost.Text,
DataPost = DateTime.Now
};
var p = context.Pessoas.Where(s => s.PessoaID == profileData.PessoaID).FirstOrDefault <Pessoa>();
if (p.Publicacao != null)
{
p.Publicacao.Add(c);
context.Entry(p).State = System.Data.Entity.EntityState.Modified;
context.SaveChanges();
}
else
{
p.Publicacao = new List <Publicacao>();
p.Publicacao.Add(c);
context.SaveChanges();
txtPost.Text = "";
ListView1.DataSource = p.Publicacao;
ListView1.DataBind();
this.Session["Usuario"] = p;
}
}
}
public List <Publicacao> ExibirPublicacoes()
{
List <Publicacao> posts = new List <Publicacao>();
List <string> publicacoes = publicacaoModel.ReadAllLinesCSV(publicacaoModel._PATH);
string userId = HttpContext.Session.GetString("_UserId");
var pub = publicacoes.FindAll(x => x.Split(";")[3] == userId);
foreach (var item in pub)
{
string[] linha = item.Split(";");
Publicacao publicacao = new Publicacao();
publicacao.IdPublicacao = int.Parse(linha[0]);
publicacao.Imagem = linha[1];
publicacao.Legenda = linha[2];
publicacao.IdUsuario = int.Parse(linha[3]);
publicacao.Likes = int.Parse(linha[4]);
posts.Add(publicacao);
}
return(posts);
}
public async Task <string> AdicionarPublicacaoService(Publicacao model)
{
model.Id = ObjectId.GenerateNewId().ToString();
var response = await _unitOfWork.RepositoryPublicacao.AdicionarRepository(model);
return(response);
}
public async Task IncluirNovaPublicacaoAsync(DateTime dataInicio, DateTime dataFim, int valor, int idAvaliacao, IEnumerable <int> idTurma)
{
var avaliacao = await _avaliacaoRepository.ObterComRelacoesAsync(idAvaliacao);
if (avaliacao.Questoes == null || avaliacao.Questoes.Count <= 0)
{
throw new Exception("Para ser publicada uma avaliação deve conter ao menos 1 questão!");
}
if (dataInicio > dataFim)
{
throw new Exception("A data e hora de início não pode ser maior que a data e hora de fim!");
}
if (dataInicio == dataFim)
{
throw new Exception("A data e hora de início não pode ser igual a data e hora de fim!");
}
foreach (int id in idTurma)
{
var publicacao = new Publicacao()
{
DataInicio = dataInicio,
DataFim = dataFim,
Valor = valor,
IdTurma = id,
IdAvaliacao = idAvaliacao,
CriadoEm = DateTime.Now,
AtualizadoEm = DateTime.Now
};
_publicacaoRepository.Adicionar(publicacao);
await _publicacaoRepository.SaveChangesAsync();
}
}
public IActionResult Index([FromQuery] int idUsuario)
{
Usuario usuario = new Usuario();
var userId = -1;
if (idUsuario == 0)
{
userId = int.Parse(HttpContext.Session.GetString("_IdLogado"));
}
else
{
userId = idUsuario;
}
Publicacao publicacao = new Publicacao();
ViewBag.logado = int.Parse(HttpContext.Session.GetString("_IdLogado"));
ViewBag.publicacao = publicacao.AcharPostsDoUsuario(userId);
ViewBag.perfil = usuario.BuscarUsuarioPorId(userId);
ViewBag.userLogado = usuario.BuscarUsuarioPorId(int.Parse(HttpContext.Session.GetString("_IdLogado")));
return(View());
}
public FormDetalhesPublicacao(int id)
{
InitializeComponent();
IdPublicacao = id;
publicacaoDAO = new PublicacaoDAO();
publicacao = publicacaoDAO.Get(IdPublicacao);
txtTitulo.Text = publicacao.Titulo;
txtData.Text = publicacao.Data.ToShortDateString();
txtSecao.Text = publicacao.Secao.ToString();
txtEdicao.Text = publicacao.Edicao.ToString();
txtPagina.Text = publicacao.Pagina.ToString();
txtAssinatura.Text = publicacao.Assinatura;
txtLink.Text = publicacao.Link;
wbDetalhes.ScriptErrorsSuppressed = true;
wbDetalhes.DocumentText = publicacao.Conteudo;
wbDetalhes.Document.OpenNew(true);
wbDetalhes.Document.Write(publicacao.Conteudo);
wbDetalhes.Refresh();
//WebBrowser browser = new WebBrowser
//{
// ScriptErrorsSuppressed = true,
// DocumentText = html
//};
//browser.Document.OpenNew(true);
//browser.Document.Write(html);
//browser.Refresh();
}
public HttpResponseMessage Change(int idPublicacao, Publicacao publicacao)
{
try
{
if (publicacao.ImagemPublicacao.Length > 1000)
{
string path = HttpContext.Current.Server.MapPath("~/Imagens/");
var bits = Convert.FromBase64String(publicacao.ImagemPublicacao);
string nomeImagem = Guid.NewGuid().ToString() + DateTime.Now.ToString("ddMMyyHHmmss") + ".jpg";
string imgPath = Path.Combine(path, nomeImagem);
File.WriteAllBytes(imgPath, bits);
publicacao.ImagemPublicacao = nomeImagem;
}
PublicacaoRepository.EditPublicacao(publicacao, idPublicacao);
return(Request.CreateResponse(HttpStatusCode.Created + ". Publicacao alterada"));
}
catch (DbEntityValidationException ex)
{
foreach (var eve in ex.EntityValidationErrors)
{
foreach (var ve in eve.ValidationErrors)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest + ". Solicitação não atendida. " + ve.ErrorMessage));
}
}
throw;
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,DataPublicacao,Descricao")] Publicacao publicacao)
{
if (id != publicacao.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(publicacao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PublicacaoExists(publicacao.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(View(publicacao));
}
public IActionResult criarUmaPublicacao([FromBody] Publicacao publicacaoView, [FromHeader] string id_user)
{
var publicacao = new PublicacaoCore(publicacaoView, _mapper, _arquivo).cadastrarPublicacao(id_user);
return(publicacao.Status ?
Ok(publicacao) :
(IActionResult)BadRequest(publicacao));
}
public PublicacaoUpvote PodeUpvote(Publicacao publicacao, Usuario usuario)
{
return(_session.QueryOver <PublicacaoUpvote>()
.Where(x => x.Publicacao.Id == publicacao.Id)
.And(x => x.Usuario.Id == usuario.Id)
.List()
.FirstOrDefault());
}
protected override void OnPrepareTransactScope(InativarPublicacaoCommand command)
{
Publicacao publicacao = _publicacaoRepository.Find(command.Publicacao.Id);
publicacao.Inativar();
_publicacaoRepository.Update(publicacao);
}
public IActionResult atualizarPublicacao([FromHeader] string id_user, [FromBody] Publicacao PublicacaoView, string id_publicacao)
{
var publicacaoAtualiza = new PublicacaoCore(PublicacaoView, _mapper, _arquivo).atualizaPublicacao(PublicacaoView, id_publicacao, id_user);
return(publicacaoAtualiza.Status ?
Ok(publicacaoAtualiza) :
(IActionResult)BadRequest(publicacaoAtualiza));
}
public async Task <Publicacao> BuscarPorIdService(string id)
{
Publicacao response = new Publicacao();
response = await _unitOfWork.RepositoryPublicacao.BuscarPorIdRepository(id);
return(response);
}
public ActionResult DeleteConfirmed(int id)
{
Publicacao publicacao = db.Publicacaos.Find(id);
db.Publicacaos.Remove(publicacao);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <Publicacao> ConsultarAsync(string id = null)
{
var filter = Builders <Publicacao> .Filter.Eq(x => x.Id, id);
Publicacao publicacao = await Collection.Find(filter)
.SingleOrDefaultAsync();
return(publicacao);
}
public bool Salvar(Publicacao publicacao)
{
try
{
var obj = _context.Publicacao.Where(c => c.IdPublicacao.Equals(publicacao.IdPublicacao)).FirstOrDefault();
if (obj != null)
{
using (SqlConnection connection = new SqlConnection(_context.ConnectionString))
{
try
{
connection.Open();
var sql = $@"UPDATE [Publicacao]
SET [IdTema] = @IdTema
,[IdTipoDeConteudo] = @IdTipoDeConteudo
,[Identificador] = @Identificador
,[Titulo] = @Titulo
,[Chamada] = @Chamada
,[Conteudo] = @Conteudo
,[Tags] = @Tags
,[Ativo] = @Ativo
,[DataCadastro] = @DataCadastro
,[DataPublicacao] = @DataPublicacao
,[Binario] = @Binario
,[ImagemCapa] = @ImagemCapa
WHERE [IdPublicacao] = @IdPublicacao
";
connection.Execute(sql, new
{
Identificador = publicacao.Identificador,
Conteudo = publicacao.Conteudo,
Ativo = publicacao.Ativo,
DataCadastro = publicacao.DataCadastro,
DataPublicacao = publicacao.DataPublicacao
});
return(true);
}
catch
{
return(false);
}
}
}
else
{
var retorno = _context.Publicacao.Add(publicacao);
_context.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
throw new Exception("Erro ao salvar Tema: " + ex.Message, ex);
}
}
public async Task <int> AdicionarPublicacaoAsync(string descricao)
{
var publicacao = new Publicacao(); //{ Nome = descricao };
_publicacaoRepository.Adicionar(publicacao);
await _publicacaoRepository.SaveChangesAsync();
return(publicacao.Id);
}
public async Task <IActionResult> Create([Bind("Id,DataPublicacao,Descricao")] Publicacao publicacao)
{
if (ModelState.IsValid)
{
_context.Add(publicacao);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(publicacao));
}
public IHttpActionResult GetPublicacao(int id)
{
Publicacao publicacao = db.Publicacoes.Find(id);
if (publicacao == null)
{
return(NotFound());
}
return(Ok(publicacao));
}
public ActionResult Edit([Bind(Include = "PK_Publicacao,Data,Fk_Letra")] Publicacao publicacao)
{
if (ModelState.IsValid)
{
db.Entry(publicacao).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Fk_Letra = new SelectList(db.Letras, "Pk_Letra", "Titulo", publicacao.Fk_Letra);
return(View(publicacao));
}