public ActionResult HistorialReclamo(String NroRegistro, String Estado)
{
Reclamo_DAL manager = new Reclamo_DAL();
Reclamo objReclamo = new Reclamo();
objReclamo.NroReclamo = NroRegistro;
objReclamo.EstadoQuejaReclamo = Estado;
return(View(objReclamo));
}
public ActionResult Edit([Bind(Include = "IdReclamo,Nombre,Empresa,Telefono,Email,Mensaje")] Reclamo reclamo)
{
if (ModelState.IsValid)
{
db.Entry(reclamo).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(reclamo));
}
public ActionResult Edit([Bind(Include = "ID,Name,Description")] Reclamo reclamo)
{
if (ModelState.IsValid)
{
db.Entry(reclamo).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(reclamo));
}
public Reclamo Buscar(long id = 0)
{
Reclamo reclamo = db.Reclamos.Find(id);
if (reclamo == null)
{
return(null);
}
return(reclamo);
}
//
// GET: /Reclamos/Details/5
public ActionResult Details(long id = 0)
{
Reclamo reclamo = modReclamo.Buscar(id);
if (reclamo == null)
{
return(HttpNotFound());
}
ViewBag.TipoReclamo = TipoReclamo.GetNames(typeof(TipoReclamo))[reclamo.IdTipoReclamo];
return(View(reclamo));
}
public ActionResult DeleteConfirmed(int id)
{
Reclamo reclamo = db.Reclamos.Find(id);
db.Reclamos.Remove(reclamo);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Create([Bind(Include = "IdReclamo,Nombre,Empresa,Telefono,Email,Mensaje")] Reclamo reclamo)
{
if (ModelState.IsValid)
{
db.Reclamo.Add(reclamo);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(reclamo));
}
//GET: Reclamos/MoreInfo
public ActionResult MoreInfo(int idReclamo)
{
Reclamo reclamo = db.Reclamoes.Find(idReclamo);
reclamo.responsableAsignadoId = null;
reclamo.responsableAsignado = null;
reclamo.estadoReclamoId = 3; //Informacion Solicitada
db.Entry(reclamo).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("ListadoReclamos", "Reclamos"));
}
public ResultadoUnico <string, int> AddReclamo(Reclamo unReclamo)
{
try
{
return(ReclamoDAO.AddReclamo(unReclamo));;
}
catch (Exception err)
{
throw err;
}
}
public ActionResult Create([Bind(Include = "ID,Name,Description")] Reclamo reclamo)
{
if (ModelState.IsValid)
{
db.Reclamos.Add(reclamo);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(reclamo));
}
/*
* context SolicitarSoporte :: AdicionarReclamo
* pre: tipoReclamo != null and concesionario != null
* post: ConsultarReclamo(id)
*/
public void AdicionarReclamo(String tipoReclamo, string concesionario, string descripcion, int idCliente)
{
int idReclamo = 0;
reclamos.Clear();
ConsularReclamo();
idReclamo = reclamos.Count + 1;
Reclamo reclamo = new Reclamo(idReclamo, tipoReclamo, concesionario, descripcion, idCliente);
AdicionarReclamoRepositorio(reclamo.IdReclamo, reclamo.TipoReclamo, reclamo.Concesionario, reclamo.Descripcion, reclamo.IdCliente);
}
public void IngresoReclamo(Reclamo rec, string Pdf, DateTime SLA, string Ip) // Ingreso de reclamos, recibe un Reclamo sin retornar algo a cambio, sin embargo puede generar excepción
// tiene como función ejecutar un procedimiento almacenado para registrar un reclamo
{
using (var conn = new SqlConnection(Str))
{
/*
* @id INTEGER,
* @nombre VARCHAR(20),
* @apellido VARCHAR(20),
* @rut VARCHAR(12),
* @email VARCHAR(100),
* @telefono INTEGER,
* @area INTEGER,
* @comentarios text,
* @fecha DATETIME,
* @pdf VARCHAR(100),
* @sla DATETIME,
* @ip VARCHAR(100)
*
* ^ This is our store procedure structure for adding a complaint into system
*
* Se llama a procedimiento almacenado en SQL Server con la estructura anterior, pasando los datos parametrizados
*/
var cmd = new SqlCommand("IngresoReclamo", conn)
{
CommandType = CommandType.StoredProcedure
};
cmd.Parameters.AddWithValue("id", rec.Id);
cmd.Parameters.AddWithValue("nombre", rec.Nombre);
cmd.Parameters.AddWithValue("apellido", rec.Apellido);
cmd.Parameters.AddWithValue("rut", rec.Rut);
cmd.Parameters.AddWithValue("email", rec.Email);
cmd.Parameters.AddWithValue("telefono", rec.Telefono);
cmd.Parameters.AddWithValue("area", Convert.ToInt32(rec.Tipo));
cmd.Parameters.AddWithValue("comentarios", rec.Comentarios);
cmd.Parameters.AddWithValue("fecha", rec.Fecha);
cmd.Parameters.AddWithValue("pdf", Pdf);
cmd.Parameters.AddWithValue("sla", SLA);
cmd.Parameters.AddWithValue("ip", Ip);
try
{ // se envía la query
conn.Open();
cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new Exception("Error al agregar reclamo " + ex.Message);
}
finally
{
conn.Close();
}
}
}
public ResultadoUnico <string, int> Estado_Grabar(Reclamo unReclamo)
{
try
{
return(ReclamoDAO.Estado_Grabar(unReclamo));;
}
catch (Exception err)
{
throw err;
}
}
public ActionResult Unassign(int idReclamo)
{
Reclamo reclamo = db.Reclamoes.Find(idReclamo);
reclamo.responsableAsignadoId = null;
reclamo.responsableAsignado = null;
reclamo.estadoReclamoId = 1; //Generado
db.Entry(reclamo).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("ListadoReclamos", "Reclamos"));
}
public ActionResult Edit([Bind(Include = "id,observacionFamacia,respuesta,fechaInicioReclamo,fechaFinReclamo,tipoReclamoId,pedidoId,hospitalId,responsableAsignadoId,estadoReclamoId")] Reclamo reclamo)
{
if (ModelState.IsValid)
{
reclamo.estadoReclamoId = 1; //Generado
db.Entry(reclamo).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("ReclamosRespFarmacia", "Reclamos"));
}
return(View(reclamo));
}
public static ResultadoUnico <string, int> AddReclamo(Reclamo unReclamo)
// public static int AddReclamo(Reclamo unReclamo)
{
ResultadoUnico <string, int> oResultado = new ResultadoUnico <string, int>();
string sql = "Reclamo_grabar";
Database db = DatabaseFactory.CreateDatabase("DAT_V01");
DbCommand dbCommand = db.GetStoredProcCommand(sql);
DbParameterCollection dbParametros = null;
try
{
db.AddInParameter(dbCommand, "@IdBeneficiario", DbType.Int64, unReclamo.UnaNovedad.UnBeneficiario.IdBeneficiario);
db.AddInParameter(dbCommand, "@IdPrestador", DbType.Int32, unReclamo.UnaNovedad.UnPrestador.ID);
db.AddInParameter(dbCommand, "@codConceptoLiq", DbType.Int64, unReclamo.UnaNovedad.UnConceptoLiquidacion.CodConceptoLiq);
db.AddInParameter(dbCommand, "@DescripcionReclamo", DbType.String, unReclamo.DescripcionReclamo);
db.AddInParameter(dbCommand, "@IdTipoReclamo", DbType.Int32, unReclamo.UnTipoReclamo.IdTipoReclamo);
db.AddInParameter(dbCommand, "@expediente", DbType.String, unReclamo.Expediente);
db.AddInParameter(dbCommand, "@Observacion", DbType.String, unReclamo.UnEstadoReclamo.observacion);
db.AddInParameter(dbCommand, "@PresentoDoc", DbType.Boolean, unReclamo.PresentoDoc);
db.AddInParameter(dbCommand, "@IdEstadoReclamo", DbType.Int32, unReclamo.UnEstadoReclamo.IdEstado);
db.AddInParameter(dbCommand, "@idOficina", DbType.String, unReclamo.UnaAuditoria.IDOficina);
db.AddInParameter(dbCommand, "@Usuario", DbType.String, unReclamo.UnaAuditoria.Usuario);
db.AddInParameter(dbCommand, "@ip", DbType.String, unReclamo.UnaAuditoria.IP);
db.AddInParameter(dbCommand, "@IdReclamo", DbType.Int64, unReclamo.IdReclamo);
db.AddInParameter(dbCommand, "@solicitaReintegro", DbType.Boolean, unReclamo.SolicitaReintegro);
db.AddOutParameter(dbCommand, "@IdReclamoOUT", DbType.Int64, 20);
dbParametros = dbCommand.Parameters;
db.ExecuteNonQuery(dbCommand);
oResultado.DatoUnico2 = Convert.ToInt32(db.GetParameterValue(dbCommand, "IdReclamoOUT"));
return(oResultado);
}
catch (System.Data.SqlClient.SqlException err)
{
log.Error(string.Format("{0}->{1}->Error:{2}->{3}", DateTime.Now, System.Reflection.MethodBase.GetCurrentMethod(), err.Source, err.Message));
oResultado.Error = new Error();
oResultado.Error.Descripcion = err.Message;
return(oResultado);
}
catch (Exception err)
{
log.Error(string.Format("{0}->{1}->Error:{2}->{3}", DateTime.Now, System.Reflection.MethodBase.GetCurrentMethod(), err.Source, err.Message));
oResultado.Error = new Error();
oResultado.Error.Descripcion = err.Message;
return(oResultado);
}
finally
{
db = null;
dbCommand.Dispose();
}
}
public ActionResult Create([Bind(Include = "Id,NumReclamo,TipoReclamo,Dependiente,Ajustador,FechaAviso,FechaSiniestro,LugarOcurrencia,MontoReclamado,Responsable,PolizaId,BienAseguradoId,CoberturaReclamoId")] Reclamo reclamo, string detalleDocs, string detallePagos, int?PolizaId, int?BienAseguradoId)
{
int d = -3;
var x = Request[""];
var detDocs = JsonConvert.DeserializeObject <List <DetalleDocumento> >(detalleDocs);
var detPagos = JsonConvert.DeserializeObject <List <DetallePago> >(detallePagos);
if (ModelState.IsValid)
{
using (var transact = db.Database.BeginTransaction())
{
try
{
if (db.Reclamos.FirstOrDefault(p => p.NumReclamo == reclamo.NumReclamo) != null)
{
ModelState.AddModelError("NumReclamo", "El número de reclamo que desea ingresar ya existe");
}
else
{
reclamo.PolizaId = (int)PolizaId;
reclamo.BienAseguradoId = (int)BienAseguradoId;
db.Reclamos.Add(reclamo);
db.SaveChanges();
foreach (var item in detDocs)
{
item.ReclamoId = reclamo.Id;
db.DetalleDocumentos.Add(item);
}
db.SaveChanges();
foreach (var item in detPagos)
{
item.ReclamoId = reclamo.Id;
db.DetallePagos.Add(item);
}
d = db.SaveChanges();
}
//Si todo se hizo correctamente se guardan los datos definitivamente
transact.Commit();
}
catch (Exception)
{
//Si hubo algun error en el almacenamiento de los datos
//deshacemos todos lo que habiamos guardado
transact.Rollback();
}
}
}
return(Json(new { d }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// controlador de la vista para consultar un reclamo a detalle
/// </summary>
/// <param name="idReclamo">recibe como parámetro el id del reclamo que se selecccionó</param>
/// aquí reutilizamos el modelo de la vista Modificar
/// <returns>retorna la vista del reclamo a detalle</returns>
public ActionResult M16_DetalleReclamo(int idReclamo)
{
Command <Entidad> comando = FabricaComando.crearM16ConsultarUsuario(idReclamo);
Reclamo reclamo = (Reclamo)comando.ejecutar();
CModificarReclamo model = new CModificarReclamo();
model._tituloReclamo = reclamo._tituloReclamo;
model._detalleReclamo = reclamo._detalleReclamo;
model._fechaReclamo = reclamo._fechaReclamo;
model._estadoReclamo = 1;
//CModificarReclamo model = new CModificarReclamo();
return(PartialView(model));
}
public ActionResult CargarPersona(int tipoDocumento, String NroDocumento)
{
Reclamo_DAL manager = new Reclamo_DAL();
ReclamoModel objGuiaModel = new ReclamoModel();
Reclamo objReclamo = new Reclamo();
objGuiaModel.lstDepartamentos = manager.ListarDepartamento();
ViewBag.lstDepartamentos = objGuiaModel.lstDepartamentos;
objReclamo = manager.CargarPersona(tipoDocumento, NroDocumento);
return(this.Json(objReclamo, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Método para consultar un reclamo en la BD
/// </summary>
/// <param name="id">id del reclamo</param>
/// <returns> reclamo </returns>
Entidad IDAO.Consultar(int id)
{
List <Parametro> parametro = FabricaDAO.asignarListaDeParametro();
int rec_id, rec_estatus, rec_fk_usuario;
String rec_titulo, rec_descripcion, rec_fecha;
Entidad reclamoE = FabricaEntidad.InstanciarReclamo();
Reclamo reclamo = (Reclamo)reclamoE;
try
{
parametro.Add(FabricaDAO.asignarParametro(M16Reclamos.rec_id, SqlDbType.Int, id.ToString(), false));
DataTable filaReclamo = EjecutarStoredProcedureTuplas(M16Reclamos.procedimientoConsultarReclamoPorId, parametro);
DataRow Fila = filaReclamo.Rows[0];
rec_id = int.Parse(Fila[M16Reclamos.recId].ToString());
rec_estatus = int.Parse(Fila[M16Reclamos.recEstatus].ToString());
rec_fk_usuario = int.Parse(Fila[M16Reclamos.recFkUsuario].ToString());
rec_titulo = Fila[M16Reclamos.rectitulo].ToString();
rec_descripcion = Fila[M16Reclamos.recDescripcion].ToString();
String[] divisor = Fila[M16Reclamos.recFecha].ToString().Split(' ');
rec_fecha = divisor[0];
reclamo = (Reclamo)FabricaEntidad.InstanciarReclamo(rec_id, rec_titulo, rec_descripcion, rec_fecha, rec_estatus, rec_fk_usuario);
return(reclamo);
}
catch (SqlException ex)
{
Log.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ReservaExceptionM16(ex.Message, ex);
}
catch (NullReferenceException ex)
{
Log.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ReservaExceptionM16(ex.Message, ex);
}
catch (ArgumentNullException ex)
{
Log.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ReservaExceptionM16(ex.Message, ex);
}
catch (ExceptionBD ex)
{
Log.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ReservaExceptionM16(ex.Message, ex);
}
catch (Exception ex)
{
Log.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ReservaExceptionM16(ex.Message, ex);
}
}
//
// GET: /Reclamos/Edit/5
public ActionResult Edit(long id = 0)
{
Reclamo reclamo = modReclamo.Buscar(id);
if (reclamo == null)
{
return(HttpNotFound());
}
ViewBag.cboTipoReclamo = (from TipoReclamo e in Enum.GetValues(typeof(TipoReclamo))
select new SelectListItem {
Value = ((int)e).ToString(), Text = e.ToString()
});
return(View(reclamo));
}
// GET: Reclamos/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Reclamo reclamo = db.Reclamos.Find(id);
if (reclamo == null)
{
return(HttpNotFound());
}
return(View(reclamo));
}
public ActionResult Edit(Reclamo reclamo)
{
if (ModelState.IsValid)
{
reclamo.IdSesion = 1;
reclamo.FechaUltimaTransaccion = DateTime.Now;
reclamo.FechaRegistro = DateTime.Now;
reclamo.EstadoSincronizacion = TipoEstadoSincronizacion.Pendiente;
reclamo.DescripcionEstadoSincronizacion = "";
modReclamo.Editar(reclamo);
return(RedirectToAction("Index"));
}
return(View(reclamo));
}
/// <summary>
/// Metodo para hacer el insert de un reclamo en la BD
/// </summary>
/// <param name="e">Entidad que posteriormente será casteada a Reclamo</param>
/// <returns>Integer con el codigo de respuesta</returns>
int IDAO.Agregar(Entidad e)
{
Reclamo reclamo = (Reclamo)e;
reclamo._estadoReclamo = 1;
List <Parametro> listaParametro = FabricaDAO.asignarListaDeParametro();
try
{
listaParametro.Add(FabricaDAO.asignarParametro(M16Reclamos.rec_titulo, SqlDbType.VarChar, reclamo._tituloReclamo, false));
listaParametro.Add(FabricaDAO.asignarParametro(M16Reclamos.rec_descripcion, SqlDbType.VarChar, reclamo._detalleReclamo, false));
listaParametro.Add(FabricaDAO.asignarParametro(M16Reclamos.rec_fecha, SqlDbType.VarChar, reclamo._fechaReclamo, false));
listaParametro.Add(FabricaDAO.asignarParametro(M16Reclamos.rec_estatus, SqlDbType.Int, reclamo._estadoReclamo.ToString(), false));
listaParametro.Add(FabricaDAO.asignarParametro(M16Reclamos.rec_fk_usuario, SqlDbType.Int, reclamo._usuario.ToString(), false));
EjecutarStoredProcedure(M16Reclamos.procedimientoAgregarReclamo, listaParametro);
return(1);
}
catch (SqlException ex)
{
Log.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ReservaExceptionM16(ex.Message, ex);
}
catch (NullReferenceException ex)
{
Log.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ReservaExceptionM16(ex.Message, ex);
}
catch (ArgumentNullException ex)
{
Log.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ReservaExceptionM16(ex.Message, ex);
}
catch (ExceptionBD ex)
{
Log.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ReservaExceptionM16(ex.Message, ex);
}
catch (LogException ex)
{
throw new ReservaExceptionM16(ex.Message, ex);
}
catch (Exception ex)
{
Log.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ReservaExceptionM16(ex.Message, ex);
}
}
public ActionResult Create(Reclamo reclamo)
{
reclamo.Id = IdentifierGenerator.NewId();
reclamo.IdSesion = 1;
reclamo.FechaUltimaTransaccion = DateTime.Now;
reclamo.FechaRegistro = DateTime.Now;
reclamo.EstadoSincronizacion = TipoEstadoSincronizacion.Pendiente;
reclamo.DescripcionEstadoSincronizacion = "";
if (ModelState.IsValid)
{
modReclamo.Crear(reclamo);
return(RedirectToAction("Index"));
}
return(View(reclamo));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Reclamo reclamo = db.Reclamoes.Include(x => x.hospital).Where(x => x.pedidoId == id).First();
if (reclamo == null)
{
return(HttpNotFound());
}
ViewBag.tipoReclamoId = new SelectList(db.TipoReclamoes, "id", "tipo");
return(View(reclamo));
}
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Reclamo reclamo = db.Reclamoes.Include(r => r.hospital).Include(r => r.Pedido).
Include(r => r.tipoReclamo).Include(r => r.estadoReclamo).Include(r => r.responsableAsignado)
.Where(r => r.pedidoId == id).First();
if (reclamo == null)
{
return(HttpNotFound());
}
return(View(reclamo));
}
public static ResultadoUnico <string, int> Estado_Grabar(Reclamo oReclamo)
{
ResultadoUnico <string, int> oResultado = new ResultadoUnico <string, int>();
string sql = "Reclamo_estado_grabar";
Database db = DatabaseFactory.CreateDatabase("DAT_V01");
DbCommand dbCommand = db.GetStoredProcCommand(sql);
DbParameterCollection dbParametros = null;
try
{
db.AddInParameter(dbCommand, "@IdReclamo", DbType.Int64, oReclamo.IdReclamo);
db.AddInParameter(dbCommand, "@IdEstadoReclamo", DbType.Int32, oReclamo.UnEstadoReclamo.IdEstado);
db.AddInParameter(dbCommand, "@fecCambio", DbType.DateTime, oReclamo.UnEstadoReclamo.FecCambio);
db.AddInParameter(dbCommand, "@observacion", DbType.String, oReclamo.UnEstadoReclamo.observacion);
db.AddInParameter(dbCommand, "@idOficina", DbType.String, oReclamo.UnaAuditoria.IDOficina);
db.AddInParameter(dbCommand, "@Usuario", DbType.String, oReclamo.UnaAuditoria.Usuario);
db.AddInParameter(dbCommand, "@ip", DbType.String, oReclamo.UnaAuditoria.IP);
dbParametros = dbCommand.Parameters;
db.ExecuteNonQuery(dbCommand);
oResultado.DatoUnico2 = 0;
return(oResultado);
}
catch (System.Data.SqlClient.SqlException err)
{
log.Error(string.Format("{0}->{1}->Error:{2}->{3}", DateTime.Now, System.Reflection.MethodBase.GetCurrentMethod(), err.Source, err.Message));
oResultado.Error = new Error();
oResultado.Error.Descripcion = err.Message;
return(oResultado);
}
catch (Exception err)
{
log.Error(string.Format("{0}->{1}->Error:{2}->{3}", DateTime.Now, System.Reflection.MethodBase.GetCurrentMethod(), err.Source, err.Message));
oResultado.Error = new Error();
oResultado.Error.Descripcion = err.Message;
return(oResultado);
}
finally
{
db = null;
dbCommand.Dispose();
}
}
// POST: Reclamos/AutoAsignacion
public ActionResult AutoAsignacion(int?idReclamo, String idResponsable)
{
if (idReclamo == null || idResponsable == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Reclamo reclamo = db.Reclamoes.Find(idReclamo);
if (reclamo == null)
{
return(HttpNotFound());
}
reclamo.responsableAsignadoId = int.Parse(idResponsable);
reclamo.estadoReclamoId = 2; //En Revision
db.Entry(reclamo).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("ListadoReclamos", "Reclamos"));
}
public JsonResult eliminarReclamo(int idReclamo)
{
int idUsuario = gestion_seguridad_ingresoController.IDUsuarioActual();
Command <Entidad> comando = FabricaComando.crearM16ConsultarUsuario(idReclamo);
Reclamo verificacion = (Reclamo)comando.ejecutar();
if (idUsuario != verificacion._usuario)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json("No está autorizado para eliminar este reclamo"));
}
else
{
Command <String> comando1 = FabricaComando.crearM16EliminarReclamo(idReclamo);
String borro_si_no = comando1.ejecutar();
return(Json("1"));
}
}
