public async Task <IHttpActionResult> _ResetPassword(ResetPassword reset)
{
if (ModelState.IsValid)
{
try
{
Usuario usuario = db.Usuarios
.Include(u => u.UsuarioTokensList)
.Where(u => u.UsuarioId == reset.Usuario)
.FirstOrDefault();
usuario.Usuariopassword = Fn.EncryptText(reset.Password1);
db.UsuarioToken.RemoveRange(usuario.UsuarioTokensList);
db.Entry(usuario).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("Usuarios/_ResetPassword", usuario.UsuarioId, usuario);
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
else
{
// ViewBag.flag = false;
return(Ok(false));
}
return(Ok(true));
}
public async Task <ActionResult> Create(DevolucionViewModel model, IEnumerable <HttpPostedFileBase> Files)
{
//var f = await UploadFiles(0, Files);
if (ModelState.IsValid)
{
//Save Return
model.Devolucion.Estado = EstadoFormatoPQRS.Open;
model.Devolucion.FechaCreacion = DateTime.Now;
db.Devoluciones.Add(model.Devolucion);
await db.SaveChangesAsync();
//Genera HASHNroTracking
string HASHNroTracking = Fn.HASH("D" + model.Devolucion.Id);
HASHNroTracking = "D" + model.Devolucion.Id + HASHNroTracking;
model.Devolucion.NroTracking = HASHNroTracking.Substring(0, 10).ToUpper();
db.Entry(model.Devolucion).State = EntityState.Modified;
await db.SaveChangesAsync();
//Save Items
if (model.Items != null)
{
int i = 1;
foreach (var item in model.Items)
{
item.DevolucionId = model.Devolucion.Id;
item.Id = i++;
db.DevolucionItems.Add(item);
}
await db.SaveChangesAsync();
}
//Save Files
if (Files != null)
{
await UploadFiles(model.Devolucion.Id, Files, 1);
}
//Generar HASH y actualiza Formato
AddLog("", model.Devolucion.Id, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];
ViewBag.UsuarioNombre = seguridadcll.Usuario.UsuarioId + " - " + seguridadcll.Usuario.UsuarioNombre;
ViewBag.UsuarioId = seguridadcll.Usuario.UsuarioId;
ViewBag.MotivoPQRS = await db.MotivosPQRS.Where(m => m.TipoPQRS == TipoPQRS.Devolucion && m.Activo == true).ToListAsync();
return(View(model));
}
public async Task <ActionResult> Edit(PeriodoViewModel model)
{
if (ModelState.IsValid)
{
if (await db.Periodo.AnyAsync(p => p.Id != model.Periodo.Id && model.Periodo.FechaIni <= p.FechaFin && model.Periodo.FechaFin >= p.FechaIni))
{
ModelState.AddModelError("", "Date Range is overlaping with other Period.");
}
if (!ModelState.Values.Any(ms => ms.Errors.Count > 0))
{
db.Entry(model.Periodo).State = EntityState.Modified;
if (model.Revisiones != null)
{
foreach (var revision in model.Revisiones)
{
revision.PeriodoId = model.Periodo.Id;
if (revision.Id == 0)
{
db.PeriodoRevision.Add(revision);
}
else
{
db.Entry(revision).State = EntityState.Modified;
}
}
}
if (model.RevisionesId != null)
{
var revisionesRemove = await db.PeriodoRevision
.Where(pr => model.RevisionesId.Contains(pr.Id))
.ToListAsync();
db.PeriodoRevision.RemoveRange(revisionesRemove);
}
await db.SaveChangesAsync();
AddLog("", model.Periodo.Id, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
}
if (model.Revisiones == null)
{
model.Revisiones = new List <PeriodoRevision>();
}
return(View(model));
}
public async Task <ActionResult> Edit(Recruitment model)
{
if (ModelState.IsValid)
{
//Guardar Cabecera
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", model.RecruitmentId, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
return(await GetView(model.RecruitmentId));
}
public async Task <IHttpActionResult> Edit(Gasto model)
{
var result = new AjaxResult();
try
{
model.GastoValor = Decimal.Parse(model.GastoValor.ToString().Replace(".", ","));
if (ModelState.IsValid)
{
Controllers.Transacciones.GastosController GastosCtrl = new Controllers.Transacciones.GastosController();
if (model.ActividadId != null)
{
//Devuelve el Gasto
if (model.GastoEstado == EstadoGasto.Ejecutado || model.GastoEstado == EstadoGasto.Pagado)
{
GastosCtrl.AfectaPresupuestoXGasto(model.GastoId, 1);
// AfectaPresupuestoXGasto(model.GastoId, 1);
}
}
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
if (model.ActividadId != null)
{
//Afecta el gasto
if (model.GastoEstado == EstadoGasto.Ejecutado || model.GastoEstado == EstadoGasto.Pagado)
{
//AfectaPresupuestoXGasto(model.GastoId, 2);
GastosCtrl.AfectaPresupuestoXGasto(model.GastoId, 2);
}
}
AddLog("", model.GastoId, model);
return(Ok(result.True("Record saved")));
}
else
{
//return InternalServerError(new Exception("Error, All field are required"));
string s = string.Join(" | ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage));
return(Ok(result.False(s)));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public ActionResult Edit(Orden orden, FormCollection form)
{
if (ModelState.IsValid)
{
//Modifica Cabecera de la orden
db.Entry(orden).State = EntityState.Modified;
db.SaveChanges();
//Modifica Items de la orden
bool flagMod = ModificaOrdenItems(orden.OrdenId, form);
if (flagMod)
{
//Afecta cantidad de Productos Inventariables en el Gasto
//Reversa Movimiento de salida por la orden
List <Movimiento> movimientoList = db.Movimiento.Where(m => m.OrdenId == orden.OrdenId).ToList();
MovimientosController movCtrl = new MovimientosController();
movCtrl.RegresaMovimiento(movimientoList);
Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];
// MovimientosController movCtrl = new MovimientosController();
movCtrl.CreaMovimientoXOrden(orden.OrdenId, trnMode.Update, seguridadcll);
#region auditoria
Seguridad.Seguridad seguridad = new Seguridad.Seguridad();
Auditoria auditoria = new Auditoria();
auditoria.AuditoriaFecha = System.DateTime.Now;
auditoria.AuditoriaHora = System.DateTime.Now.TimeOfDay;
auditoria.usuarioId = seguridadcll.Usuario.UsuarioId;
auditoria.AuditoriaEvento = "Edit";
auditoria.AuditoriaDesc = "Se Modifico La Orden: " + orden.OrdenId;
auditoria.ObjetoId = "Ordenes/Edit";
seguridad.insertAuditoria(auditoria);
#endregion auditoria
////Modifica Cantidades del Movimiento
//return RedirectToAction("CreaMovimientoXOrden", "Movimientos", new { OrdenId = orden.OrdenId, mode = trnMode.Update });
//Afecta cantidad de Productos Inventariables en el Gasto
return(RedirectToAction("Index", GetReturnSearch()));
}
}
db.Configuration.ProxyCreationEnabled = false;
ViewBag.OrdenItems = db.OrdenItems.Where(o => o.OrdenId == orden.OrdenId).ToList();
return(View(orden));
}
public async Task <IHttpActionResult> EditItem(ColeccionPIVItem coleccionItem)
{
try
{
db.Entry(coleccionItem).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", coleccionItem.Id.ToString(), coleccionItem);
return(Ok(true));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Complete(int id, int lastVisitaId)
{
try
{
if (lastVisitaId != 0)
{
var lastVisita = await db.Visita.FirstOrDefaultAsync(v => v.Id == lastVisitaId);
if (lastVisita != null)
{
lastVisita.Activa = false;
db.Entry(lastVisita).State = EntityState.Modified;
}
}
var visita = await db.Visita.FindAsync(id);
visita.Completada = true;
await db.SaveChangesAsync();
AddLog("VisitasComplete", visita.Id, new { VisitaIdAnterior = lastVisitaId });
return(Ok(new AjaxResult()
{
Data = visita.Id
}));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <ActionResult> Edit(AplicacionesViewModel model)
{
if (ModelState.IsValid)
{
//Save Aplicación table
db.Entry(model.Aplicacion).State = EntityState.Modified;
await db.SaveChangesAsync();
//Detele Detail (AplicacionObjetos)
if (await DeleteAplicacionObjetos(model.Aplicacion.Id))
{
foreach (var obj in model.Objetos)
{
if (obj.Seleccionado)
{
var ao = new AplicacionObjeto();
ao.AplicacionId = model.Aplicacion.Id;
ao.ObjetoId = obj.ObjetoId;
db.AplicacionObjetos.Add(ao);
}
}
await db.SaveChangesAsync();
AddLog("", model.Aplicacion.Id, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
else
{
ModelState.AddModelError("", "Error Deleting Detail (AplicacionObjetos)");
}
//Save Detail (AplicacionObjetos)
}
return(View(model));
}
public async Task <IHttpActionResult> Edit(PresupuestoVendedor model)
{
try
{
var result = new AjaxResult();
if (ModelState.IsValid)
{
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", model.PlantaID, model);
return(Ok(result.True("Record saved")));
}
else
{
//return InternalServerError(new Exception("Error, All field are required"));
string s = string.Join(" | ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage));
return(Ok(result.False(s)));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <ActionResult> Edit(NivelesAprobacion nivelAprobacion)
{
if (ModelState.IsValid)
{
if (await db.NivelesAprobacion.AnyAsync(na => na.CanalID == nivelAprobacion.CanalID && na.PlantaID == nivelAprobacion.PlantaID && na.Orden == nivelAprobacion.Orden && na.Id != nivelAprobacion.Id))
{
ModelState.AddModelError("", "Ya existe un un nivel de aprobación con la misma (Planta, Canal, Orden)");
}
if (await db.NivelesAprobacion.AnyAsync(na => na.CanalID == nivelAprobacion.CanalID && na.PlantaID == nivelAprobacion.PlantaID && na.UsuarioId == nivelAprobacion.UsuarioId && na.Id != nivelAprobacion.Id))
{
ModelState.AddModelError("", "Ya existe un un nivel de aprobación con la misma (Planta, Canal, Usuario)");
}
if (!ModelState.Values.Any(ms => ms.Errors.Count > 0))
{
db.Entry(nivelAprobacion).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", nivelAprobacion.Id, nivelAprobacion);
return(RedirectToAction("Index", GetReturnSearch()));
}
}
ViewBag.CanalID = new SelectList(db.Canales.OrderBy(c => c.CanalDesc).ToList(), "CanalID", "CanalDesc", nivelAprobacion.CanalID);
ViewBag.PlantaID = new SelectList(db.Plantas.OrderBy(p => p.PlantaDesc).ToList(), "PlantaID", "PlantaDesc", nivelAprobacion.PlantaID);
ViewBag.UsuarioId = new SelectList(new List <Usuario>());
return(View(nivelAprobacion));
}
public int generaConsecutivo(string ConsecutivoId = null)
{
int idx = 0;
try
{
var consecutivo = db.Consecutivo
.Where(c => c.ConsecutivoId.Trim().ToLower() == ConsecutivoId.Trim().ToLower())
.FirstOrDefault();
if (consecutivo == null)
{
Consecutivo nConsecutivo = new Consecutivo();
nConsecutivo.ConsecutivoId = ConsecutivoId;
nConsecutivo.ConsecutivoNro = 1;
db.Consecutivo.Add(nConsecutivo);
db.SaveChanges();
idx = 1;
}
else
{
idx = consecutivo.ConsecutivoNro + 1;
consecutivo.ConsecutivoNro = idx;
db.Entry(consecutivo).State = EntityState.Modified;
db.SaveChanges();
}
}
catch
{
idx = 0;
}
return(idx);
}
public async Task <ActionResult> Edit(VisitasViewModel model, IEnumerable <HttpPostedFileBase> Photos)
{
if (ModelState.IsValid)
{
db.Entry(model.Visita).State = EntityState.Modified;
await db.SaveChangesAsync();
#region VisitaFotos
var currentPhotos = await db.VisitaFoto
.Where(vf => vf.VisitaId == model.Visita.Id)
.ToListAsync();
if (model.VisitaFotos != null)
{
var PhotosId = model.VisitaFotos.Select(a => a.Order).ToArray();
var photosToDelete = currentPhotos.Where(a => !PhotosId.Contains(a.Order)).ToList();
if (photosToDelete.Count > 0)
{
db.VisitaFoto.RemoveRange(photosToDelete);
await db.SaveChangesAsync();
}
}
else
{
var photosToDelete = currentPhotos.ToList();
if (photosToDelete.Count > 0)
{
db.VisitaFoto.RemoveRange(photosToDelete);
await db.SaveChangesAsync();
}
}
int order = 0;
if (currentPhotos.Count > 0)
{
order = currentPhotos.Select(i => i.Order).Max() + 1;
}
if (Photos != null)
{
await UploadPhotos(model.Visita.Id, Photos, order);
}
#endregion
AddLog("", model.Visita.Id, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
return(await GetView(model.Visita.Id));
}
public async Task <IHttpActionResult> CambiarFoto([FromBody] string profilePictureBase64)
{
try
{
var usuarioHV = await db.UsuarioHV.FirstOrDefaultAsync(u => u.UsuarioId == Seguridadcll.Usuario.UsuarioId);
string[] profilePicture = profilePictureBase64.Split(',');
using (var ms = new MemoryStream(Convert.FromBase64String(profilePicture[1])))
{
var bitmap = Fn.ResizeBitmap(new System.Drawing.Bitmap(ms), 200, 200);
if (usuarioHV == null)
{
usuarioHV = new UsuarioHV
{
UsuarioId = Seguridadcll.Usuario.UsuarioId,
FotoMediaType = profilePicture[0].Replace("data:", "").Replace(";base64", ""),
Foto = Fn.BitmapToByte(bitmap),
};
db.UsuarioHV.Add(usuarioHV);
}
else
{
usuarioHV.FotoMediaType = profilePicture[0].Replace("data:", "").Replace(";base64", "");
usuarioHV.Foto = Fn.BitmapToByte(bitmap);
db.Entry(usuarioHV).State = EntityState.Modified;
}
}
await db.SaveChangesAsync();
AddLog("", usuarioHV.UsuarioId, null);
return(Ok(true));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <ActionResult> Edit(CoreValue coreValue)
{
if (ModelState.IsValid)
{
db.Entry(coreValue).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", coreValue.Id, coreValue);
return(RedirectToAction("Index", GetReturnSearch()));
}
return(View(coreValue));
}
public async Task <ActionResult> Edit(Departamento model)
{
if (ModelState.IsValid)
{
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", model.DepartamentoID, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
return(View(model));
}
public override void OnAuthorization(HttpActionContext actionContext)
{
if (actionContext.ActionDescriptor.GetCustomAttributes <AllowAnonymousAttribute>().Any())
{
return;
}
if (actionContext.Request.Headers.Authorization == null)
{
HandleUnauthorizedRequest(actionContext);
return;
}
string scheme = actionContext.Request.Headers.Authorization.Scheme;
string token = actionContext.Request.Headers.Authorization.Parameter;
if (string.IsNullOrWhiteSpace(scheme) || string.IsNullOrWhiteSpace(token) || scheme != "Bearer")
{
HandleUnauthorizedRequest(actionContext);
return;
}
using (var db = new MMSContext())
{
var data = db.UsuarioToken
.Include(ut => ut.Usuario)
.Include(ut => ut.Usuario.RolUsuarioList)
.Where(ut => ut.Usuario.Usuarioactivo && ut.Token == token)
.Select(ut => new
{
Usuario = ut.Usuario,
UsuarioToken = ut,
RolesId = ut.Usuario.RolUsuarioList.Select(ru => ru.RolId).ToList()
})
.FirstOrDefault();
if (data == null || !db.RolObjeto.Where(ro => data.RolesId.Contains(ro.RolId) && ro.ObjetoId == "PerfectStore").Any())
{
HandleUnauthorizedRequest(actionContext);
return;
}
data.UsuarioToken.FechaUltimoUso = DateTime.Now;
db.Entry(data.UsuarioToken).State = EntityState.Modified;
db.SaveChanges();
HttpContext.Current.Items["__usuario"] = data.Usuario;
}
}
public async Task <ActionResult> Edit(Ciudad model)
{
if (ModelState.IsValid)
{
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", model.CiudadID, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
ViewData["DepartamentoID"] = new SelectList(await db.Departamento.Select(d => new { d.DepartamentoID, d.DepartamentoDesc }).ToListAsync(), "DepartamentoID", "DepartamentoDesc");
ViewData["PaisID"] = new SelectList(await db.Pais.Select(p => new { p.PaisID, p.PaisDesc }).ToListAsync(), "PaisID", "PaisDesc");
return(View(model));
}
public async Task <ActionResult> Create(ColeccionPIVViewModel model)
{
if (ModelState.IsValid)
{
if (model.ClientesId != null)
{
var clientes = await db.Clientes.Where(c => model.ClientesId.Contains(c.ClienteID)).ToListAsync();
foreach (var cliente in clientes)
{
cliente.ColeccionPIVId = model.ColeccionPIV.Id;
db.Entry(cliente).State = EntityState.Modified;
}
}
db.ColeccionPIV.Add(model.ColeccionPIV);
await db.SaveChangesAsync();
AddLog("", model.ColeccionPIV.Id, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
return(View(model));
}
public async Task <ActionResult> Edit(ObjetosViewModel model)
{
if (ModelState.IsValid)
{
try
{
if (!model.Objeto.ObjetoMenu)
{
model.Objeto.ObjetoIcono = null;
model.Objeto.ObjetoIdPadre = null;
model.Objeto.ObjetoOrden = null;
}
db.Entry(model.Objeto).State = EntityState.Modified;
await db.SaveChangesAsync();
if (await DeleteAplicacionObjetos(model.Objeto.ObjetoId))
{
if (model.Objeto.ObjetoMenu)
{
foreach (var app in model.Apps)
{
if (app.Seleccionado)
{
AplicacionObjeto ao = new AplicacionObjeto();
ao.AplicacionId = app.AplicacionId;
ao.ObjetoId = model.Objeto.ObjetoId;
db.AplicacionObjetos.Add(ao);
}
}
await db.SaveChangesAsync();
}//if (model.Objeto.ObjetoMenu)
AddLog("", model.Objeto.ObjetoId, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
else
{
ModelState.AddModelError("", "Error Deleting Detail (AplicacionObjetos)");
}
}
catch (Exception e)
{
ViewBag.error = e.ToString();
}
}
ViewBag.Objeto_ObjetoIdPadre = new SelectList(await db.Objeto.Where(o => o.ObjetoId.StartsWith("__") && o.ObjetoMenu).ToListAsync(), "ObjetoId", "ObjetoDesc", model.Objeto.ObjetoIdPadre);
return(await GetView(model.Objeto.ObjetoId));
}
public async Task <IHttpActionResult> Edit(Marca marca)
{
try
{
db.Entry(marca).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", marca.Id, marca);
return(Ok(true));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Edit(Canal canal)
{
try
{
db.Entry(canal).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", canal.CanalID, canal);
return(Ok(true));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Edit(Producto producto)
{
try
{
db.Entry(producto).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", producto.CodigoAutoLog, producto);
return(Ok(true));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> ActualizarFechaActualizacion()
{
try
{
var conf = await db.Configuracion.FirstOrDefaultAsync();
conf.ConfigFechaActualizacionDatosBase = DateTime.Now;
db.Entry(conf).State = EntityState.Modified;
await db.SaveChangesAsync();
return(Ok(new AjaxResult()));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> EditStep(FlujoPQRS model)
{
try
{
if (ModelState.IsValid)
{
model.EnviaCorreoDestinatarios = model.EnviaCorreoDestinatarios ?? false;
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", model.Id, model);
}
return(Ok(model));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Edit(TipoMovimiento tipoMovimiento)
{
try
{
var result = new AjaxResult();
db.Entry(tipoMovimiento).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", tipoMovimiento.TipoMovimientoID, tipoMovimiento);
return(Ok(result.True()));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <ActionResult> Edit(PlantillaViewModel model)
{
if (ModelState.IsValid)
{
if (model.PlantillaItems == null)
{
model.PlantillaItems = new List <PlantillaItem>();
}
foreach (var pi in model.PlantillaItems)
{
pi.PlantillaId = model.Plantilla.Id;
}
var currentItems = await db.PlantillaItem
.Where(pi => pi.PlantillaId == model.Plantilla.Id)
.ToListAsync();
var currentItemsId = currentItems.Select(pi => pi.ItemId).ToArray();
var itemsId = model.PlantillaItems.Select(pi => pi.ItemId).ToArray();
var itemsToAdd = model.PlantillaItems.Where(pi => !currentItemsId.Contains(pi.ItemId)).ToList();
var itemsToDelete = currentItems.Where(pi => !itemsId.Contains(pi.ItemId)).ToList();
if (itemsToDelete.Count > 0)
{
db.PlantillaItem.RemoveRange(itemsToDelete);
}
if (itemsToAdd.Count > 0)
{
db.PlantillaItem.AddRange(itemsToAdd);
}
db.Entry(model.Plantilla).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", model.Plantilla.Id, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
return(View(model));
}
public async Task <ActionResult> Edit(Cliente model)
{
if (ModelState.IsValid)
{
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", model.ClienteID, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
ViewData["ColeccionPIVId"] = new SelectList(await db.ColeccionPIV.Select(c => new { c.Id, c.Nombre }).ToListAsync(), "Id", "Nombre");
ViewData["VendedorId"] = new SelectList(await db.Usuarios.Select(u => new { u.UsuarioId, u.UsuarioNombre }).ToListAsync(), "UsuarioId", "UsuarioNombre");
ViewData["CanalID"] = new SelectList(await db.Canales.Select(c => new { c.CanalID, c.CanalDesc }).ToListAsync(), "CanalID", "CanalDesc");
ViewData["CiudadID"] = new SelectList(await db.Ciudad.Where(c => c.DepartamentoID == model.DepartamentoID).Select(c => new { c.CiudadID, c.CiudadDesc }).ToListAsync(), "CiudadID", "CiudadDesc");
ViewData["DepartamentoID"] = new SelectList(await db.Departamento.Where(d => d.PaisID == model.PaisID).Select(d => new { d.DepartamentoID, d.DepartamentoDesc }).ToListAsync(), "DepartamentoID", "DepartamentoDesc");
ViewData["PaisID"] = new SelectList(await db.Pais.Select(p => new { p.PaisID, p.PaisDesc }).ToListAsync(), "PaisID", "PaisDesc");
return(View(model));
}
public async Task <IHttpActionResult> Eventos(List <Evento> eventos)
{
try
{
foreach (var evento in eventos)
{
db.Entry(evento).State = EntityState.Modified;
}
await db.SaveChangesAsync();
AddLog("", "", new { EventosActivos = eventos.Where(e => e.Activo).Select(e => new { e.Id, e.Nombre, e.Descripcion }) });
return(Ok(true));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <ActionResult> Edit(MotivoPQRS model)
{
if (ModelState.IsValid)
{
if (model.TipoPQRS != 0)
{
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", model.Id, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
else
{
ModelState.AddModelError("", "Error, Please select type PQRS");
}
}
return(View(model));
}
