public ActionResult Guardar(ComentariosModel model)
{
var rm = new ResponseModel();
var consulta = db.comentarios.Where(m => m.ID == model.Id).FirstOrDefault();
if (consulta == null)
{
consulta = new comentarios();
consulta.ID_TIPO_PROGRAMA = model.Programa;
consulta.COMENTARIO = model.Comentario;
db.comentarios.Add(consulta);
}
else
{
consulta.ID_TIPO_PROGRAMA = model.Programa;
consulta.COMENTARIO = model.Comentario;
}
if (db.SaveChanges() > 0)
{
rm.response = true;
rm.message = "Se guardaron los datos correctamente";
rm.result = true;
rm.function = "reload(true,'" + rm.message + "')";
}
return(Json(rm, JsonRequestBehavior.AllowGet));
}
public int insertarcomentarios(comentarios co)
{
try
{
SqlConnection cnx = cn.conectar();
cm = new SqlCommand("comentar", cnx);
cm.Parameters.AddWithValue("@b", 1);
cm.Parameters.AddWithValue("idcomentarios", "");
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 async Task <IActionResult> Edit(int id, [Bind("idComentario,comentario,DHComentario")] comentarios comentarios)
{
if (id != comentarios.idComentario)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(comentarios);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!comentariosExists(comentarios.idComentario))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(comentarios));
}
public JsonResult agregarComentario(comentarios com)
{
DateTime hoy = DateTime.Now;
com.FechaHora = hoy;
com.IdUsuario = SessionHelper.GetIdUser();
com.Visible = 1;
com.ComentarioSistema = 1;
var rm = new ResponseModel();
if (ModelState.IsValid)
{
rm = com.Guardar();
if (rm.response)
{
rm.function = "agregarcom";
rm.result = com;
}
}
var usr = SessionHelper.GetNameUser();;
var coment = new { comentario = com.Comentario, horafecha = hoy.ToString("yyyy-MM-dd HH:mm:ss"), usuario = usr };
rm.result = coment;
return(Json(rm));
}
public List <comentarios> ObtenerPorDetalle(int id)
{
List <comentarios> lista = new List <comentarios>();
try
{
AbrirConexion();
StringBuilder CadenaSql = new StringBuilder();
SqlCommand comandoSelect = new SqlCommand();
comandoSelect.Connection = Conexion;
comandoSelect.CommandType = CommandType.StoredProcedure;
comandoSelect.CommandText = "DML_Comentarios";
comandoSelect.Parameters.AddWithValue("@Sentencia", "Select");
comandoSelect.Parameters.AddWithValue("@id_detalle_ticket", id);
using (var dr = comandoSelect.ExecuteReader())
{
while (dr.Read())
{
comentarios entidad = new comentarios();
entidad.id_comentario = int.Parse(dr["id_comentario"].ToString());
entidad.comentario = dr["comentario"].ToString();
if (dr["imagen"].ToString() != string.Empty)
{
entidad.imagen = Convert.ToBase64String((byte[])dr["imagen"]);
}
entidad.fechahora_comentario = dr["fechahora_comentario"].ToString();
entidad.id_detalle_ticket = int.Parse(dr["id_detalle_ticket"].ToString());
entidad.id_usuario = int.Parse(dr["id_usuario"].ToString());
entidad.usuario = dr["usuario"].ToString();
entidad.id_tipo_usuario = int.Parse(dr["id_tipo_usuario"].ToString());
entidad.tipo_usuario = dr["tipo_usuario"].ToString();
if (dr["foto"].ToString() != string.Empty)
{
entidad.foto = "data:image/png;base64," + Convert.ToBase64String((byte[])dr["foto"]);
}
lista.Add(entidad);
}
}
}
catch (InvalidCastException ex)
{
ApplicationException excepcion = new ApplicationException("Se genero un error de conversión de tipos con el siguiente mensaje: " + ex.Message, ex);
excepcion.Source = "Insertar comentarios";
throw excepcion;
}
catch (Exception ex)
{
ApplicationException excepcion = new ApplicationException("Se genero un error de aplicación con el siguiente mensaje: " + ex.Message, ex);
excepcion.Source = "Insertar comentarios";
throw excepcion;
}
finally
{
CerrarConexion();
}
return(lista);
}
public async Task <IActionResult> Create([Bind("idComentario,comentario,DHComentario")] comentarios comentarios)
{
if (ModelState.IsValid)
{
_context.Add(comentarios);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(comentarios));
}
public ActionResult Comentario(comentarios comentario)
{
comentario.DHComentario = DateTime.Now;
_context.Comentarios.Add(comentario);
_context.SaveChanges();
// return await Details(comentario.chamdosId);
// return Details(comentario.chamdosId);
return(RedirectToAction("Details", new { id = comentario.chamdosId }));
}
public comentarios updatecomentarios(Comentario coment)
{
comentarios nComent = new comentarios();
nComent.FK_COMENTARIOS_USUARIOS = coment.Fanatico;
nComent.fechaCreacion = coment.Fecha;
nComent.comentario = coment.Contenido;
nComent.calificacion = coment.Calificacion;
nComent.FK_COMENTARIOS_ESTADOS = _manejadorDB.obtenerEstado(coment.Estado).PK_estados;
nComent.FK_COMENTARIOS_BANDAS = _manejadorDB.obtenerBanda(coment.Banda).PK_bandas;
return(nComent);
}
public void post(int id_juego, int id_usuario, string comment)
{
using (var bd = new Games_MarketEntities())
{
comentarios ocomentarios = new comentarios();
ocomentarios.id_juego = id_juego;
ocomentarios.id_usuario = id_usuario;
ocomentarios.comentario = comment;
ocomentarios.fecha = DateTime.Now;
bd.comentarios.Add(ocomentarios);
bd.SaveChanges();
}
}
public ActionResult Post([FromBody] comentarios comentario)
{
try
{
_context.Add(comentario);
_context.SaveChanges();
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <HttpResponseMessage> Post(comentarios item)
{
if (item == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"El comentario no puede estar sin datos"));
}
//Valido si existe la publicacion, si no se manda el valor, por defecto es CERO
if (!ValidandoSiExistenDatosRelacionados.ExistsPublicacion(item.id_post))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No existe dicha publicación"));
}
//valido si existe el user que comenta
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(item.id_user))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No existe el usuario"));
}
item.fecha_creacion = DateTime.Now;
item.isDeleted = false;
if (r.Post(item))
{
//TODO PUSH for comment
using (var db = new DBContextModel())
{
users creatorPost = db.publicaciones.SingleOrDefault(u => u.id_post == item.id_post).users;
var receiptInstallID = new Dictionary <string, string>
{
{ creatorPost.Phone_OS, creatorPost.Device_id }
};
AppCenterPush appCenterPush = new AppCenterPush(receiptInstallID);
users CommenterPost = db.users.SingleOrDefault(u => u.id_user == item.id_user);
await appCenterPush.Notify("comentarios",
$"{CommenterPost.nombre} comentó tu publicación",
item.contenido,
new Dictionary <string, string>() {
{ DLL.PushConstantes.gotoPage, DLL.PushConstantes.goto_post },
{ DLL.PushConstantes.id_post, item.id_post.ToString() },
{ DLL.PushConstantes.id_user, creatorPost.id_user.ToString() }
});
}
return(Request.CreateResponse(HttpStatusCode.Created, item));
}
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "No es posible guardar los datos del comentario"));
}
public HttpResponseMessage Put(int id, comentarios item)
{
var data = r.GetById(id);
if (data == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe en la base de datos el comentario a actualizar"));
}
if (r.Put(id, item))
{
return(Request.CreateResponse(HttpStatusCode.OK, $"Datos modificados para el comentario {id}"));
}
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"No fue posible actualizar el comentario, id: {id}"));
}
public Comentario createComentario(comentarios coment)
{
int id = coment.PK_comentarios;
string fanatico = _manejadorDB.obtenerUsuario(coment.FK_COMENTARIOS_USUARIOS).username;
DateTime fecha = coment.fechaCreacion;
string contenido = coment.comentario;
float calificacion = coment.calificacion;
string estado = _manejadorDB.obtenerEstado(coment.FK_COMENTARIOS_ESTADOS).estado;
string banda = _manejadorDB.obtenerBanda(coment.FK_COMENTARIOS_BANDAS).nombreBan;
Comentario nuevoComentario = new Comentario(id, fanatico, fecha, contenido, calificacion, estado, banda);
return(nuevoComentario);
}
public JsonResult GuardarResHoras(responsableHora rh)
{
var rm = new ResponseModel();
rh.idarea = Convert.ToInt32(TempData["idarea"]);
rh.idtarea = Convert.ToInt32(TempData["idtarea"]);
rm = rh.guardar();
if (rm.response)
{
var comSis = new comentarios();
comSis.comentarioSistema(rh.idtarea, "Se modificaron algunos datos de la descripcion de la tarea ");
rm.href = Url.Content("self");
}
return(Json(rm));
}
public JsonResult FinalizarTarea()
{
var rm = new ResponseModel();
tareas.IdTarea = Funciones.TareaVisualizada();
rm = tareas.finalizarTarea();
if (rm.response)
{
var comSis = new comentarios();
comSis.comentarioSistema(tareas.IdTarea, "Tarea finalizada por el usuario");
rm.href = Url.Content("self");
}
return(Json(rm));
}
/*Añade un comentario a una banda especifica
*/
public void añadirComentario(comentarios coment)
{
using (myconcertEntities context = new myconcertEntities())
{
try
{
context.comentarios.Add(coment);
context.SaveChanges();
}
catch (Exception e)
{
throw (e);
}
}
}
private void btn_aceptar_Click(object sender, EventArgs e)
{
if (pasa_control() == true)
{
using (var context = new lts_sindicatoDataContext())
{
ParaInspeccion insert = new ParaInspeccion();
insert.CUIL = txt_cuil.Text.ToString().Trim();
insert.CUIT = txt_cuit.Text.ToString().Trim();
insert.FECHA = DateTime.Today;
insert.ESTADO = 0;
try
{
context.ParaInspeccion.InsertOnSubmit(insert);
context.SubmitChanges();
}
catch (Exception)
{
throw;
}
try
{
if (txt_comentario.Text != string.Empty)
{
comentarios comit = new comentarios();
comit.ID_USUARIO = id_usuario;
comit.COMENTARIO = txt_comentario.Text;
comit.FECHA = DateTime.Today;
comit.PI_ID = context.ParaInspeccion.OrderByDescending(x => x.ID).First().ID;
context.comentarios.InsertOnSubmit(comit);
context.SubmitChanges();
MessageBox.Show("¡¡¡¡¡ Datos para la inspeccion, Cargados Existosamente !!!!! ");
btn_aceptar.Enabled = false;
Close();
}
}
catch (Exception)
{
throw;
}
}
}
}
public ActionResult Ver(int id)
{
var tarea = new tareas();
if ((responsable.ObtenerArea(SessionHelper.GetIdUser()) != (tarea.Obtener(id).IdArea)) && (!SessionHelper.esAdmin()))
{
return(RedirectToAction("Error", "Index"));
}
var responsables = new responsable();
var comentarios = new comentarios();
ViewBag.comentarios = comentarios.Listar(id);
ViewBag.tarea = tareas.Obtener(id);
TempData["idarea"] = ViewBag.tarea.IdArea;
TempData["idtarea"] = id;
ViewBag.usuariosArea = responsables.listarResponsable(ViewBag.tarea.IdArea);
return(View());
}
public ActionResult Put(int id, [FromBody] comentarios comentario)
{
try
{
if (id != comentario.Id)
{
return(BadRequest());
}
_context.Entry(comentario).State = EntityState.Modified;
_context.Update(comentario);
_context.SaveChanges();
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public bool Update(comentarios entidad)
{
SqlCommand cmd = new SqlCommand();
bool respuesta = false;
try
{
AbrirConexion();
cmd.Connection = Conexion;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "DML_Comentarios";
cmd.Parameters.AddWithValue("@Sentencia", "Update");
cmd.Parameters.AddWithValue("@IdComentario", entidad.id_comentario);
cmd.Parameters.AddWithValue("@comentario", entidad.comentario);
if (entidad.imagen != string.Empty)
{
cmd.Parameters.AddWithValue("@imagen", Convert.FromBase64String(entidad.imagen));
}
cmd.Parameters.AddWithValue("@id_detalle_ticket", entidad.id_detalle_ticket);
cmd.Parameters.AddWithValue("@id_usuario", entidad.id_usuario);
cmd.ExecuteNonQuery();
respuesta = true;
}
catch (InvalidCastException ex)
{
ApplicationException excepcion = new ApplicationException("Se genero un error de conversión de tipos con el siguiente mensaje: " + ex.Message, ex);
excepcion.Source = "Insertar comentarios";
throw excepcion;
}
catch (Exception ex)
{
ApplicationException excepcion = new ApplicationException("Se genero un error de aplicación con el siguiente mensaje: " + ex.Message, ex);
excepcion.Source = "Insertar comentarios";
throw excepcion;
}
finally
{
CerrarConexion();
cmd = null;
}
return(respuesta);
}
public ActionResult GuardarComentario(comentarios entidad)
{
var r = false;
try
{
r = ctrlComentario.Insertar(entidad);
if (!r)
{
return(Json("Error al realizar la operacion", JsonRequestBehavior.AllowGet));
}
return(Json("Realizado", JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(View("Error", new HandleErrorInfo(ex, "TipoUsuario", "Create")));
}
}
//Generar comentario de banda
public Respuesta generarComentario(string idBand, string user, string comment, float calification)
{
Respuesta respuesta = null;
try
{
if (_manejador.obtenerBanda(idBand) == null)
{
return(_fabricaRespuestas.crearRespuesta(false, "Banda no existente. Por favor intente de nuevo."));
}
Comentario comentario =
new Comentario(0,
user,
DateTime.Now,
comment,
calification,
_manejador.obtenerEstado(1).estado,
_manejador.obtenerBanda(idBand).nombreBan);
comentarios parseComment = _convertidor.updatecomentarios(comentario);
if (calification < 0.0 || calification > 5.0)
{
return(_fabricaRespuestas.crearRespuesta(false, "Calificación debe estar entre 0 y 5 estrellas"));
}
if (comment.Length > 140)
{
return(_fabricaRespuestas.crearRespuesta(false, "Comentario máximo de 140 caracteres. Por favor intente de nuevo."));
}
_manejador.añadirComentario(parseComment); //Almacena comentario
respuesta = _fabricaRespuestas.crearRespuesta(true, "Comentario añadido correctamente.");
} catch (Exception)
{
//Retorna error
respuesta = _fabricaRespuestas.crearRespuesta(false, "Fallo al generar comentario.");
//respuesta = _fabricaRespuestas.crearRespuesta(true, "Comentario añadido correctamente.", e.ToString());
}
return(respuesta);
}
public List <comentarios> listarcomentarios()
{
try
{
cm = new SqlCommand("comentar", cnx);
cm.Parameters.AddWithValue("@b", 1);
cm.Parameters.AddWithValue("idcomentarios", "");
cm.Parameters.AddWithValue("@nombres", "");
cm.Parameters.AddWithValue("@correo", "");
cm.Parameters.AddWithValue("@telefono", "");
cm.Parameters.AddWithValue("@mensaje", "");
cm.CommandType = CommandType.StoredProcedure;
cnx.Open();
dr = cm.ExecuteReader();
indicador = 1;
listacomentarios = new List <comentarios>();
while (dr.Read())
{
comentarios c = new comentarios();
c.idcomentarios = Convert.ToInt32(dr["idcomentario"].ToString());
c.nombre = dr["nombre"].ToString();
c.correo = dr["correo"].ToString();
c.telefono = dr["telefono"].ToString();
c.mensaje = dr["mensaje"].ToString();
listacomentarios.Add(c);
}
}
catch (Exception e)
{
e.Message.ToString();
listacomentarios = null;
}
finally
{
cm.Connection.Close();
}
return(listacomentarios);
}
public bool Actualizar(comentarios Entidad)
{
return(PerComentarios.Update(Entidad));
}
public bool Insertar(comentarios Entidad)
{
return(PerComentarios.Insertar(Entidad));
}
public int editarcomentario(comentarios co)
{
return(ac.editarcomentarios(co));
}
public int insertarcomentarios(comentarios co)
{
return(ac.insertarcomentarios(co));
}
