public ActionResult Create([Bind(Include = "Texto,EpisodioFK")] Comentarios comentario)
{
try{
var Ut = db.Utilizadores.Where(
uti => uti.UserName
.Equals(User.Identity.Name)).FirstOrDefault();
if (!string.IsNullOrWhiteSpace(comentario.Texto))
{
comentario.Texto = comentario.Texto.Trim();
comentario.UtilizadorFK = Ut.ID;
if (ModelState.IsValid)
{
//guarda os comentários na BD
db.Comentarios.Add(comentario);
db.SaveChanges();
return(Redirect(Request.UrlReferrer.ToString()));
}
var errors = ModelState.Values.SelectMany(v => v.Errors);
ViewBag.UtilizadorFK = new SelectList(db.Utilizadores, "ID", "UserName", comentario.UtilizadorFK);
ViewBag.EpisodioFK = new SelectList(db.Episodios, "ID", "Nome", comentario.EpisodioFK);
}
}
catch (Exception)
{
ModelState.AddModelError("", string.Format("Ocorreu um erro a criar o comentário,tente novamente."));
}
return(Redirect(Request.UrlReferrer.ToString()));
}
public int insertarComentarios(Comentarios co)
{
try
{
cnx = cn.conectar();
cm = new SqlCommand("comentar", cnx);
cm.Parameters.AddWithValue("@b", 1);
cm.Parameters.AddWithValue("@idcomentario", "");
cm.Parameters.AddWithValue("@nombres", co.nombre);
cm.Parameters.AddWithValue("@correo", co.correo);
cm.Parameters.AddWithValue("@telefono", co.telefono);
cm.Parameters.AddWithValue("@mensaje", co.mensaje);
cm.CommandType = CommandType.StoredProcedure;
cnx.Open();
cm.ExecuteNonQuery();
indicador = 1;
}catch (Exception e) {
e.Message.ToString();
indicador = 0;
}
finally
{
cm.Connection.Close();
}
return(indicador);
}
public ActionResult Create(FormCollection collection)
{
try
{
// TODO: Add insert logic here
String idUsu = collection["usuario"];
int idLec = Int32.Parse(collection["leccion"]);
String Contenido = collection["contenido"];
ApplicationUser usuario = db.Users.Find(idUsu);
Lecciones lec = db.Lecciones.Find(idLec);
Comentarios coment = new Comentarios();
coment.Comentario = Contenido;
coment.Usuario = usuario;
coment.Leccion = lec;
db.Comentarios.Add(coment);
db.SaveChanges();
return(RedirectToAction("Details", "Lecciones", new { id = idLec }));
}
catch
{
return(View());
}
}
protected void btnAltaComentario_Click(object sender, EventArgs e)
{
ComentarioNegocio comentarioNegocio = new ComentarioNegocio();
Comentarios comentario = new Comentarios();
Usuario usuario = new Usuario();
usuario = (Usuario)Session[Session.SessionID + "usuario"];
try
{
comentario.IDSolicitud = Convert.ToInt64(Request.QueryString["ids"].ToString());
comentario.Usuario.ID = usuario.ID;
comentario.FechaComentario = DateTime.Today;
comentario.Comentario = txtComentario.Text;
if (txtComentario.Text == "")
{
Response.Redirect("SolicitudInterna.aspx?ids=" + comentario.IDSolicitud);
}
comentarioNegocio.alta(comentario);
SolicitudNegocio negocio = new SolicitudNegocio();
solicitud.FechaFin = DateTime.Today;
solicitud.Estado.ID = 2;
negocio.comentar(solicitud);
Response.Redirect("SolicitudInterna.aspx?ids=" + comentario.IDSolicitud);
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Delete(int?id)
{
Comentarios comentario = db.Comentarios.Find(id);
//um utilizador com a role Adim pode apagar qualquer comentario
//um utilizador pode apenas apagar os seus comentarios
if (comentario == null)
{
return(Redirect("/"));
}
//pesquisa na base de dados o utilizador que está autenticado
var Ut = db.Utilizadores.Where(uti => uti.UserName.Equals(User.Identity.Name)).FirstOrDefault();
try
{
if (Ut.ID.Equals(comentario.UtilizadorFK) || User.IsInRole("Administrador"))
{
if (id == null)
{
return(RedirectToAction("Index"));
}
if (comentario == null)
{
return(RedirectToAction("Index"));
}
return(View(comentario));
}
}
catch (Exception)
{
ModelState.AddModelError("", string.Format("Ocorreu um erro."));
}
return(RedirectToAction("Details", "Episodios", new { id = comentario.EpisodioFK }));
}
public ActionResult Edit(int?id)
{
var Ut = db.Utilizadores.Where(
uti => uti.UserName.Equals(User.Identity.Name)).FirstOrDefault();
Comentarios comentario = db.Comentarios.Find(id);
if (comentario == null)
{
return(Redirect("/"));
}
if (id == null)
{
return(RedirectToAction("Index"));
}
try {
//ve se o coment pertence ao user ou se possui permissoes de admin
if (Ut.ID.Equals(comentario.UtilizadorFK) || User.IsInRole("Administrador"))
{
ViewBag.EpisodioFK = new SelectList(db.Episodios, "ID", "Nome", comentario.EpisodioFK);
return(View(comentario));
}
}
catch (Exception)
{
ModelState.AddModelError("", string.Format("Ocorreu um erro a editar o comentário,tente novamente."));
}
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "ID,Texto,EpisodioFK")] Comentarios comentario)
{
try{
//um user com a role admin pode editar qualquer comentario, um utilizador com a role utilizador apenas pode editar o seu
var Ut = db.Utilizadores.Where(uti => uti.UserName.Equals(User.Identity.Name)).FirstOrDefault();
//ve se o coment pertence ao user ou se possui permissoes de admin
if (Ut.ID.Equals(comentario.UtilizadorFK) || User.IsInRole("Administrador"))
{
if (ModelState.IsValid)
{
comentario.UtilizadorFK = Ut.ID;
comentario.Texto = comentario.Texto.Trim();
db.Entry(comentario).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.EpisodioFK = new SelectList(db.Episodios, "ID", "Nome", comentario.EpisodioFK);
return(View(comentario));
}
}
catch (Exception)
{
ModelState.AddModelError("", string.Format("Ocorreu um erro a editar o comentário,tente novamente."));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Descricao,UtilizadorFK,Data,NoticiasFK")] Comentarios comentarios)
{
if (id != comentarios.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(comentarios);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ComentariosExists(comentarios.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["NoticiasFK"] = new SelectList(_context.Noticias, "ID", "Conteudo", comentarios.NoticiasFK);
ViewData["UtilizadorFK"] = new SelectList(_context.Utilizadores, "ID", "ID", comentarios.UtilizadorFK);
return(View(comentarios));
}
/*Método para la inserción de datos para comentarios*/
public int insertarComentarios(Comentarios coment)
{
try
{
conexion = _conexion.conectar(); // Conexiòn
comandos_sql = new SqlCommand("Comentar", conexion); // Nombre del procedimiento SQL
comandos_sql.Parameters.AddWithValue("@b", 1); // Valores que toman los parámetros
comandos_sql.Parameters.AddWithValue("@idcomentario", "");
comandos_sql.Parameters.AddWithValue("@nombres", coment.nombres);
comandos_sql.Parameters.AddWithValue("@correo", coment.correo);
comandos_sql.Parameters.AddWithValue("@telefono", coment.telefono);
comandos_sql.Parameters.AddWithValue("@mensaje", coment.mensaje);
comandos_sql.CommandType = CommandType.StoredProcedure; // Tipo de comando ejecutado
conexion.Open(); // Abrir conexión de BD
comandos_sql.ExecuteNonQuery(); // Ejecución de consulta
indicador = 1; // Valor del indicador
}
catch (Exception error)
{
error.Message.ToString();// Mostrar mensaje en caso de error
indicador = 1;
}
finally
{
comandos_sql.Connection.Close();// Cierre de conexión
}
return(indicador);
}
public IHttpActionResult PostComentario(Comentarios comentario)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Comentarios.Add(comentario);
try
{
db.SaveChanges();
}
catch (DbUpdateException ex)
{
if (comentarioExiste(comentario.id, comentario.idEvento))
{
return(Conflict());
}
//if (ComentarioExists(comentario.idEvento))
//{
// return Conflict();
//}
else
{
throw new DbUpdateException(ex.Message);
}
}
return(CreatedAtRoute("DefaultApi", new { id = comentario.idEvento }, comentario));
}
public async Task <ActionResult <Comentarios> > PostComentarios(Comentarios comentarios)
{
_context.Comentarios.Add(comentarios);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetComentarios", new { id = comentarios.IdComentario }, comentarios));
}
public async Task <IActionResult> PutComentarios(int id, Comentarios comentarios)
{
if (id != comentarios.IdComentario)
{
return(BadRequest());
}
_context.Entry(comentarios).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ComentariosExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult DeleteConfirmed(int id)
{
Comentarios comentario = db.Comentarios.Find(id);
if (comentario == null)
{
return(Redirect("/"));
}
try
{
var Ut = db.Utilizadores.Where(uti => uti.UserName.Equals(User.Identity.Name)).FirstOrDefault();
if (Ut.ID.Equals(comentario.UtilizadorFK) || User.IsInRole("Administrador"))
{
db.Comentarios.Remove(comentario);
db.SaveChanges();
}
}
catch (Exception)
{
ModelState.AddModelError("", string.Format("Ocorreu um erro a eliminar o comentário,tente novamente."));
}
return(RedirectToAction("Details", "Episodios", new { id = comentario.EpisodioFK }));
}
public IActionResult Comentarios([FromBody] Comentarios comentario)
{
try
{
var context = new postgresContext();
context.Comentarios.Add(comentario);
context.SaveChanges();
context.Dispose();
return(new ResultWithBody
{
Code = System.Net.HttpStatusCode.OK,
Body = "Inserção de Cometarios - Comentario Inserido!",
});
}
catch (Exception ex)
{
Console.WriteLine("[error] ConfigController - GetFurnaces - {0} - {1}",
ex.Message,
ex.StackTrace.Replace(Environment.NewLine, " "));
return(new ResultWithBody
{
Code = System.Net.HttpStatusCode.InternalServerError,
Body = "GetFurnaces - Fatal error retrieving furnaces configuration",
});
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
Comentarios coment = new Comentarios();
if (coment.EntregarComentarios() != null)
{
string numnot = Request.QueryString["noticia"];
if (numnot != null)
{
Repeater1.DataSource = coment.Entregarcomentarioporidnoticia(int.Parse(numnot));
Repeater1.DataBind();
}
else
{
Response.Redirect("Error.aspx");
}
}
}
int idnoti = int.Parse(Request.QueryString["noticia"]);
Noticias noti = new Noticias();
if (noti.EntregarNoticiaporID(idnoti) != null)
{
Titulo.Text = noti.EntregarNoticiaporID(noti.NoticiaPrincipal()).Rows[0][6].ToString();
string Text = noti.EntregarNoticiaporID(noti.NoticiaPrincipal()).Rows[0][1].ToString();
//separa los textos por el espacio.
int buscador = Text.IndexOf("<br/>");
string parrafo = Text.Substring(buscador);
Parrafo1.Text = parrafo;
Parrafo2.Text = Text.Substring(buscador, parrafo.Length);
}
}
public IActionResult Create([FromBody] Comentarios comentario)
{
Claim userIdClaim = User.Claims.FirstOrDefault(x => x.Type.Contains("nameIdentifier"));
string userId = userIdClaim.Value;
try
{
comentariosCore = new ComentariosCore(db);
ResponseApiError responseApiError = comentariosCore.Create(comentario, userId);
if (responseApiError != null)
{
return(StatusCode(responseApiError.HttpStatusCode, responseApiError));
}
return(Ok(new ResponseApiSuccess {
Code = 1, Message = "Comentario posteado"
}));
}
catch (Exception ex)
{
logger.Error(ex);
return(StatusCode((int)HttpStatusCode.InternalServerError, new ResponseApiError {
Code = 1001, Message = ex.Message
}));
}
}
public ActionResult Create([Bind(Include = "Descricao,NoticiasFK")] Comentarios comentario)
{
comentario.ID = db.Comentarios.Max(c => c.ID) + 1;
//pesquisar o id do autor do comentario
var utilizador = db.Utilizadores.Where(u => u.Username == User.Identity.Name).FirstOrDefault().ID;;
//definir o autor do comentario
comentario.UtilizadorFK = utilizador;
comentario.Data = System.DateTime.Now;
try
{
if (ModelState.IsValid)
{
//adiciona um comentario a base de dados
db.Comentarios.Add(comentario);
// efectua comit na base de dados
db.SaveChanges();
//redireciona para os detalhes da noticia
return(RedirectToAction("Details", "Noticias", new { id = comentario.NoticiasFK }));
}
}
catch (Exception)
{
ModelState.AddModelError("", "Não foi possivel concratizar a operação.");
}
return(View(comentario));
}
/// <summary>
/// Guarda el comentario de un post en especifico
/// </summary>
/// <param name="comentarioDto"></param>
/// <returns></returns>
public ApiCallResult GuardarComentario(ComentarioSavedDto comentarioDto)
{
try
{
Blogs blog = this.blogRepository.ObtenerSlug(comentarioDto.Slug);
if (blog is null)
{
throw new Exception("No existe la entrada");
}
Comentarios comentario = mapper.Map <Comentarios>(comentarioDto);
comentario.Idblog = blog.Idblog;
comentario.Fechacreaciion = DateTime.Now;
this.blogRepository.GuardarComentario(comentario);
return(new ApiCallResult
{
Estado = true,
Mensaje = "Comentario guardado"
});
}
catch (Exception e)
{
return(new ApiCallResult
{
Estado = false,
Mensaje = $"Error en {e.Message}"
});
}
}
//Editar Comentarios
public int EditarComentarios(Comentarios co)
{
try
{
SqlConnection cnx = cn.conectar(); //conexion
cm = new SqlCommand("comentar", cnx);
cm.Parameters.AddWithValue("@b", 4);
cm.Parameters.AddWithValue("idcomentario", co.idcomentario); //parametro del procedimiento almacenado
cm.Parameters.AddWithValue("nombres", "");
cm.Parameters.AddWithValue("correo", "");
cm.Parameters.AddWithValue("telefono", "");
cm.Parameters.AddWithValue("@mensaje", co.mensaje);
cm.CommandType = CommandType.StoredProcedure;
cnx.Open();
cm.ExecuteNonQuery();
indicador = 1;
}
catch (Exception e)
{
e.Message.ToString();
indicador = 0;
}
finally
{ cm.Connection.Close(); }
return(indicador);
}
public int insertarComentarios(Comentarios co)
{
try
{
SqlConnection cnx = cn.conectar(); //Conexion
cm = new SqlCommand("comentar", cnx); //Nombre del procedimiento
cm.Parameters.AddWithValue("@b", 1); //Valores que toman los parametros
cm.Parameters.AddWithValue("@idcomentario", ""); //del procedimiento
cm.Parameters.AddWithValue("@nombres", co.nombres);
cm.Parameters.AddWithValue("@correo", co.correo);
cm.Parameters.AddWithValue("@telefono", co.telefono);
cm.Parameters.AddWithValue("@mensaje", co.mensaje);
cm.CommandType = CommandType.StoredProcedure; //Tipo de comando ejecutado
cnx.Open(); //Abrir conexion de BD
cm.ExecuteNonQuery(); //Ejecucion de consulta
indicador = 1; //Valor del indicador
}
catch (Exception e)
{
e.Message.ToString(); //Mostrar mensaje en caso error
indicador = 0;
}
finally
{
cm.Connection.Close(); //Cierre de conexion
}
return(indicador);
}
private void BtnDesLike_Click(object sender, RoutedEventArgs e)
{
Icon1.Kind = MaterialDesignThemes.Wpf.PackIconKind.LikeOutline;
Icon2.Kind = MaterialDesignThemes.Wpf.PackIconKind.Dislike;
Comentarios comentario = new Comentarios();
comentario.comentario = txtComentarios.Text;
comentario.id_imagem = _window.idImg;
int?cont = 0;
using (DB_Connection con = new DB_Connection())
{
cont = con.Imagens.Where(x => x.id == _window.idImg).Max(x => x.like_negativo);
if (cont == null)
{
cont = 0;
}
}
Imagens imagem = new Imagens();
imagem.like_negativo = cont + 1;
imagem.id = _window.idImg;
_service.UpdateTable(comentario);
ExecuteUpdate(cont + 1, imagem.id, "like_negativo");
ClearField();
EnableFields();
btnLike.IsEnabled = false;
}
public IHttpActionResult PutComentarios(int id, Comentarios comentarios)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != comentarios.Id)
{
return(BadRequest());
}
db.Entry(comentarios).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ComentariosExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Edit(int id, [Bind("Idcometarios,Nombre,Email,Website,Descripcion,Identradas")] Comentarios comentarios)
{
if (id != comentarios.Idcometarios)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(comentarios);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ComentariosExists(comentarios.Idcometarios))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["Identradas"] = new SelectList(_context.Entradas, "Identradas", "Identradas", comentarios.Identradas);
return(View(comentarios));
}
public void RegistrarComentario(Guid id, Comentarios comentario)
{
Gauchada gauch = GetById(id);
gauch.Comentarios.Add(comentario);
context.Gauchadas.Update(gauch);
context.SaveChanges();
}
public void Update(Guid id, Comentarios comentario)
{
Comentarios coment = GetById(id);
coment.Respuesta = comentario.Respuesta;
context.Comentarios.Update(coment);
context.SaveChanges();
}
public void UpdateTable(Comentarios comentario)
{
using (DB_Connection con = new DB_Connection())
{
con.Comentarios.Add(comentario);
con.SaveChanges();
}
}
public ActionResult DeleteConfirmed(int id)
{
Comentarios comentarios = db.Comentarios.Find(id);
db.Comentarios.Remove(comentarios);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult DeleteConfirmed(int?idcomentario, int?idcliente)
{
Comentarios comentarios = db.Comentarios.Find(idcomentario);
db.Comentarios.Remove(comentarios);
db.SaveChanges();
return(Redirect("/Comentario/index" + "?idcliente=" + idcliente));
}
public ActionResult DeleteConfirmed(int id)
{
Comentarios comentarios = db.Comentarios.Find(id);
db.Comentarios.Remove(comentarios);
db.SaveChanges();
return(RedirectToAction("Details", "Noticias", new { id = comentarios.NoticiaFK }));
}
public void AdicionarComentario(Comentario comentario)
{
comentario.Validate();
if (comentario.Usuario != null)
{
Comentarios.Add(comentario);
}
}
