public async Task<ActionResult> Nuevo([Bind(Include="id,nombre,id_afr,activo,potenciador,subSelect,calculo")] Factores_Riesgo factores_riesgo)
{
if (ModelState.IsValid)
{
db.Factores_Riesgo.Add(factores_riesgo);
await db.SaveChangesAsync();
if(factores_riesgo.subSelect != null && factores_riesgo.subSelect.Count>0){
List<FRRiesgo> nue = new List<FRRiesgo>();
foreach(String e in factores_riesgo.subSelect){
FRRiesgo intro = new FRRiesgo();
intro.id_fr = factores_riesgo.id;
intro.id_riesgo = e;
nue.Add(intro);
}
db.FRRiesgo.AddRange(nue);
await db.SaveChangesAsync();
}
Historial nuevo = new Historial("Creó", User.Identity.GetUserId(), "Factores_Riesgo", factores_riesgo.id, factores_riesgo.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Factor de Riesgo creado correctamente.";
return RedirectToAction("Editar","FactoresRiesgos",new{id=factores_riesgo.id});
}
TempData["Mensaje"] = "Error al crear la FactoresRiesgos.";
return View(factores_riesgo);
}
public async Task<ActionResult> Editar([Bind(Include="id,nombre,activo")] Riesgos riesgos)
{
if (ModelState.IsValid)
{
db.Entry(riesgos).State = EntityState.Modified;
await db.SaveChangesAsync();
Historial nuevo = new Historial("Editó", User.Identity.GetUserId(), "Riesgos", riesgos.id, riesgos.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Riesgos creada correctamente.";
return RedirectToAction("Index");
}
TempData["Mensaje"] = "Error al crear la Riesgos.";
return View(riesgos);
}
public async Task<ActionResult> Editar([Bind(Include="id,nombre,descripcion,enlace")] Informacion informacion)
{
if (ModelState.IsValid)
{
db.Entry(informacion).State = EntityState.Modified;
await db.SaveChangesAsync();
Historial nuevo = new Historial("Editó", User.Identity.GetUserId(), "Informacion", informacion.id, informacion.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Informacion creada correctamente.";
return RedirectToAction("Editar","Informacion",new{id=informacion.id});
}
TempData["Mensaje"] = "Error al crear la Informacion.";
return RedirectToAction("Editar","Informacion",new{id=informacion.id});
}
public async Task<ActionResult> Editar([Bind(Include="id,nombre,descripcion")] Tipo_Cimentaciones tipo_cimentaciones)
{
if (ModelState.IsValid)
{
db.Entry(tipo_cimentaciones).State = EntityState.Modified;
await db.SaveChangesAsync();
Historial nuevo = new Historial("Editó", User.Identity.GetUserId(), "Tipo_Cimentaciones", tipo_cimentaciones.id, tipo_cimentaciones.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Tipo de Cimentación editada correctamente.";
return RedirectToAction("Editar", "Tipo_Cimentaciones", new { id = tipo_cimentaciones.id });
}
TempData["Mensaje"] = "Error al editar el Tipo de Cimentación.";
return View(tipo_cimentaciones);
}
public async Task<ActionResult> Editar([Bind(Include="id,tipo,coste")] Tipo_Maquinaria tipo_maquinaria)
{
if (ModelState.IsValid)
{
db.Entry(tipo_maquinaria).State = EntityState.Modified;
await db.SaveChangesAsync();
Historial nuevo = new Historial("Editó", User.Identity.GetUserId(), "Tipo_Maquinaria", tipo_maquinaria.id, tipo_maquinaria.tipo, Request.UserHostAddress);
TempData["Mensaje"] = "Tipo_Maquinaria creada correctamente.";
return RedirectToAction("Index");
}
TempData["Mensaje"] = "Error al crear el Tipo de Maquinaria.";
return View(tipo_maquinaria);
}
public async Task<ActionResult> Editar([Bind(Include="id,nombre")] Agrupacion_FR agrupacion_fr)
{
if (ModelState.IsValid)
{
db.Entry(agrupacion_fr).State = EntityState.Modified;
await db.SaveChangesAsync();
Historial nuevo = new Historial("Editó", User.Identity.GetUserId(), "Agrupacion_FR", agrupacion_fr.id, agrupacion_fr.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Agrupacion de Factores de Riesgo editada correctamente.";
return RedirectToAction("Editar", "Agrupacion_FactoresRiesgo", new { id = agrupacion_fr.id });
}
TempData["Mensaje"] = "Error al editar la Agrupacion de Factores de Riesgo.";
return View(agrupacion_fr);
}
public async Task<ActionResult> Editar([Bind(Include="id,nombre,valor")] Peso peso)
{
if (ModelState.IsValid)
{
db.Entry(peso).State = EntityState.Modified;
await db.SaveChangesAsync();
Historial nuevo = new Historial("Editó", User.Identity.GetUserId(), "Peso", peso.id, peso.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Peso creada correctamente.";
return RedirectToAction("Index");
}
TempData["Mensaje"] = "Error al crear la Peso.";
return View(peso);
}
public async Task<ActionResult> Nuevo([Bind(Include="nombre,valor")] Patologias patologias)
{
if (ModelState.IsValid)
{
db.Patologias.Add(patologias);
await db.SaveChangesAsync();
Historial nuevo = new Historial("Eliminó", User.Identity.GetUserId(), "Patologias", patologias.id, patologias.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Patología creada correctamente.";
return RedirectToAction("Index");
}
TempData["Mensaje"] = "Error al crear la Patología.";
return View(patologias);
}
public async Task<ActionResult> Nuevo([Bind(Include="id,tipo,coste")] Tipo_Personal tipo_personal)
{
if (ModelState.IsValid)
{
db.Tipo_Personal.Add(tipo_personal);
await db.SaveChangesAsync();
Historial nuevo = new Historial("Creó", User.Identity.GetUserId(), "Tipo_Personal", tipo_personal.id, tipo_personal.tipo, Request.UserHostAddress);
TempData["Mensaje"] = "Tipo de Personal creado correctamente.";
return RedirectToAction("Index");
}
TempData["Mensaje"] = "Error al crear el Tipo de Personal.";
return View(tipo_personal);
}
public async Task<ActionResult> Nuevo([Bind(Include="id,nombre,val,activo")] Grados_Proximidad grados_proximidad)
{
if (ModelState.IsValid)
{
grados_proximidad.valor = double.Parse(grados_proximidad.val.Replace(".",","));
db.Grados_Proximidad.Add(grados_proximidad);
await db.SaveChangesAsync();
Historial nuevo = new Historial("Creó", User.Identity.GetUserId(), "Grados_Proximidad", grados_proximidad.id, grados_proximidad.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Grado de Proximidad creado correctamente.";
return RedirectToAction("Editar","GradosProximidad",new{id=grados_proximidad.id});
}
TempData["Mensaje"] = "Error al crear el Grado de Proximidad.";
return View(grados_proximidad);
}
public async Task<ActionResult> Nuevo([Bind(Include = "id,nombre,zonastring")] ZonasLista zonas)
{
if (ModelState.IsValid)
{
Zonas zonasNueva = new Zonas();
zonasNueva.id = Guid.NewGuid().ToString();
zonasNueva.nombre = zonas.nombre;
zonasNueva.poligono = DbGeography.PolygonFromText(zonas.zonastring, 4326).AsBinary();
zonas.tipo = "77268b47-79d5-49a7-8475-acf6f618e9f8";
db.Zonas.Add(zonasNueva);
await db.SaveChangesAsync();
Historial nuevo = new Historial("Creó", User.Identity.GetUserId(), "Zonas", zonasNueva.id, zonasNueva.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Zonas creada correctamente.";
return RedirectToAction("Editar", "Zonas", new { id = zonasNueva.id });
}
TempData["Mensaje"] = "Error al crear la Zonas.";
return View(zonas);
}
public async Task<ActionResult> Nuevo([Bind(Include = "id,nombre,lat,lon,t_coordenadas")] SubestacionesForm model)
{
if (ModelState.IsValid)
{
try {
///Coordenadas Geográfricas
if (model.t_coordenadas == 1)
{
Subestaciones subestacion = new Subestaciones();
subestacion.nombre = model.nombre;
subestacion.coordenadas = System.Data.Entity.Spatial.DbGeography.PointFromText("POINT(" + model.lat + " " + model.lon + ")", 4326).AsBinary();
db.Subestaciones.Add(subestacion);
await db.SaveChangesAsync();
model.id = subestacion.id;
}
///Coordenadas UTM
else {
model.id = Guid.NewGuid().ToString();
bool insertar_utm = new Models.Subestaciones().UTM_Insertar(model);
}
Historial nuevo = new Historial("Creó", User.Identity.GetUserId(), "Subestaciones", model.id, model.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Subestaciones creada correctamente.";
return RedirectToAction("Editar", "Subestaciones", new { id = model.id });
}
catch {
TempData["Mensaje"] = "Error al crear la Subestaciones.";
return View(model);
}
}
TempData["Mensaje"] = "Error al crear la Subestaciones.";
return View(model);
}
public async Task<ActionResult> Nuevo([Bind(Include = "id,nombre,subSelect,color")] LineasForm lineas)
{
if (ModelState.IsValid)
{
Lineas nuevaL = new Lineas();
nuevaL.nombre = lineas.nombre;
if (String.IsNullOrEmpty(lineas.color))
{
lineas.color = "#d450b7";
}
else {
nuevaL.color = lineas.color;
}
db.Lineas.Add(nuevaL);
await db.SaveChangesAsync();
List<Subestaciones_Linea> sub_li = new List<Subestaciones_Linea>();
foreach(var e in lineas.subSelect){
Subestaciones_Linea ne = new Subestaciones_Linea();
ne.id_linea = nuevaL.id;
ne.id_subestacion = e;
sub_li.Add(ne);
}
db.Subestaciones_Linea.AddRange(sub_li);
await db.SaveChangesAsync();
Historial nuevo = new Historial("Creó", User.Identity.GetUserId(), "Lineas", lineas.id, lineas.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Línea creada correctamente.";
return RedirectToAction("Index");
}
TempData["Mensaje"] = "Error al crear la Línea.";
return View(lineas);
}
public async Task<ActionResult> Nuevo([Bind(Include="id,nombre,descripcion,anomalia,grado_anomalia,tiempo_programacion,tiempo_ejecucion,rendimiento,coste_total")] Operaciones operaciones)
{
if (ModelState.IsValid)
{
operaciones.medios = "propios";
db.Operaciones.Add(operaciones);
await db.SaveChangesAsync();
Historial nuevo = new Historial("Creó", User.Identity.GetUserId(), "Operaciones", operaciones.id, operaciones.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Operación creada correctamente.";
return RedirectToAction("Editar", "Operaciones", new {id=operaciones.id });
}
TempData["Mensaje"] = "Error al crear la Operación.";
Utiles utiles = new Utiles();
operaciones.lista_anomalias = utiles.Listas()[1];
return View(operaciones);
}
public async Task<ActionResult> Recovery(CambiarPassword model)
{
if (ModelState.IsValid)
{
var us = await UserManager.FindByNameAsync(model.username);
var result = await UserManager.RemovePasswordAsync(us.Id);
result = await UserManager.AddPasswordAsync(us.Id, model.Password);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(us.Id);
Historial nuevo = new Historial("Cambió Contraseña", us.Id, "usuario", us.Id, user.UserName, Request.UserHostAddress);
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
TempData["MensajeCambioContrasena"] = "Se ha cambiado la contraseña correctamente al usuario." + user.UserName;
Conexion db = new Conexion();
List<UsuarioRecovery> listaRecovery = db.UsuarioRecovery.Where(m => m.username == model.username).ToList();
db.UsuarioRecovery.RemoveRange(listaRecovery);
await db.SaveChangesAsync();
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index","Acceso",new{returnUrl = "/"});
}
else
{
AddErrors(result);
}
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
TempData["Mensaje"] = "Error al cambiar la contraseña.";
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Recovery", "Acceso", new { id = model.id });
}
/// <summary>
/// Método para actializar los medios de la Operación
/// </summary>
/// <param name="op_nuevo"></param>
/// <param name="id"></param>
/// <param name="ip"></param>
/// <returns></returns>
public async Task Actualizar(Operaciones_Medios_Propios op_nuevo, string id, string ip)
{
using(var db = new Conexion()){
decimal coste_total = 0;
//Eliminar las Subcontratas de esta Operación
List<Operaciones_Subcontratas> op_sub = db.Operaciones_Subcontratas.Where(m => m.operacion_id == op_nuevo.id).ToList();
db.Operaciones_Subcontratas.RemoveRange(op_sub);
await db.SaveChangesAsync();
List<Operaciones_TipoPersonal> intro_opp = new List<Operaciones_TipoPersonal>();
intro_opp = db.Operaciones_TipoPersonal.Where(m=>m.operacion == op_nuevo.id).ToList();
db.Operaciones_TipoPersonal.RemoveRange(intro_opp);
db.SaveChanges();
intro_opp.Clear();
int posicion = 0;
foreach (int i in op_nuevo.c_personal)
{
if (i != 0)
{
Operaciones_TipoPersonal n_opp = new Operaciones_TipoPersonal();
n_opp.operacion = op_nuevo.id;
n_opp.tipo_personal = op_nuevo.lista_personal[posicion];
n_opp.cantidad = i;
intro_opp.Add(n_opp);
//Sumar el coste total de la operación
var t_p = db.Tipo_Personal.SingleOrDefault(m => m.id == n_opp.tipo_personal);
coste_total = coste_total + (t_p.coste * i) * op_nuevo.tiempo_ejecucion;
}
posicion++;
};
db.Operaciones_TipoPersonal.AddRange(intro_opp);
await db.SaveChangesAsync();
Historial nuevo = new Historial("Modificó Tipos de Personal", id, "usuario", ip);
List<Operaciones_TipoMaterial> intro_opm = new List<Operaciones_TipoMaterial>();
intro_opm = db.Operaciones_TipoMaterial.Where(m => m.operacion == op_nuevo.id).ToList();
db.Operaciones_TipoMaterial.RemoveRange(intro_opm);
await db.SaveChangesAsync();
intro_opm.Clear();
posicion = 0;
foreach (int i in op_nuevo.c_material)
{
if (i != 0)
{
Operaciones_TipoMaterial n_opp = new Operaciones_TipoMaterial();
n_opp.operacion = op_nuevo.id;
n_opp.tipo_material = op_nuevo.lista_material[posicion];
n_opp.cantidad = i;
intro_opm.Add(n_opp);
//Sumar el coste total de la operación
var t_p = db.Tipo_Material.SingleOrDefault(m => m.id == n_opp.tipo_material);
coste_total = coste_total + t_p.coste * i;
}
posicion++;
};
db.Operaciones_TipoMaterial.AddRange(intro_opm);
await db.SaveChangesAsync();
Historial nuevo_material = new Historial("Modificó Tipos de Material", id, "usuario", ip);
List<Operaciones_TipoMaquinaria> intro_opma = new List<Operaciones_TipoMaquinaria>();
intro_opma = db.Operaciones_TipoMaquinaria.Where(m => m.operacion == op_nuevo.id).ToList();
db.Operaciones_TipoMaquinaria.RemoveRange(intro_opma);
await db.SaveChangesAsync();
intro_opma.Clear();
posicion = 0;
foreach (int i in op_nuevo.c_maquinaria)
{
if (i != 0)
{
Operaciones_TipoMaquinaria n_opp = new Operaciones_TipoMaquinaria();
n_opp.operacion = op_nuevo.id;
n_opp.tipo_maquinaria = op_nuevo.lista_maquinaria[posicion];
n_opp.cantidad = i;
intro_opma.Add(n_opp);
//Sumar el coste total de la operación
var t_p = db.Tipo_Maquinaria.SingleOrDefault(m => m.id == n_opp.tipo_maquinaria);
coste_total = coste_total + (t_p.coste * i)*op_nuevo.tiempo_ejecucion;
}
posicion++;
};
db.Operaciones_TipoMaquinaria.AddRange(intro_opma);
await db.SaveChangesAsync();
Historial nuevo_maquinarias = new Historial("Modificó Tipos de Maquinarias", id, "usuario", ip);
Operaciones operaciones = await db.Operaciones.FindAsync(op_nuevo.id);
operaciones.coste_total = coste_total;
operaciones.medios = "propios";
db.Entry(operaciones).State = EntityState.Modified;
await db.SaveChangesAsync();
}
}
/// <summary>
/// Método para actializar los medios de la Operación
/// </summary>
/// <param name="op_nuevo"></param>
/// <param name="id"></param>
/// <param name="ip"></param>
/// <returns></returns>
public async Task Actualizar(Operaciones_Medios_Subcontratados op_nuevo, string id, string ip)
{
using (var db = new Conexion())
{
//Eliminar las Subcontratas de esta Operación
List<Operaciones_Subcontratas> op_sub = db.Operaciones_Subcontratas.Where(m => m.operacion_id == op_nuevo.id).ToList();
db.Operaciones_Subcontratas.RemoveRange(op_sub);
await db.SaveChangesAsync();
//Elimino Medios de Tipo Personal
List<Operaciones_TipoPersonal> intro_opp = new List<Operaciones_TipoPersonal>();
intro_opp = db.Operaciones_TipoPersonal.Where(m => m.operacion == op_nuevo.id).ToList();
db.Operaciones_TipoPersonal.RemoveRange(intro_opp);
await db.SaveChangesAsync();
//Elimino Medios de Tipo Material
List<Operaciones_TipoMaterial> intro_opm = new List<Operaciones_TipoMaterial>();
intro_opm = db.Operaciones_TipoMaterial.Where(m => m.operacion == op_nuevo.id).ToList();
db.Operaciones_TipoMaterial.RemoveRange(intro_opm);
await db.SaveChangesAsync();
//Elimino Medios de Tipo Maquinaria
List<Operaciones_TipoMaquinaria> intro_opma = new List<Operaciones_TipoMaquinaria>();
intro_opma = db.Operaciones_TipoMaquinaria.Where(m => m.operacion == op_nuevo.id).ToList();
db.Operaciones_TipoMaquinaria.RemoveRange(intro_opma);
await db.SaveChangesAsync();
Operaciones_Subcontratas nuevo = new Operaciones_Subcontratas();
nuevo.cantidad = op_nuevo.coste_sub;
nuevo.operacion_id = op_nuevo.id;
nuevo.subcontrata_id = op_nuevo.subcontrata;
db.Operaciones_Subcontratas.Add(nuevo);
await db.SaveChangesAsync();
Operaciones operaciones = await db.Operaciones.FindAsync(op_nuevo.id);
operaciones.coste_total = op_nuevo.coste_sub;
operaciones.medios = "subcontratados";
db.Entry(operaciones).State = EntityState.Modified;
await db.SaveChangesAsync();
Historial historial = new Historial("Modificó Medio de Tipo Subcontrata", id, "usuario", ip);
}
}
public async Task<ActionResult> Eliminar(string id)
{
Grados_Proximidad grados_proximidad = await db.Grados_Proximidad.FindAsync(id);
if (grados_proximidad == null)
{
return HttpNotFound();
}
db.Grados_Proximidad.Remove(grados_proximidad);
await db.SaveChangesAsync();
Historial nuevo = new Historial("Eliminó", User.Identity.GetUserId(), "Grados_Proximidad", grados_proximidad.id, grados_proximidad.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Grado de Proximidad eliminado correctamente.";
return RedirectToAction("Index");
}
public async Task<ActionResult> Editar(EditarPerfilUsuario model)
{
if (ModelState.IsValid)
{
StringHash text = new StringHash();
var user = await UserManager.FindByNameAsync(User.Identity.Name);
user.nombre = model.nombre;
user.apellido1 = model.apellido1;
user.apellido2 = model.apellido2;
user.telefono = model.telefono;
user.email = model.email;
user.cod_secreto = text.Encrypt(model.cod_secreto,true,user.UserName);
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
Historial nuevo = new Historial("Modificó su Perfil", User.Identity.GetUserId(), "usuario",Request.UserHostAddress);
TempData["Mensaje"] = "Datos del Usuario modificados correctamente.";
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Perfil", "Usuarios");
}
else
{
AddErrors(result);
}
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
TempData["Mensaje"] = "Error al modificar los datos.";
return RedirectToAction("Perfil", "Usuarios");
}
public async Task<ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
Historial nuevo = new Historial("Cambió Contraseña", User.Identity.GetUserId(), "usuario", User.Identity.GetUserId(), User.Identity.Name, Request.UserHostAddress);
TempData["Mensaje"] = "Contraseña cambiada correctamente.";
return RedirectToAction("Perfil","Usuarios");
}
else
{
AddErrors(result);
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
Historial nuevo = new Historial("Cambió Contraseña", User.Identity.GetUserId(), "usuario", User.Identity.GetUserId(), User.Identity.Name, Request.UserHostAddress);
TempData["Mensaje"] = "Contraseña cambiada correctamente.";
return RedirectToAction("Perfil", "Usuarios");
}
else
{
AddErrors(result);
}
}
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
TempData["Mensaje"] = "Error al cambiar la contraseña.";
return RedirectToAction("Perfil", "Usuarios");
}
public ActionResult LogOff()
{
string url = System.Web.HttpContext.Current.Request.ApplicationPath;
AuthenticationManager.SignOut();
Historial nuevo = new Historial("Cerró Conexión", User.Identity.GetUserId(), "salir", Request.UserHostAddress);
return RedirectToAction("Index", "Acceso", new { ReturnUrl = url });
}
public async Task<ActionResult> CambiarPass(CambiarPassword model)
{
if (ModelState.IsValid)
{
var result = await UserManager.RemovePasswordAsync(model.id);
result = await UserManager.AddPasswordAsync(model.id, model.Password);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(model.id);
Historial nuevo = new Historial("Cambió Contraseña", User.Identity.GetUserId(), "usuario", model.id, user.UserName, Request.UserHostAddress);
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
TempData["Mensaje"] = "Se ha cambiado la contraseña correctamente al usuario."+user.UserName;
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Editar", "Acceso", new { id = user.Id });
}
else
{
AddErrors(result);
}
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
TempData["Mensaje"] = "Error al cambiar la contraseña.";
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Editar", "Acceso", new { id =model.id });
}
public async Task<ActionResult> UsuarioZona(List<string> selectZonas, string id)
{
if (ModelState.IsValid)
{
try {
var result = await UsuariosZonas.RemoveAll(id);
//Si se eliminan correctamente
if (result)
{
var listaNueva = await UsuariosZonas.addAll(selectZonas, id);
//Si se agregan correctamente
if (listaNueva)
{
var guardarPoligono = usuario.UsuariosPoligono(id);
Historial nuevo = new Historial("Cambio de Zonas", User.Identity.GetUserId(), "UsuariosZonas", id, User.Identity.GetUserName(), Request.UserHostAddress);
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
TempData["Mensaje"] = "Se ha cambiado las zonas correctamente al usuario.";
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Editar", "Acceso", new { id = id });
}
}
}
catch (Exception ex)
{
}
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
TempData["Mensaje"] = "Error al cambiar ls zonas.";
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Editar", "Acceso", new { id = id });
}
public async Task<ActionResult> Perfil(PerfilUsuario model)
{
if (ModelState.IsValid)
{
if (model.perfil != null && model.perfil.ContentLength > 0)
{
var user = await UserManager.FindByIdAsync(model.id);
Stream inputStream = model.perfil.InputStream;
Image orgImg = Image.FromStream(inputStream);
Rectangle CropArea = new Rectangle(Convert.ToInt32(model.dataX),
Convert.ToInt32(model.dataY),
Convert.ToInt32(model.dataWidth),
Convert.ToInt32(model.dataHeight));
using (Bitmap bitMap = new Bitmap(CropArea.Width, CropArea.Height))
{
using (Graphics g = Graphics.FromImage(bitMap))
{
g.DrawImage(orgImg, new Rectangle(0, 0, bitMap.Width, bitMap.Height), CropArea, GraphicsUnit.Pixel);
}
MemoryStream memoryStream = new MemoryStream();
bitMap.Save(memoryStream, System.Drawing.Imaging.ImageFormat.Jpeg);
user.perfil = memoryStream.ToArray();
}
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
Historial nuevo = new Historial("Modificó Foto de Perfil", User.Identity.GetUserId(), "usuario", user.Id, user.UserName, Request.UserHostAddress);
TempData["Mensaje"] = "Perfil Modificado Correctamente.";
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Editar", "Acceso", new { id = user.Id });
}
else
{
AddErrors(result);
}
}
else
{
TempData["Mensaje"] = "Error al Actualizar el Perfil.";
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Editar", "Acceso", new { id = model.id });
}
}
TempData["Mensaje"] = "Error al Actualizar el Perfil.";
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Editar", "Acceso", new { id = model.id });
}
public async Task<ActionResult> Editar(EditarUsuario model)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByIdAsync(model.id);
user.nombre = model.nombre;
user.apellido1 = model.apellido1;
user.apellido2 = model.apellido2;
user.telefono = model.telefono;
user.email = model.email;
user.UserName = model.UserName;
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
ApplicationDbContext dba = new ApplicationDbContext();
Conexion db = new Conexion();
List<IdentityUserRole> lista_roles_usu = dba.User_Role.Where(m => m.UserId == user.Id).ToList();
dba.User_Role.RemoveRange(lista_roles_usu);
dba.SaveChanges();
List<UsuariosGrupo> grupoUR = db.UsuariosGrupo.Where(m => m.idusuario == user.Id).ToList();
db.UsuariosGrupo.RemoveRange(grupoUR);
db.SaveChanges();
grupoUR.Clear();
try {
foreach (var role in model.rol)
{
UsuariosGrupo inGrupo = new UsuariosGrupo();
inGrupo.idgrupousuario = role;
inGrupo.idusuario = user.Id;
grupoUR.Add(inGrupo);
List<GrupoU_Roles> listaRoles = db.GrupoU_Roles.Where(m=>m.idgrupo== role).ToList();
foreach (var intro in listaRoles)
{
var roless = db.Roles.FirstOrDefault(m=>m.Id == intro.idrol);
var isInRole = await UserManager.IsInRoleAsync(user.Id, roless.Name);
if (!isInRole)
{
await UserManager.AddToRoleAsync(user.Id, roless.Name);
}
}
}
db.UsuariosGrupo.AddRange(grupoUR);
db.SaveChanges();
}
catch (Exception e)
{
}
Historial nuevo = new Historial("Modificó", User.Identity.GetUserId(), "usuario", user.Id, user.UserName, Request.UserHostAddress);
TempData["Mensaje"] = "Datos del Usuario modificados correctamente.";
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Editar", "Acceso", new {id= user.Id });
}
else
{
AddErrors(result);
}
}
//Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario.
return View(model);
}
public async Task<ActionResult> Nuevo(RegisterViewModel model)
{
if (ModelState.IsValid)
{
StringHash cod_secreto = new StringHash();
TextoAleatorio text = new TextoAleatorio();
var user = new ApplicationUser() { UserName = model.UserName,
nombre = model.nombre,
apellido1= model.apellido1,
apellido2 = model.apellido2,
telefono = model.telefono,
email= model.email,
fecha_creado = DateTime.Now,
cod_secreto = cod_secreto.Encrypt(text.Texto(), true, model.UserName)
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//Crea Rol por defecto
var rol = await UserManager.AddToRoleAsync(user.Id,"Lector");
UsuariosGrupo inGrupo = new UsuariosGrupo();
inGrupo.idgrupousuario = "8127f8b1-ff6e-4b21-bdd1-c3c9d1f9e440";
inGrupo.idusuario = user.Id;
Conexion db = new Conexion();
db.UsuariosGrupo.Add(inGrupo);
db.SaveChanges();
Historial nuevo = new Historial("Creó", User.Identity.GetUserId(), "usuario", user.Id, user.UserName, Request.UserHostAddress);
//Para Crearlo y automaticamente longuearlo
//await SignInAsync(user, isPersistent: false);
return RedirectToAction("Editar", "Acceso", new {id=user.Id });
}
else
{
AddErrors(result);
}
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
return View(model);
}
public async Task<ActionResult> Eliminar(string id)
{
var eliminar = db.Usuarios.SingleOrDefault(m => m.id == id);
if (eliminar == null)
{
return HttpNotFound();
}
db.Usuarios.Remove(eliminar);
await db.SaveChangesAsync();
Historial nuevo = new Historial("Eliminó", User.Identity.GetUserId(), "Usuarios", eliminar.id, eliminar.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Usuario eliminado correctamente.";
return RedirectToAction("Index");
}
// POST: Operaciones/Eliminar/5
public async Task<ActionResult> EliminarOperacionPr(string id)
{
OperacionesProgramadas operaciones = await db.OperacionesProgramadas.FindAsync(id);
if (operaciones == null)
{
return HttpNotFound();
}
db.OperacionesProgramadas.Remove(operaciones);
await db.SaveChangesAsync();
Historial nuevo = new Historial("Eliminó", User.Identity.GetUserId(), "OperacionesProgramadas", operaciones.id, operaciones.idoperacion, Request.UserHostAddress);
TempData["Mensaje"] = "Operación Programada eliminada correctamente.";
return RedirectToAction("Programadas");
}
public async Task<ActionResult> Editar([Bind(Include="id,nombre,descripcion,anomalia,grado_anomalia,tiempo_programacion,tiempo_ejecucion,rendimiento,coste_total,color")] Operaciones operaciones)
{
if (ModelState.IsValid)
{
db.Entry(operaciones).State = EntityState.Modified;
await db.SaveChangesAsync();
Historial nuevo = new Historial("Editó", User.Identity.GetUserId(), "Operaciones", operaciones.id, operaciones.nombre, Request.UserHostAddress);
TempData["Mensaje"] = "Operación editada correctamente.";
return RedirectToAction("Editar", "Operaciones", new { id = operaciones.id });
}
TempData["Mensaje"] = "Error al crear la Operación.";
return View(operaciones);
}
public async Task<ActionResult> Index(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindAsync(model.UserName, model.Password);
if (user != null)
{
await SignInAsync(user, model.RememberMe);
Conexion db = new Conexion();
Usuarios usuario = db.Usuarios.First(m=>m.login == user.UserName);
usuario.fecha_ul_acceso = DateTime.Now;
db.SaveChanges();
var cadena = HttpContext;
Historial nuevo = new Historial("Auntenticó", model.UserName, "entrar", Request.UserHostAddress);
return RedirectToLocal(returnUrl);
}
else
{
ModelState.AddModelError("", "Usuario o Contraseña no es correcto.");
}
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
return View(model);
}
