public ActionResult CambiarStatus([Bind(Include = "UsuarioID,TipoPermisoID,Status")] Permiso permiso)
{
var valPermiso = db.Permisos.Find(permiso.UsuarioID, permiso.TipoPermisoID);
TipoPermiso tipoPermiso = db.TipoPermisos.Find(permiso.TipoPermisoID);
if (valPermiso == null)
{
//no existe y hay que insertarlo
permiso.Status = true;
db.Permisos.Add(permiso);
AlertaSuccess(string.Format("Permiso: <b>{0}</b> se ACTIVO.", tipoPermiso.Nombre), true);
}
else
{
//existe entonces hay que eliminarlo
db.Permisos.Remove(valPermiso);
AlertaWarning(string.Format("Permiso: <b>{0}</b> se DESACTIVO.", tipoPermiso.Nombre), true);
}
db.SaveChanges();
string url = Url.Action("Lista", "Permiso", new { id = permiso.UsuarioID });
return(Json(new { success = true, url = url, modelo = "Permiso" }, JsonRequestBehavior.AllowGet));
}
public Response Crear(TipoPermiso tipoPermiso)
{
try
{
var respuesta = Existe(tipoPermiso);
if (!respuesta.IsSuccess)
{
tipoPermiso.Nombre = tipoPermiso.Nombre.TrimStart().TrimEnd().ToUpper();
db.Add(tipoPermiso);
db.SaveChanges();
return(new Response
{
IsSuccess = true,
Message = "Ok",
});
}
else
{
return(new Response
{
IsSuccess = false,
Message = "Existe un tipo de permiso con igual nombre...",
});
}
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = ex.Message,
});
}
}
public async Task <IActionResult> Edit(string id, TipoPermiso TipoPermiso)
{
Response response = new Response();
try
{
if (!string.IsNullOrEmpty(id))
{
response = await apiServicio.EditarAsync(id, TipoPermiso, new Uri(WebApp.BaseAddress),
"api/TiposPermiso");
if (response.IsSuccess)
{
this.TempData["MensajeTimer"] = $"{Mensaje.Success}|{response.Message}|{"7000"}";
return(RedirectToAction("Index"));
}
this.TempData["MensajeTimer"] = $"{Mensaje.Error}|{response.Message}|{"10000"}";
return(View(TipoPermiso));
}
return(BadRequest());
}
catch (Exception ex)
{
return(BadRequest());
}
}
public static MvcHtmlString PermissionCustomControl(this HtmlHelper htmlHelper, int seccion, TipoPermiso tipoPermiso, string html)
{
bool hasPermiso =
WebSession.FormularioActual.PermisoList.Any(p => p.Seccion == seccion && p.TipoPermiso == (int)tipoPermiso);
return new MvcHtmlString(hasPermiso ? html : string.Empty);
}
public async Task <IActionResult> RegisterPermitTypes([FromBody] TipoPermiso tipoPermiso)
{
try
{
await _GenericRepository.CreateAsync(tipoPermiso);
_UnitOfWork.Commit();
return(Ok(new Request()
{
status = true,
message = "The type of permit was registered correctly",
data = tipoPermiso
}));
}
catch (Exception ex)
{
return(Ok(new Request()
{
status = false,
message = "The type of permit was not registered correctly",
data = ex.Message
}));
}
}
public async Task <IActionResult> PutPermitType([FromRoute] int id, [FromBody] TipoPermiso permit)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != permit.Id)
{
return(BadRequest());
}
_context.Entry(permit).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PermitExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public Boolean Guardar(clsTipoPermiso tiPe)
{
try
{
using (RecursosHumanosEntities ent = new RecursosHumanosEntities())
{
TipoPermiso tiP = new TipoPermiso()
{
IdTipoPermiso = tiPe.IdTipoPermiso,
Descripcion = tiPe.Descripcion,
IdEmpresa = tiPe.IdEmpresa,
IdEstado = tiPe.IdEstado,
};
ent.AddToTipoPermiso(tiP);
ent.SaveChanges();
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine("Error:" + ex);
return(false);
}
}
public async Task <IActionResult> ModifyPermitTypes([FromBody] TipoPermiso tipoPermiso)
{
try
{
await _GenericRepository.UpdateAsync(tipoPermiso);
_UnitOfWork.Commit();
return(Ok(new Request()
{
status = true,
message = "This action was successful",
data = tipoPermiso
}));
}
catch (Exception ex)
{
return(Ok(new Request()
{
status = false,
message = "An unexpected error occurred",
data = ex.Message
}));
}
}
public async Task <IActionResult> Create(TipoPermiso TipoPermiso)
{
if (!ModelState.IsValid)
{
this.TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ModeloInvalido}";
return(View(TipoPermiso));
}
Response response = new Response();
try
{
response = await apiServicio.InsertarAsync(TipoPermiso,
new Uri(WebApp.BaseAddress),
"api/TiposPermiso/InsertarTipoPermiso");
if (response.IsSuccess)
{
this.TempData["MensajeTimer"] = $"{Mensaje.Success}|{response.Message}|{"7000"}";
return(RedirectToAction("Index"));
}
this.TempData["MensajeTimer"] = $"{Mensaje.Error}|{response.Message}|{"7000"}";
return(View(TipoPermiso));
}
catch (Exception ex)
{
return(BadRequest());
}
}
internal static void AuthorizeAccion(IdAccion idAccion, int idUsuario, TipoPermiso eJECUCION)
{
var keyArray = new KeyArray();
var tpAuth = CachingManager.Instance.GetAutorizacion(idUsuario, (short)idAccion, eJECUCION).tipoAutorizacion;
if (tpAuth == TipoAutorizacion.CON_PERMISOS || tpAuth == TipoAutorizacion.CON_DOBLE_CONTROL)
{
return;
}
AccionEntity accion = CachingManager.Instance.GetAccionById((short)idAccion);
keyArray.Codigo = CodigosMensajes.FE_ERROR_FALTA_PERMISOS;
if (accion != null)
{
keyArray.Parametros.Add(accion.Descripcion);
}
else
{
keyArray.Parametros.Add(string.Format("Acción {0} no encontrada", idAccion));
}
var fe = new AuthorizationException(001);
fe.DataValidations.Add(keyArray);
throw fe;
}
public ActionResult DeleteConfirmed(Guid id)
{
string btnValue = Request.Form["accionx"];
TipoPermiso tipoPermiso = db.TipoPermisos.Find(id);
switch (btnValue)
{
case "deshabilitar":
tipoPermiso.Status = false;
db.Entry(tipoPermiso).State = EntityState.Modified;
db.SaveChanges();
AlertaDefault(string.Format("Se deshabilito <b>{0}, {1}</b>", tipoPermiso.Clave, tipoPermiso.Nombre), true);
break;
case "eliminar":
db.TipoPermisos.Remove(tipoPermiso);
db.SaveChanges();
AlertaDanger(string.Format("Se elimino <b>{0}, {1}</b>", tipoPermiso.Clave, tipoPermiso.Nombre), true);
break;
default:
AlertaDanger(string.Format("Ocurrio un error."), true);
break;
}
string url = Url.Action("Lista", "TipoPermiso");
return(Json(new { success = true, url = url }));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
TipoPermiso tipoPermiso = await db.TipoPermiso.FindAsync(id);
db.TipoPermiso.Remove(tipoPermiso);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Edit([Bind(Include = "IdTipoPermiso,VDescripcionPermiso")] TipoPermiso tipoPermiso)
{
if (ModelState.IsValid)
{
db.Entry(tipoPermiso).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(tipoPermiso));
}
public async Task <IActionResult> PostPermitType(TipoPermiso permit)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.TiposPermisos.Add(permit);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPermitsType", new { id = permit.Id }, permit));
}
public async Task <ActionResult> Create([Bind(Include = "IdTipoPermiso,VDescripcionPermiso")] TipoPermiso tipoPermiso)
{
if (ModelState.IsValid)
{
db.TipoPermiso.Add(tipoPermiso);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(tipoPermiso));
}
public async Task <Response> PostTipoPermiso([FromBody] TipoPermiso TipoPermiso)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var respuesta = Existe(TipoPermiso);
if (!respuesta.IsSuccess)
{
db.TipoPermiso.Add(TipoPermiso);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio
});
}
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro
});
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.SwTH),
ExceptionTrace = ex,
Message = Mensaje.Excepcion,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "",
});
return(new Response
{
IsSuccess = false,
Message = Mensaje.Error,
});
}
}
public bool Add(TipoPermiso model)
{
try
{
_permisoDbContext.Add(model);
_permisoDbContext.SaveChanges();
}
catch (System.Exception)
{
return(false);
}
return(true);
}
public TipoPermiso Get(int id)
{
var result = new TipoPermiso();
try
{
result = _permisoDbContext.tipoPermisos.Single(x => x.Id == id);
}
catch (System.Exception)
{
}
return(result);
}
public string nameByID(int id)
{
TipoPermiso tipoPermiso = new TipoPermiso();
tipoPermiso.idTipoPermiso = id;
if (tipoPermiso.read())
{
return(tipoPermiso.nombreTipoPermiso);
}
else
{
return(string.Empty);
}
}
// GET: TipoPermisos/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoPermiso tipoPermiso = await db.TipoPermiso.FindAsync(id);
if (tipoPermiso == null)
{
return(HttpNotFound());
}
return(View(tipoPermiso));
}
public ActionResult Editar([Bind(Include = "TipoPermisoID,Clave,Nombre,Descripcion,Status")] TipoPermiso tipoPermiso)
{
if (ModelState.IsValid)
{
db.Entry(tipoPermiso).State = EntityState.Modified;
db.SaveChanges();
AlertaSuccess(string.Format("Tipo de Permiso: <b>{0}, {1}</b> se edito con exitó.", tipoPermiso.Clave, tipoPermiso.Nombre), true);
string url = Url.Action("Lista", "TipoPermiso");
return(Json(new { success = true, url = url }));
}
return(PartialView("_Editar", tipoPermiso));
}
protected void btnEliminar_Click(object sender, EventArgs e)
{
TipoPermiso tp = new TipoPermiso();
tp.IdTipoPermiso = ddlTipoPermiso.SelectedIndex;
if (tp.Delete())
{
ClientScript.RegisterStartupScript(this.GetType(), "mensaje", "verificacionDelete(true)", true);
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "mensaje", "verificacionDelete(false)", true);
}
}
public ActionResult Editar(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoPermiso tipoPermiso = db.TipoPermisos.Find(id);
if (tipoPermiso == null)
{
return(HttpNotFound());
}
return(PartialView("_Editar", tipoPermiso));
}
public AutorizationType GetAutorizacion(int idUsuario, short idAccion, TipoPermiso tipo_permiso)
{
string keyCache = KEY_AUTHORIZE + idUsuario + idAccion + tipo_permiso;
AutorizationType autorizacion = CacheLayer.Get <AutorizationType>(keyCache);
if (autorizacion == null)
{
autorizacion = new AutorizationType();
autorizacion.tipoAutorizacion = SecurityHelper.AuthorizeAccion(idUsuario, (short)idAccion.GetHashCode(), tipo_permiso);
if (autorizacion != null)
{
Insert(keyCache, autorizacion, DateTime.Now.AddMinutes(30));
}
}
return(autorizacion);
}
public async Task <IActionResult> Edit(string id, TipoPermiso TipoPermiso)
{
Response response = new Response();
try
{
if (!string.IsNullOrEmpty(id))
{
response = await apiServicio.EditarAsync(id, TipoPermiso, new Uri(WebApp.BaseAddress),
"/api/TiposPermiso");
if (response.IsSuccess)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
EntityID = string.Format("{0} : {1}", "Sistema", id),
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit),
LogLevelShortName = Convert.ToString(LogLevelParameter.ADV),
Message = "Se ha actualizado un registro sistema",
UserName = "******"
});
return(RedirectToAction("Index"));
}
ViewData["Error"] = response.Message;
return(View(TipoPermiso));
}
return(BadRequest());
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
Message = "Editando un tipo de permiso",
ExceptionTrace = ex,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "******"
});
return(BadRequest());
}
}
public IList <TipoPermiso> listado()
{
TipoPermiso permiso = new TipoPermiso();
IList <TipoPermiso> lista = new List <TipoPermiso>();
if (permiso.readAll())
{
foreach (var item in permiso.coleccion)
{
lista.Add(item);
}
return(lista);
}
else
{
return(null);
}
}
public async Task <IActionResult> Create(TipoPermiso TipoPermiso)
{
Response response = new Response();
try
{
response = await apiServicio.InsertarAsync(TipoPermiso,
new Uri(WebApp.BaseAddress),
"/api/TiposPermiso/InsertarTipoPermiso");
if (response.IsSuccess)
{
var responseLog = await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
ExceptionTrace = null,
Message = "Se ha creado un tipo de permiso",
UserName = "******",
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
LogLevelShortName = Convert.ToString(LogLevelParameter.ADV),
EntityID = string.Format("{0} {1}", "TipoPermiso:", TipoPermiso.IdTipoPermiso),
});
return(RedirectToAction("Index"));
}
ViewData["Error"] = response.Message;
return(View(TipoPermiso));
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
Message = "Creando un tipo de permiso",
ExceptionTrace = ex,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "******"
});
return(BadRequest());
}
}
public static string GetString(TipoPermiso tipo)
{
switch (tipo)
{
case TipoPermiso.Administrativo:
return("Administrativo");
case TipoPermiso.DecesoDeFamiliar:
return("Deceso de Familiar");
case TipoPermiso.FeriadoLegal:
return("Feriado Legal");
case TipoPermiso.NacimientoDeHijo:
return("Nacimiento de Hijo");
default:
return("");
}
}
public bool Update(TipoPermiso model)
{
try
{
var originalModel = _permisoDbContext.tipoPermisos.Single(x =>
x.Id == model.Id
);
originalModel.Descripcion = model.Descripcion;
_permisoDbContext.Update(originalModel);
_permisoDbContext.SaveChanges();
}
catch (System.Exception)
{
return(false);
}
return(true);
}
public async Task <Response> PostTipoPermiso([FromBody] TipoPermiso TipoPermiso)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var respuesta = Existe(TipoPermiso);
if (!respuesta.IsSuccess)
{
db.TipoPermiso.Add(TipoPermiso);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.GuardadoSatisfactorio
});
}
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.Excepcion,
});
}
}
private Response Existe(TipoPermiso TipoPermiso)
{
var bdd = TipoPermiso.Nombre;
var TipoPermisorespuesta = db.TipoPermiso.Where(p => p.Nombre == bdd).FirstOrDefault();
if (TipoPermisorespuesta != null)
{
return(new Response
{
IsSuccess = true,
Message = Mensaje.ExisteRegistro,
Resultado = null,
});
}
return(new Response
{
IsSuccess = false,
Resultado = TipoPermisorespuesta,
});
}
public HttpGetAction(TipoPermiso permiso)
{
_permiso = permiso;
}
/// <summary>
/// Comprueba si un usuario determinado posee el permiso indicado
/// </summary>
/// <param name="Usuario_id"></param>
/// <param name="permiso"></param>
/// <returns></returns>
public static bool comprobarPermiso(int Usuario_id, TipoPermiso permiso)
{
int rol = GetRol(Usuario_id);
return _db.Permiso.Any(p => p.Id == (int)permiso && p.Rol.Any(r => r.Id == rol));
}
