public int Delete([FromBody] ParametroModel model)
{
if (!ModelState.IsValid)
{
throw new HttpRequestException(string.Format(
this.myErrorHandler.GetMessage(MensajesErrorEnum.Validacion),
ModelState.Values.First().Errors.First().ErrorMessage));
}
var parametro = this.myService.GetById(model.Id);
if (parametro == null)
{
throw new HttpRequestException(this.myErrorHandler.GetMessage(MensajesErrorEnum.ParametroNoExiste));
}
var result = this.myService.Remove(model.Id);
if (result.CompareTo(0) > 0)
{
return(result);
}
else
{
throw new HttpRequestException(this.myErrorHandler.GetMessage(MensajesErrorEnum.NoAutorizaBorrado));
}
}
public async Task <ParametroModel> Edit([FromBody] ParametroModel request)
{
if (!ModelState.IsValid)
{
throw new HttpRequestException(string.Format(
this.myErrorHandler.GetMessage(MensajesErrorEnum.Validacion),
ModelState.Values.First().Errors.First().ErrorMessage));
}
var parametro = await this.myService.GetById(request.Id);
if (parametro == null)
{
throw new HttpRequestException(this.myErrorHandler.GetMessage(MensajesErrorEnum.ParametroNoExiste));
}
var result = await this.myService.Update(request);
if (result.CompareTo(0) > 0)
{
return(await this.myService.GetById(request.Id));
}
else
{
throw new HttpRequestException(this.myErrorHandler.GetMessage(MensajesErrorEnum.NoAutorizaActualizacion));
}
}
public ParametroModel Create([FromBody] ParametroModel model)
{
if (!ModelState.IsValid)
{
throw new HttpRequestException(string.Format(
this.myErrorHandler.GetMessage(MensajesErrorEnum.Validacion),
ModelState.Values.First().Errors.First().ErrorMessage));
}
var parametro = new ParametroModel
{
Categoria = model.Categoria,
Codigo = model.Codigo,
ValorPrincipal = model.ValorPrincipal,
ValorSecundario = model.ValorSecundario
};
var result = this.myService.Add(parametro);
if (result.CompareTo(0) > 0)
{
return(this.myService.Where(p => p.Codigo.Equals(model.Codigo)).FirstOrDefault());
}
else
{
throw new HttpRequestException(this.myErrorHandler.GetMessage(MensajesErrorEnum.NoAutorizaCreacion));
}
}
public async Task <IHttpActionResult> Put([FromBody] ParametroModel model)
{
IdentityUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
// Se obtiene el parametro y se actualiza la fecha de modificación y el estatus
var param = paramService.GetSingle(c => c.PA_ID_PARAMETRO == model.PA_ID_PARAMETRO);
param.PA_USUARIO_MOD = user.Id;
param.PA_FECHA_MOD = DateTime.Now.Date;
param.PA_ESTATUS = Convert.ToInt16(RegistryStateModel.RegistryState.Pendiente);
param.PA_FECHA_PROCESO = model.PA_FECHA_PROCESO;
param.PA_FRECUENCIA = model.PA_FRECUENCIA;
param.PA_HORA_EJECUCION = model.PA_HORA_EJECUCION;
param.PA_RUTA_CONTABLE = model.PA_RUTA_CONTABLE;
param.PA_RUTA_TEMPORAL = model.PA_RUTA_TEMPORAL;
param.PA_FRECUENCIA_LIMPIEZA = model.PA_FRECUENCIA_LIMPIEZA;
param.PA_CUENTA_LIMPIEZA = model.PA_CUENTA_LIMPIEZA;
param.PA_CENTRO_COSTO_LIMPIEZA = model.PA_CENTRO_COSTO_LIMPIEZA;
//paramService.Update(param);
// Se obtiene el parametro temporal para luego actualizarlo con el parametro
var paramTemp = paramTempService.GetSingle(c => c.PA_ID_PARAMETRO == model.PA_ID_PARAMETRO);
paramTemp = MappingTempFromParam(paramTemp, param);
paramTemp.PA_ESTATUS = Convert.ToInt16(RegistryStateModel.RegistryState.PorAprobar);
paramTempService.Update(paramTemp);
return(Ok());
}
/// <summary>
/// Muestra la vista del formulario de Parámetro
/// </summary>
/// <param name="request">Request</param>
/// <returns>Vista de formulario de Parámetro</returns>
public ActionResult FormularioParametro(ParametroRequest request)
{
ParametroModel model = new ParametroModel();
model.ListaSistema = ListarSistema("", GenericoResource.EtiquetaSeleccionar);
model.ListaTipoParametro = ListarTipoParametro(GenericoResource.EtiquetaSeleccionar);
if (request.CodigoParametro != null)
{
model.Parametro = parametroService.BuscarParametro(new ParametroRequest()
{
CodigoParametro = request.CodigoParametro
}).Result.FirstOrDefault();
model.ListaSistema.ForEach(delegate(SelectListItem item)
{
if (model.Parametro.CodigoSistema != null && item.Value.ToUpper() == model.Parametro.CodigoSistema.ToUpper())
{
item.Selected = true;
}
});
model.ListaTipoParametro.ForEach(delegate(SelectListItem item)
{
if (item.Value == model.Parametro.TipoParametro)
{
item.Selected = true;
}
});
}
return(PartialView(model));
}
/// <summary>
/// Muestra la vista principal
/// </summary>
/// <returns>Vista principal de la opción</returns>
public ActionResult Index()
{
ParametroModel model = new ParametroModel();
model.ListaSistema = ListarSistema("", GenericoResource.EtiquetaTodos);
model.ListaTipoParametro = ListarTipoParametro(GenericoResource.EtiquetaTodos);
return(View(model));
}
public async Task <IHttpActionResult> Post([FromBody] ParametroModel model)
{
IdentityUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
model.PA_USUARIO_CREACION = user.Id;
model.PA_FECHA_CREACION = DateTime.Now.Date;
var parametro = paramService.InsertParametro(model);
return(Ok(parametro));
}
public ParametroModel BuscarPorNome(string NomeParametro)
{
var param = BuzzOnConnection.Instance.Get <Parametro>(p => p.Nome == NomeParametro);
if (param != null)
{
var paramModel = new ParametroModel(param);
return(paramModel);
}
return(null);
}
public IActionResult Edit(ParametroModel model)
{
try
{
if (!ModelState.IsValid)
{
return(View("Edit", model));
}
ps.Edit(model);
SetTempData("Parámetro editado correctamente");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
SetTempData(ex.Message, "error");
return(View("Edit", model));
}
}
private ParametroTempModel MappingTempFromParam(ParametroTempModel paramT, ParametroModel param)
{
paramT.PA_ESTATUS = Convert.ToInt32(RegistryStateModel.RegistryState.Aprobado);
paramT.PA_FECHA_APROBACION = param.PA_FECHA_APROBACION;
paramT.PA_FECHA_CREACION = param.PA_FECHA_CREACION;
paramT.PA_FECHA_MOD = DateTime.Today.Date;
paramT.PA_FECHA_PROCESO = param.PA_FECHA_PROCESO;
paramT.PA_HORA_EJECUCION = param.PA_HORA_EJECUCION;
paramT.PA_ID_PARAMETRO = param.PA_ID_PARAMETRO;
paramT.PA_RUTA_CONTABLE = param.PA_RUTA_CONTABLE;
paramT.PA_RUTA_TEMPORAL = param.PA_RUTA_TEMPORAL;
paramT.PA_USUARIO_APROBADOR = param.PA_USUARIO_APROBADOR;
paramT.PA_USUARIO_CREACION = param.PA_USUARIO_CREACION;
paramT.PA_USUARIO_MOD = param.PA_USUARIO_MOD;
paramT.PA_CUENTA_LIMPIEZA = param.PA_CUENTA_LIMPIEZA;
paramT.PA_CENTRO_COSTO_LIMPIEZA = param.PA_CENTRO_COSTO_LIMPIEZA;
paramT.PA_FRECUENCIA = param.PA_FRECUENCIA;
paramT.PA_FRECUENCIA_LIMPIEZA = param.PA_FRECUENCIA_LIMPIEZA;
return(paramT);
}
public async Task <IHttpActionResult> PutAprobarParametro([FromBody] AprobacionModel model)
{
IdentityUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
var tempModel = paramTempService.GetSingle(c => c.PA_ID_PARAMETRO == model.id);
if (tempModel != null)
{
tempModel.PA_FECHA_APROBACION = DateTime.Now.Date;
tempModel.PA_ESTATUS = Convert.ToInt16(RegistryStateModel.RegistryState.Aprobado);
tempModel.PA_USUARIO_APROBADOR = user.Id;
paramTempService.Update(tempModel);
ParametroModel param = new ParametroModel();
param = MappingParamFromTemp(param, tempModel);
paramService.Update(param);
return(Ok("El parámetro ha sido aprobado."));
}
return(BadRequest("No se encontraron datos para actualizar."));
}
//Funcion para obtener el identificardor y el valor del parametro de la base datos y los retorna en una lista de objetos ParametroModel
public List <ParametroModel> ObtenerInformacionParametro(string tipo)
{
List <ParametroModel> listaParametroResultado = new List <ParametroModel>();
string sentenciaSql = "SELECT ParametroID, Valor " +
"FROM Parametro " +
$"WHERE Tipo like '{tipo}' ";
DataTable tablaDatos = this.conexion.ComandoConsulta(sentenciaSql);
for (int i = 0; i < tablaDatos.Rows.Count; i++)
{
ParametroModel parametroResultado = new ParametroModel();
parametroResultado.Identificador = tablaDatos.Rows[i].Field <int>("ParametroID");
parametroResultado.Valor = tablaDatos.Rows[i].Field <string>("Valor").Replace("_", " ");
listaParametroResultado.Add(parametroResultado);
}
return(listaParametroResultado);
}
//Mapping
private ParametroModel MappingParamFromTemp(ParametroTempModel paramTemp)
{
var param = new ParametroModel();
param.PA_ESTATUS = Convert.ToInt32(RegistryStateModel.RegistryState.Aprobado);
param.PA_FECHA_APROBACION = paramTemp.PA_FECHA_APROBACION;
param.PA_FECHA_CREACION = paramTemp.PA_FECHA_CREACION;
param.PA_FECHA_MOD = paramTemp.PA_FECHA_MOD;
param.PA_FECHA_PROCESO = paramTemp.PA_FECHA_PROCESO;
param.PA_HORA_EJECUCION = paramTemp.PA_HORA_EJECUCION;
param.PA_ID_PARAMETRO = paramTemp.PA_ID_PARAMETRO;
param.PA_RUTA_CONTABLE = paramTemp.PA_RUTA_CONTABLE;
param.PA_RUTA_TEMPORAL = paramTemp.PA_RUTA_TEMPORAL;
param.PA_USUARIO_APROBADOR = paramTemp.PA_USUARIO_APROBADOR;
param.PA_USUARIO_CREACION = paramTemp.PA_USUARIO_CREACION;
param.PA_USUARIO_MOD = paramTemp.PA_USUARIO_MOD;
param.PA_FRECUENCIA = paramTemp.PA_FRECUENCIA;
param.PA_FRECUENCIA_LIMPIEZA = paramTemp.PA_FRECUENCIA_LIMPIEZA;
return(param);
}
public List <ParametroModel> comboBoxTipoSangre()
{
List <ParametroModel> listaComboBoxEnviar = new List <ParametroModel>();
string sql = "select idParametro,valorParametro " +
"from Parametro " +
"where tipoParametro like 'tipo sangre'";
DataTable datos = this.conexion.Consultar(sql);
for (int i = 0; i < datos.Rows.Count; i++)
{
ParametroModel parametroEnviar = new ParametroModel();
parametroEnviar.idParametro = datos.Rows[i].Field <int>("idParametro");
parametroEnviar.valorParametro = datos.Rows[i].Field <string>("valorParametro").Replace("_", " ");
listaComboBoxEnviar.Add(parametroEnviar);
}
return(listaComboBoxEnviar);
}
public async Task <int> Update(ParametroModel entrada)
{
return(await this.myService.Update(this.myMapper.Map <ParametroModel, Parametro>(entrada)));
}
public int Add(ParametroModel entrada)
{
return(this.myService.Add(this.myMapper.Map <ParametroModel, Parametro>(entrada)));
}
