示例#1
0
        // Para enviar la lista resultante al AJAX
        public JsonResult obtenerObjetosConMenu()
        {
            var result = new[] { new { objeto = "" } }.ToList();

            try
            {
                Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];
                if (seguridadcll != null)
                {
                    result = null;
                    var resultTemp = (from r in seguridadcll.ObjetosMenuList
                                      select new
                    {
                        objeto = r.ObjetoId,
                    }).ToList();
                    result = resultTemp;
                }
                else
                {
                    result = new[] { new { objeto = "Sin_Objetos" } }.ToList();;
                }
            }
            catch (Exception e)
            {
                ViewBag.error = e.ToString();
            }
            return(Json(result, JsonRequestBehavior.AllowGet));
        }
示例#2
0
        public ActionResult _Productos(bool ValidaInventario = false)
        {
            Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];
            var          Config       = seguridadcll.Configuracion;

            string ConfigTipoMovEntrada   = Config.ConfigTipoMovEntrada;
            string ConfigTipoMovAjEntrada = Config.ConfigTipoMovAjEntrada;

            List <Producto> productoList = new List <Producto>();

            if (ValidaInventario == false)
            {
                productoList = db.Producto.ToList();
            }
            else if (ValidaInventario == true)
            {
                //db.Producto.Where(p => p.TipoProductoID == Config.ConfigTipoProdGasto).ToList();
                //productoList = (from p in db.Producto
                //               join m in db.Movimiento on p.ProductoId equals m.ProductoId
                //               where (m.TipoMovimientoID == ConfigTipoMovEntrada || m.TipoMovimientoID == ConfigTipoMovAjEntrada) && m.MovimientoDisponible > 0
                //               select p).Distinct().ToList();
                string ConfigTipoProdGasto = Config.ConfigTipoProdGasto;
                var    productosUnion      = (from p in db.Producto
                                              join m in db.Movimiento on p.ProductoId equals m.ProductoId
                                              where (m.TipoMovimientoID == ConfigTipoMovEntrada || m.TipoMovimientoID == ConfigTipoMovAjEntrada) && m.MovimientoDisponible > 0
                                              select p).Distinct().Union((from p in db.Producto
                                                                          where p.TipoProductoID == ConfigTipoProdGasto
                                                                          select p));
                productoList = productosUnion.ToList();
            }

            return(PartialView(productoList));
        }
        public ActionResult ReporteDetalleActividades(ReporteActividades model, int?ActividadId = null, string ActividadTitulo = "", string PlantaID = "", string PlantaDesc = "")
        {
            Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];
            var          actividades  = new List <Actividad>();
            //Para conocer los campos vacíos.
            bool esVacioId         = String.IsNullOrEmpty(ActividadId.ToString());
            bool esVacioTitulo     = String.IsNullOrEmpty(ActividadTitulo);
            bool esVacioIdPlanta   = String.IsNullOrEmpty(PlantaID);
            bool esVacioDescPlanta = String.IsNullOrEmpty(PlantaDesc);

            if (!esVacioId || !esVacioTitulo || !esVacioIdPlanta || !esVacioDescPlanta)
            {
                actividades = db.Actividad.Include(a => a.cliente).ToList()
                              .Where(a =>
                                     ((esVacioId) ? true : a.ActividadId.ToString().Contains(ActividadId.ToString())) &&
                                     ((esVacioTitulo) ? true : a.ActividadTitulo.ToLower().Contains(ActividadTitulo.ToLower())) &&
                                     ((esVacioIdPlanta) ? true : a.ClienteID.ToLower().Contains(PlantaID.ToLower())) &&
                                     ((esVacioDescPlanta) ? true : a.cliente.ClienteRazonSocial.ToLower().Contains(PlantaDesc.ToLower()))
                                     )
                              .OrderByDescending(a => a.ActividadId)
                              .ToList();
                ViewBag.TableActividades = actividades;
            }
            else
            {
                ViewBag.TableActividades = actividades;
            }
            return(View(model));
        }
示例#4
0
        public async Task <ActionResult> Create(Recruitment model)
        {
            if (ModelState.IsValid)
            {
                model.Estado       = EstadoFormatoPQRS.Open;
                model.CreationDate = DateTime.Now;

                db.Recruitments.Add(model);
                await db.SaveChangesAsync();

                AddLog("", model.RecruitmentId, model);
                return(RedirectToAction("Index", GetReturnSearch()));
            }

            ViewBag.UsuarioIdSubstitute  = new SelectList(db.Usuarios, "UsuarioId", "UsuarioNombre", model.UsuarioIdSubstitute);
            ViewBag.AreaManagerID        = new SelectList(db.Usuarios, "UsuarioId", "UsuarioNombre", model.AreaManagerID);
            ViewBag.HumanResourcesID     = new SelectList(db.Usuarios, "UsuarioId", "UsuarioNombre", model.HumanResourcesID);
            ViewBag.ImmediateBossID      = new SelectList(db.Usuarios, "UsuarioId", "UsuarioNombre", model.ImmediateBossID);
            ViewBag.CentroCostoID        = new SelectList(db.CentroCostos, "CentroCostoID", "CentroCostoDesc", model.CentroCostoID);
            ViewBag.ProposedCostCenterID = new SelectList(db.CentroCostos, "CentroCostoID", "CentroCostoDesc", model.ProposedCostCenterID);
            ViewBag.DepartmentId         = new SelectList(db.Area, "Id", "Nombre", model.DepartmentId);
            ViewBag.ProposedDepartmentId = new SelectList(db.Area, "Id", "Nombre", model.ProposedDepartmentId);

            var sectors = from Sectors d in Enum.GetValues(typeof(Sectors))
                          select new { ID = (int)d, Name = d.ToString() };

            var positions = from Positions d in Enum.GetValues(typeof(Positions))
                            select new { ID = (int)d, Name = d.ToString() };

            var contractTypes = from ContractTypes d in Enum.GetValues(typeof(ContractTypes))
                                select new { ID = (int)d, Name = d.ToString() };

            var budgets = from Budgets d in Enum.GetValues(typeof(Budgets))
                          select new { ID = (int)d, Name = d.ToString() };

            var resignationReasons = from ResignationReasons d in Enum.GetValues(typeof(ResignationReasons))
                                     select new { ID = (int)d, Name = d.ToString() };

            var previousNotices = from PreviousNotices d in Enum.GetValues(typeof(PreviousNotices))
                                  select new { ID = (int)d, Name = d.ToString() };

            var experienceTimes = from ExperienceTimes d in Enum.GetValues(typeof(ExperienceTimes))
                                  select new { ID = (int)d, Name = d.ToString() };

            ViewBag.Sector            = new SelectList(sectors, "ID", "Name", model.Sector);
            ViewBag.Position          = new SelectList(positions, "ID", "Name", model.Position);
            ViewBag.ContractType      = new SelectList(contractTypes, "ID", "Name", model.ContractType);
            ViewBag.Budget            = new SelectList(budgets, "ID", "Name", model.Budget);
            ViewBag.ResignationReason = new SelectList(resignationReasons, "ID", "Name", model.ResignationReason);
            ViewBag.PreviousNotice    = new SelectList(previousNotices, "ID", "Name", model.PreviousNotice);
            ViewBag.ExperienceTime    = new SelectList(experienceTimes, "ID", "Name", model.ExperienceTime);

            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.Recruitment && m.Activo == true).ToListAsync();

            return(View(model));
        }
示例#5
0
        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));
        }
示例#6
0
        public ActionResult Create()
        {
            Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];

            ViewBag.UsuarioNombre = seguridadcll.Usuario.UsuarioId + " - " + seguridadcll.Usuario.UsuarioNombre;
            ViewBag.UsuarioId     = seguridadcll.Usuario.UsuarioId;
            ViewBag.MotivoPQRS    = db.MotivosPQRS.Where(m => m.TipoPQRS == TipoPQRS.Novedad && m.Activo == true).ToList();
            ViewBag.CausaPQRS     = db.CausaPQRS.Where(m => m.TipoPQRS == TipoPQRS.Novedad).ToList();
            return(View());
        }
示例#7
0
        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));
        }
示例#8
0
        public ActionResult DeleteConfirmed(int id)
        {
            //Reversar Movimientos
            List <Movimiento>     movimientoList = db.Movimiento.Where(m => m.OrdenId == id).ToList();
            MovimientosController movCtrl        = new MovimientosController();

            movCtrl.RegresaMovimiento(movimientoList);

            //Poner eliminado cada Movimiento
            foreach (var mov in movimientoList)
            {
                mov.MovimientoEstado = EstadoMovimiento.Eliminado;
                db.Entry(mov).State  = EntityState.Modified;
                db.SaveChanges();
            }



            //Cambiar estado de la orden a eliminado
            Orden orden = db.Orden.Find(id);

            orden.OrdenEstado = EstadoOrden.Eliminado;
            db.SaveChanges();


            //Actualiza Estado del Gasto
            var GastoList = db.Gasto.Where(g => g.ActividadId == orden.ActividadId).ToList();

            foreach (var gasto in GastoList)
            {
                gasto.GastoEstado     = EstadoGasto.Eliminado;
                db.Entry(gasto).State = EntityState.Modified;
                db.SaveChanges();
            }

            #region auditoria
            Seguridad.Seguridad seguridad    = new Seguridad.Seguridad();
            Auditoria           auditoria    = new Auditoria();
            Seguridadcll        seguridadcll = (Seguridadcll)Session["seguridad"];

            auditoria.AuditoriaFecha  = System.DateTime.Now;
            auditoria.AuditoriaHora   = System.DateTime.Now.TimeOfDay;
            auditoria.usuarioId       = seguridadcll.Usuario.UsuarioId;
            auditoria.AuditoriaEvento = "Delete";
            auditoria.AuditoriaDesc   = "Se cambio a estado eliminado la Orden: " + id;
            auditoria.ObjetoId        = "Ordenes/Delete";

            seguridad.insertAuditoria(auditoria);
            #endregion auditoria

            return(RedirectToAction("Index"));
        }
示例#9
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="ProductoId"></param>
        /// <returns></returns>
        ///
        public JsonResult infoProducto(string ProductoId = null, bool ValidaInventario = false)
        {
            db.Configuration.ProxyCreationEnabled = false;
            Producto producto;

            try
            {
                if (ValidaInventario == false)
                {
                    producto = db.Producto
                               .Where(p => p.ProductoId == ProductoId)
                               .FirstOrDefault();
                }
                else
                {
                    Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];
                    var          Config       = seguridadcll.Configuracion;


                    string ConfigTipoMovEntrada   = Config.ConfigTipoMovEntrada;
                    string ConfigTipoMovAjEntrada = Config.ConfigTipoMovAjEntrada;

                    //producto = (from p in db.Producto
                    //            join m in db.Movimiento on p.ProductoId equals m.ProductoId
                    //            where (m.TipoMovimientoID == ConfigTipoMovEntrada || m.TipoMovimientoID == ConfigTipoMovAjEntrada) && m.MovimientoDisponible > 0 && p.ProductoId == ProductoId
                    //            select p).FirstOrDefault();

                    string ConfigTipoProdGasto = Config.ConfigTipoProdGasto;
                    var    productosUnion      = (from p in db.Producto
                                                  join m in db.Movimiento on p.ProductoId equals m.ProductoId
                                                  where (m.TipoMovimientoID == ConfigTipoMovEntrada || m.TipoMovimientoID == ConfigTipoMovAjEntrada) && m.MovimientoDisponible > 0 && p.ProductoId == ProductoId
                                                  select p).Distinct().Union((from p in db.Producto
                                                                              where p.TipoProductoID == ConfigTipoProdGasto && p.ProductoId == ProductoId
                                                                              select p));
                    producto = productosUnion.FirstOrDefault();
                }
                if (producto == null)
                {
                    producto = new Producto();
                }
            }
            catch
            {
                producto = new Producto();
            }
            return(this.Json(producto, JsonRequestBehavior.AllowGet));
        }
示例#10
0
        public async Task <IHttpActionResult> RolAplicaciones(RolAplicacionViewModel model)
        {
            try
            {
                if (await DeleteRolAplicaciones(model.rol.RolId))
                {
                    foreach (var apps in model.aplicaciones)
                    {
                        if (apps.Seleccionado)
                        {
                            db.RolAplicaciones.Add(new RolAplicacion {
                                RolId = model.rol.RolId, AplicacionId = apps.Id
                            });
                        }
                    }
                }

                await db.SaveChangesAsync();


                //Inserta Auditoria
                Controllers.Seguridad.Seguridad seguridad = new Controllers.Seguridad.Seguridad();
                Auditoria    auditoria    = new Auditoria();
                Seguridadcll seguridadcll = (Seguridadcll)HttpContext.Current.Session["seguridad"];

                auditoria.AuditoriaFecha  = System.DateTime.Now;
                auditoria.AuditoriaHora   = System.DateTime.Now.TimeOfDay;
                auditoria.usuarioId       = seguridadcll.Usuario.UsuarioId;
                auditoria.AuditoriaEvento = "Add_Apps";
                auditoria.AuditoriaDesc   = "Add_Apps : " + model.rol.RolId;
                auditoria.ObjetoId        = "Roles/RolAplicaciones";

                seguridad.insertAuditoria(auditoria);
                //Inserta Auditoria

                return(Ok(true));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
示例#11
0
        /*Metodo que refresca la seguridad Session[seguridad]*/

        public JsonResult actualizaSeguridad()
        {
            try
            {
                Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];
                if (seguridadcll != null)
                {
                    CargueSeguridad(seguridadcll.Usuario);
                }
                else
                {
                    return(Json(false, JsonRequestBehavior.AllowGet));
                }
            }
            catch
            {
                return(Json(false, JsonRequestBehavior.AllowGet));
            }
            return(Json(true, JsonRequestBehavior.AllowGet));
        }
示例#12
0
        public ActionResult _Clientes()
        {
            List <Cliente> clientes = new List <Cliente>();

            try
            {
                Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];

                //para poder incluir la ciudad
                clientes = (from cs in seguridadcll.ClienteList
                            join cl in db.Clientes.Include(c => c.ciudad)
                            on cs.ClienteID equals cl.ClienteID
                            select cl).ToList();
            }
            catch
            {
                clientes = new List <Cliente>();
            }

            return(PartialView(clientes));
        }
示例#13
0
        private async Task <ActionResult> GetView(int id)
        {
            Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];

            ViewBag.UsuarioNombre = seguridadcll.Usuario.UsuarioId + " - " + seguridadcll.Usuario.UsuarioNombre;
            ViewBag.UsuarioId     = seguridadcll.Usuario.UsuarioId;

            var recruitment = await db.Recruitments
                              .FindAsync(id);

            if (recruitment == null)
            {
                return(HttpNotFound());
            }

            ViewBag.UsuarioIdSubstitute  = new SelectList(await db.Usuarios.ToListAsync(), "UsuarioId", "UsuarioNombre", recruitment.UsuarioIdSubstitute);
            ViewBag.AreaManagerID        = new SelectList(await db.Usuarios.ToListAsync(), "UsuarioId", "UsuarioNombre", recruitment.AreaManagerID);
            ViewBag.HumanResourcesID     = new SelectList(await db.Usuarios.ToListAsync(), "UsuarioId", "UsuarioNombre", recruitment.HumanResourcesID);
            ViewBag.ImmediateBossID      = new SelectList(await db.Usuarios.ToListAsync(), "UsuarioId", "UsuarioNombre", recruitment.ImmediateBossID);
            ViewBag.CentroCostoID        = new SelectList(await db.CentroCostos.ToListAsync(), "CentroCostoID", "CentroCostoDesc", recruitment.CentroCostoID);
            ViewBag.ProposedCostCenterID = new SelectList(await db.CentroCostos.ToListAsync(), "CentroCostoID", "CentroCostoDesc", recruitment.ProposedCostCenterID);
            ViewBag.DepartmentId         = new SelectList(await db.Area.ToListAsync(), "Id", "Nombre", recruitment.DepartmentId);
            ViewBag.ProposedDepartmentId = new SelectList(await db.Area.ToListAsync(), "Id", "Nombre", recruitment.ProposedDepartmentId);

            ViewBag.Sector            = new SelectList(Fn.EnumToIEnumarable <Sectors>().ToList(), "Value", "Name", recruitment.Sector);
            ViewBag.Position          = new SelectList(Fn.EnumToIEnumarable <Positions>().ToList(), "Value", "Name", recruitment.Position);
            ViewBag.ContractType      = new SelectList(Fn.EnumToIEnumarable <ContractTypes>().ToList(), "Value", "Name", recruitment.ContractType);
            ViewBag.Budget            = new SelectList(Fn.EnumToIEnumarable <Budgets>().ToList(), "Value", "Name", recruitment.Budget);
            ViewBag.ResignationReason = new SelectList(Fn.EnumToIEnumarable <ResignationReasons>().ToList(), "Value", "Name", recruitment.ResignationReason);
            ViewBag.PreviousNotice    = new SelectList(Fn.EnumToIEnumarable <PreviousNotices>().ToList(), "Value", "Name", recruitment.PreviousNotice);
            ViewBag.ExperienceTime    = new SelectList(Fn.EnumToIEnumarable <ExperienceTimes>().ToList(), "Value", "Name", recruitment.ExperienceTime);
            ViewBag.Type = new SelectList(Fn.EnumToIEnumarable <Types>().ToList(), "Value", "Name", recruitment.Type);

            ViewBag.MotivoPQRS = await db.MotivosPQRS.Where(m => m.TipoPQRS == TipoPQRS.Recruitment && m.Activo == true).ToListAsync();

            ViewBag.CausaPQRS = await db.CausaPQRS.Where(m => m.TipoPQRS == TipoPQRS.Recruitment).ToListAsync();

            return(View(GetCrudMode().ToString(), recruitment));
        }
示例#14
0
文件: Seguridad.cs 项目: jump720/MMS
        /*función o metodo que valida los permisos de un rol con los objetos (esto se valida con los datos de la session[Seguridad])*/
        public bool validaSeguridad(Seguridadcll seguridadcll = null, string ObjetoId = "")
        {
            bool Result = false;
            //List<RolUsuario> RolUsuarioList = seguridadcll.RolUsuarioList;
            List <RolObjeto> RolObjetoList = seguridadcll.RolObjetoList;


            var RolObjeto = RolObjetoList
                            .Where(o => o.ObjetoId.ToLower().Trim() == ObjetoId.ToLower().Trim()).FirstOrDefault();

            //Result = (RolObjeto != null) ? true : Result;

            if (RolObjeto != null)//Si tiene permiso
            {
                Result = true;
            }
            else//No tiene permiso
            {
                Result = false;
                /*Crear el objeto si no existe en la BD*/
                var objeto = db.Objeto
                             .Where(o => o.ObjetoId.ToLower().Trim() == ObjetoId.ToLower().Trim())
                             .FirstOrDefault();
                if (objeto == null)
                {
                    Objeto o = new Objeto();
                    o.ObjetoId   = ObjetoId;
                    o.ObjetoDesc = ObjetoId;
                    o.ObjetoMenu = false;

                    db.Objeto.Add(o);
                    db.SaveChanges();
                }
                /*Crear el objeto si no existe en la BD*/
            }


            return(Result);
        }
示例#15
0
        public override void OnAuthorization(HttpActionContext actionContext)
        {
            if (actionContext.ActionDescriptor.GetCustomAttributes <AllowAnonymousAttribute>().Any())
            {
                return;
            }

            if (string.IsNullOrWhiteSpace(objetoId))
            {
                objetoId = (actionContext.ActionDescriptor.ControllerDescriptor.ControllerName + "/" + actionContext.ActionDescriptor.ActionName).ToLower();
            }

            Seguridadcll seguridadcll = (Seguridadcll)HttpContext.Current.Session["seguridad"];

            var objetos = seguridadcll.RolObjetoList.Select(ro => ro.ObjetoId.Trim().ToLower()).Distinct().ToList();

            if (objetos.Any(o => o == objetoId))
            {
                return;
            }

            HandleUnauthorizedRequest(actionContext);
        }
示例#16
0
        public override void OnAuthorization(HttpActionContext actionContext)
        {
            if (actionContext.ActionDescriptor.GetCustomAttributes <AllowAnonymousAttribute>().Any())
            {
                return;
            }

            if (actionContext.RequestContext.Principal.Identity.IsAuthenticated)
            {
                Seguridadcll seguridadcll = (Seguridadcll)HttpContext.Current.Session["seguridad"];

                if (seguridadcll == null)
                {
                    using (var db = new MMSContext())
                    {
                        var usuario = db.Usuarios.FirstOrDefault(u => u.UsuarioId == actionContext.RequestContext.Principal.Identity.Name && u.Usuarioactivo);
                        new Controllers.Seguridad.UsuariosController().CargueSeguridad(usuario, HttpContext.Current);
                    }
                }
            }

            base.OnAuthorization(actionContext);
        }
示例#17
0
        public ActionResult DeleteConfirmed(string[] ids)
        {
            try
            {
                TipoGasto tipoGasto = db.TipoGastos.Find(ids);
                db.TipoGastos.Remove(tipoGasto);
                db.SaveChanges();

                //Auditoria
                Seguridad.Seguridad seguridad    = new Seguridad.Seguridad();
                Auditoria           auditoria    = new Auditoria();
                Seguridadcll        seguridadcll = (Seguridadcll)Session["seguridad"];

                auditoria.AuditoriaFecha  = System.DateTime.Now;
                auditoria.AuditoriaHora   = System.DateTime.Now.TimeOfDay;
                auditoria.usuarioId       = seguridadcll.Usuario.UsuarioId;
                auditoria.AuditoriaEvento = "Eliminar";
                auditoria.AuditoriaDesc   = "Eliminó TipoGasto: " + tipoGasto.TipoGastoID;
                auditoria.ObjetoId        = RouteData.Values["controller"].ToString() + "/" + RouteData.Values["action"].ToString();

                seguridad.insertAuditoria(auditoria);
                //Auditoria
            }
            catch (Exception e)
            {
                var tipoGastos = db.TipoGastos.Find(ids);
                if (tipoGastos == null)
                {
                    ViewBag.Error = "Advertencia, Registro no encontrado o Invalido " + ids;
                }
                else
                {
                    ViewBag.Error = e.ToString();
                }
            }
            return(RedirectToAction("Index"));
        }
示例#18
0
        public SysDataTablePager Get(FormDataCollection form)
        {
            //NameValueCollection nvc = HttpUtility.ParseQueryString(Request.RequestUri.Query);
            string sEcho          = form["draw"].ToString();                    //pagina
            int    iDisplayStart  = Convert.ToInt32(form["Start"]);             //numero de objeto a esconder
            int    iDisplayLength = Convert.ToInt32(form["Length"]);            //tamaño de la grilla
            string sSearch        = form["search[value]"].ToString().ToLower(); //filtro smart (global)

            dynamic ActividadesList;
            var     Count = 0;

            if (HttpContext.Current.Session != null)
            {
                Seguridadcll seguridadcll = (Seguridadcll)HttpContext.Current.Session["seguridad"];
                var          clienteList  = seguridadcll.ClienteList.Select(c => c.ClienteID).ToArray();
                try
                {
                    if (!string.IsNullOrEmpty(sSearch))
                    {
                        ActividadesList = (from a in db.Actividad
                                           join u in db.Usuarios on a.UsuarioIdElabora equals u.UsuarioId
                                           join c in db.Clientes on a.ClienteID equals c.ClienteID
                                           select new { a.ActividadId, a.ActividadFecha, a.ActividadEstado, a.ActividadTitulo, c.ClienteID, a.cliente.ClienteRazonSocial, a.UsuarioIdElabora, u.UsuarioNombre })
                                          .ToList()
                                          .Where(a => clienteList.Contains(a.ClienteID) == true && a.ActividadId.ToString().Contains(sSearch) ||
                                                 (a.ActividadFecha != null && a.ActividadFecha.ToString("d").ToLower().Contains(sSearch)) ||
                                                 (!string.IsNullOrEmpty(a.ActividadEstado.ToString()) && a.ActividadEstado.ToString().ToLower().Contains(sSearch)) ||
                                                 (!string.IsNullOrEmpty(a.ActividadTitulo) && a.ActividadTitulo.ToLower().Contains(sSearch)) ||
                                                 (!string.IsNullOrEmpty(a.ClienteRazonSocial) && a.ClienteRazonSocial.ToLower().Contains(sSearch)) ||
                                                 (!string.IsNullOrEmpty(a.UsuarioIdElabora) && a.UsuarioIdElabora.ToLower().Contains(sSearch)))
                                          .OrderByDescending(a => a.ActividadId)
                                          .Skip(iDisplayStart).Take(iDisplayLength).ToList();
                        Count = ((from a in db.Actividad
                                  join u in db.Usuarios on a.UsuarioIdElabora equals u.UsuarioId
                                  join c in db.Clientes on a.ClienteID equals c.ClienteID
                                  select new { a.ActividadId, a.ActividadFecha, a.ActividadEstado, a.ActividadTitulo, c.ClienteID, a.cliente.ClienteRazonSocial, a.UsuarioIdElabora })
                                 .ToList()
                                 .Where(a => clienteList.Contains(a.ClienteID) == true && a.ActividadId.ToString().Contains(sSearch) ||
                                        (a.ActividadFecha != null && a.ActividadFecha.ToString("d").ToLower().Contains(sSearch)) ||
                                        (!string.IsNullOrEmpty(a.ActividadEstado.ToString()) && a.ActividadEstado.ToString().ToLower().Contains(sSearch)) ||
                                        (!string.IsNullOrEmpty(a.ActividadTitulo) && a.ActividadTitulo.ToLower().Contains(sSearch)) ||
                                        (!string.IsNullOrEmpty(a.ClienteRazonSocial) && a.ClienteRazonSocial.ToLower().Contains(sSearch)) ||
                                        (!string.IsNullOrEmpty(a.UsuarioIdElabora) && a.UsuarioIdElabora.ToLower().Contains(sSearch)))
                                 .OrderByDescending(a => a.ActividadId)
                                 .ToList()).Count;
                    }
                    else
                    {
                        ActividadesList = (from a in db.Actividad
                                           join u in db.Usuarios on a.UsuarioIdElabora equals u.UsuarioId
                                           join c in db.Clientes on a.ClienteID equals c.ClienteID
                                           select new { a.ActividadId, a.ActividadFecha, a.ActividadEstado, a.ActividadTitulo, c.ClienteID, a.cliente.ClienteRazonSocial, a.UsuarioIdElabora, u.UsuarioNombre })
                                          .Where(a => clienteList.Contains(a.ClienteID) == true)
                                          .OrderByDescending(a => a.ActividadId)
                                          .Skip(iDisplayStart).Take(iDisplayLength).ToList();

                        Count = ((from a in db.Actividad
                                  join u in db.Usuarios on a.UsuarioIdElabora equals u.UsuarioId
                                  join c in db.Clientes on a.ClienteID equals c.ClienteID
                                  select new { a.ActividadId, a.ActividadFecha, a.ActividadEstado, a.ActividadTitulo, c.ClienteID, a.cliente.ClienteRazonSocial, a.UsuarioIdElabora })
                                 .Where(a => clienteList.Contains(a.ClienteID) == true)
                                 .OrderByDescending(a => a.ActividadId)
                                 .ToList()).Count;
                    }//if (!string.IsNullOrEmpty(sSearch))
                }
                catch// (Exception e)
                {
                    ActividadesList = new List <Actividad>();
                }
            }
            else
            {
                ActividadesList = new List <Actividad>();
            }//if (HttpContext.Current.Session != null)



            var CustomerPaged = new SysDataTablePager();

            CustomerPaged.draw            = sEcho;
            CustomerPaged.recordsTotal    = Count;
            CustomerPaged.recordsFiltered = Count;
            CustomerPaged.data            = ActividadesList;

            return(CustomerPaged);
        }
示例#19
0
        public dynamic CreaOrdenXActividad(int actividadId = 0, Seguridadcll seguridadcll = null)
        {
            int NroOrden  = 0;
            var actividad = db.Actividad.Where(a => a.ActividadId == actividadId).FirstOrDefault();

            //valida que exista la actividad
            if (actividad != null)
            {
                //valida que el estado sea autorizado
                if (actividad.ActividadEstado == EstadosActividades.Autorizado)
                {
                    //Valida que no exista orden para esta actividad

                    var ordenTemp = db.Orden.Where(o => o.ActividadId == actividadId && o.OrdenEstado != EstadoOrden.Eliminado)
                                    .FirstOrDefault();

                    if (ordenTemp == null)
                    {
                        var actividadItems = db.ActividadItem
                                             .Include(a => a.producto)
                                             .Where(ai => ai.ActividadId == actividadId &&
                                                    ai.producto.TipoProductoID == "1").ToList();
                        if (actividadItems.Count > 0)
                        {
                            //Obtiene numero de Orden(ultimo de la tabla + 1)
                            Seguridad.Seguridad seguridad = new Seguridad.Seguridad();
                            NroOrden = seguridad.generaConsecutivo("Ordenes");


                            //Crear cabecera de la Orden
                            Orden orden = new Orden();
                            orden.OrdenId                = NroOrden;
                            orden.ActividadId            = actividad.ActividadId;
                            orden.OrdenFecha             = DateTime.Today;
                            orden.OrdenFechaDespacho     = DateTime.Today;
                            orden.OrdenFechaModificacion = DateTime.Today;
                            orden.OrdenNroGuia           = "";
                            orden.OrdenComentario        = actividad.ActividadTitulo;
                            orden.UsuarioIdModifica      = actividad.UsuarioIdElabora;
                            orden.OrdenEstado            = EstadoOrden.Abierta;

                            db.Orden.Add(orden);

                            db.SaveChanges();

                            //Crea Detalle de la orden
                            int Linea = 1;
                            foreach (var item in actividadItems)
                            {
                                var producto = db.Producto.Where(p => p.ProductoId == item.ProductoId).FirstOrDefault();
                                if (producto.TipoProductoID == "1")
                                {
                                    OrdenItems ordenItems = new OrdenItems();
                                    ordenItems.OrdenId                  = NroOrden;
                                    ordenItems.OrdenItemsLinea          = Linea;
                                    ordenItems.ProductoId               = item.ProductoId;
                                    ordenItems.OrdenItemsCant           = item.ActividadItemCantidad;
                                    ordenItems.OrdenItemsCantConfirmada = 0;
                                    ordenItems.OrdenItemsVlr            = item.ActividadItemPrecio ?? 0;
                                    ordenItems.CentroCostoID            = item.CentroCostoID;

                                    db.OrdenItems.Add(ordenItems);

                                    Linea++;
                                }
                            }//foreach (var item in actividadItems)
                            db.SaveChanges();
                            //MovimientosController movCtrl = new MovimientosController();
                            //int NroMovimiento = movCtrl.CreaMovimientoXOrden(NroOrden);

                            #region auditoria

                            Auditoria auditoria = new Auditoria();
                            //Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];

                            auditoria.AuditoriaFecha  = System.DateTime.Now;
                            auditoria.AuditoriaHora   = System.DateTime.Now.TimeOfDay;
                            auditoria.usuarioId       = seguridadcll.Usuario.UsuarioId;
                            auditoria.AuditoriaEvento = "Create";
                            auditoria.AuditoriaDesc   = "Se Creo la Orden: " + NroOrden;
                            auditoria.ObjetoId        = "Ordenes/CreaOrdenXActividad";

                            seguridad.insertAuditoria(auditoria);
                            #endregion auditoria
                            //Afecta cantidad de Productos Inventariables en el Gasto
                            MovimientosController movCtrl = new MovimientosController();
                            movCtrl.CreaMovimientoXOrden(orden.OrdenId, trnMode.Insert, seguridadcll);
                            //return RedirectToAction("CreaMovimientoXOrden", "Movimientos", new { OrdenId = orden.OrdenId, mode = trnMode.Insert });
                        }
                        else
                        {
                            //Cambia estado de la actividad a despachada y el gasto tambien
                            //Actualiza Estado del Gasto
                            var GastoList = db.Gasto.Where(g => g.ActividadId == actividad.ActividadId).ToList();
                            foreach (var gasto in GastoList)
                            {
                                gasto.GastoEstado     = EstadoGasto.Ejecutado;
                                db.Entry(gasto).State = EntityState.Modified;
                                db.SaveChanges();
                            }//foreach (var gasto in GastoList)


                            //Actualiza estado de la actividad
                            ActividadesController actCtrl = new ActividadesController();
                            actCtrl.CambiaEstadoActividad(actividad.ActividadId, (int)EstadosActividades.Despachado);

                            //return RedirectToAction("Index", "Actividades");
                        }//if (actividadItems.Count > 0)
                    }
                    else
                    {
                        NroOrden = 0;
                    }//if (ordenTemp == null) {
                }
                else
                {
                    NroOrden = 0;
                }//if(actividad.ActividadEstado == EstadosActividades.Autorizado)
            }
            else
            {
                NroOrden = 0;
            }//if (actividad != null)


            return(NroOrden);
        }
示例#20
0
        public Seguridadcll CargueSeguridad(Usuario usuario, HttpContext context = null, int App = 1)
        {
            db.Configuration.ProxyCreationEnabled = false;

            /*Obtiene roles*/
            var rolesUsuario   = db.RolUsuario.Where(r => r.UsuarioId == usuario.UsuarioId).ToList();
            var rolesUsuarioId = rolesUsuario.Select(ru => ru.RolId).ToArray();

            /*Aplicaciones asignadas al rol*/
            var aplicaciones = db.RolAplicaciones
                               .Include(ra => ra.Aplicacion)
                               .Where(ra => ra.Aplicacion.Activo && rolesUsuarioId.Contains(ra.RolId))
                               .Select(ra => ra.Aplicacion).Distinct().ToList();

            /*Obtiene RolObjeto*/
            var rolesObjetos = db.RolObjeto.Where(ro => rolesUsuarioId.Contains(ro.RolId) && ro.RolObjetoActivo == true).ToList();

            /*Obtiene subordinados*/
            var usuarios = db.Usuarios.Where(r => r.UsuarioPadreId == usuario.UsuarioId).ToList();

            var rolObj = rolesObjetos.Where(ro => ro.ObjetoId == "Clientes/All").FirstOrDefault();

            /*Obtiene clientes*/
            List <Cliente> clienteList = new List <Cliente>();

            if (rolObj == null)
            {
                //Plantas
                var plantas = db.UsuarioPlanta
                              .Where(ul => ul.UsuarioId == usuario.UsuarioId)
                              .Select(a => a.PlantaId).ToArray();
                //Canales
                var canales = db.UsuarioCanal
                              .Where(ul => ul.UsuarioId == usuario.UsuarioId)
                              .Select(a => a.CanalId).ToArray();


                if (plantas.Length == 0)
                {
                    //Nivel 1
                    db.Clientes.Where(c => c.VendedorId == usuario.UsuarioId)
                    .ToList().ForEach(c => clienteList.Add(c));
                }
                else
                {
                    if (canales.Length > 0)
                    {
                        //Nivel 2
                        db.Clientes.Where(c => plantas.Contains(c.PlantaID) && canales.Contains(c.CanalID))
                        .ToList().ForEach(c => clienteList.Add(c));
                    }
                    else
                    {
                        //Nivel 3
                        db.Clientes.Where(c => plantas.Contains(c.PlantaID))
                        .ToList().ForEach(c => clienteList.Add(c));
                    }
                }


                //obtiene sus clientes
                //db.Clientes
                //    .Where(c => c.PlantaID == usuario.PlantaID)
                //    .ToList()
                //    .ForEach(c => clienteList.Add(c));

                //agregamos los clientes de sus subordinados
                //foreach (var usu in usuarios)
                //{
                //    db.Clientes
                //        .Where(c => c.PlantaID == usu.PlantaID)
                //        .ToList()
                //        .ForEach(c => clienteList.Add(c));
                //}

                //clienteList = (from cl in clienteList
                //               join p in db.PresupuestoVendedor on cl.ClienteID equals p.ClienteID
                //               select cl).Distinct().ToList();
            }
            else
            {
                //Nivel 4
                clienteList = db.Clientes.ToList();
                //clienteList = (from cl in clienteList
                //               join p in db.PresupuestoVendedor on cl.ClienteID equals p.ClienteID
                //               select cl).Distinct().ToList();
            }

            //obtiene Objetos del Menu
            var objetosId   = rolesObjetos.Select(ro => ro.ObjetoId).Distinct().ToArray();
            var objetosMenu = db.Objeto
                              .Include(o => o.AplicacionObjetos)
                              .Where(o => o.ObjetoMenu == true && objetosId.Contains(o.ObjetoId)).ToList();

            var objetosMenuDirectorio = db.Objeto
                                        .Include(o => o.AplicacionObjetos)
                                        .Where(o => o.ObjetoId.StartsWith("__") && o.ObjetoMenu).ToList();

            /*Llena variable para generar session */
            var seguridadcll = new Seguridadcll()
            {
                Usuario                   = usuario,
                RolUsuarioList            = rolesUsuario,
                RolObjetoList             = rolesObjetos,
                UsuariosHijos             = usuarios,
                ClienteList               = clienteList,
                ObjetosMenuList           = objetosMenu,
                ObjetosMenuDirectorioList = objetosMenuDirectorio,
                Configuracion             = db.Configuracion.FirstOrDefault(),
                Aplicaciones              = aplicaciones
            };

            if (context == null)
            {
                Session["seguridad"] = seguridadcll;
            }
            else
            {
                context.Session["seguridad"] = seguridadcll;
            }

            return(seguridadcll);
        }
示例#21
0
        public SysDataTablePager filldata(FormDataCollection form)
        {
            string sEcho          = form["draw"].ToString();                    //pagina
            int    iDisplayStart  = Convert.ToInt32(form["Start"]);             //numero de objeto a esconder
            int    iDisplayLength = Convert.ToInt32(form["Length"]);            //tamaño de la grilla
            string sSearch        = form["search[value]"].ToString().ToLower(); //filtro smart (global)

            var movimientosList = new List <Movimiento>();
            var Count           = 0;

            if (HttpContext.Current.Session != null)
            {
                try
                {
                    Seguridadcll  seguridadcll = (Seguridadcll)HttpContext.Current.Session["seguridad"];
                    Configuracion config       = seguridadcll.Configuracion;

                    if (!string.IsNullOrEmpty(sSearch))
                    {
                        movimientosList = db.Movimiento.Include(m => m.producto)
                                          .Where(m => (m.TipoMovimientoID == config.ConfigTipoMovAjEntrada || m.TipoMovimientoID == config.ConfigTipoMovEntrada) &&
                                                 m.MovimientoDisponible > 0 && m.MovimientoEstado == EstadoMovimiento.Abierto)
                                          .ToList()
                                          .Where(m => m.MovimientoId.ToString().Contains(sSearch) ||
                                                 (m.MovimientoFechaCrea != null && m.MovimientoFechaCrea.ToString("d").ToLower().Contains(sSearch)) ||
                                                 (!string.IsNullOrEmpty(m.ProductoId) && m.ProductoId.ToLower().Contains(sSearch)) ||
                                                 (!string.IsNullOrEmpty(m.producto.ProductoDesc) && m.producto.ProductoDesc.ToLower().Contains(sSearch)) ||
                                                 (!string.IsNullOrEmpty(m.MovimientoValor.ToString()) && m.MovimientoValor.ToString().ToLower().Contains(sSearch)) ||
                                                 (!string.IsNullOrEmpty(m.MovimientoCantidad.ToString()) && m.MovimientoCantidad.ToString().ToLower().Contains(sSearch)) ||
                                                 (!string.IsNullOrEmpty(m.MovimientoDisponible.ToString()) && m.MovimientoDisponible.ToString().ToLower().Contains(sSearch)) ||
                                                 (!string.IsNullOrEmpty(m.MovimientoReservado.ToString()) && m.MovimientoReservado.ToString().ToLower().Contains(sSearch))
                                                 )
                                          .ToList();
                    }
                    else
                    {
                        movimientosList = db.Movimiento.Include(m => m.producto)
                                          .Where(m => (m.TipoMovimientoID == config.ConfigTipoMovAjEntrada || m.TipoMovimientoID == config.ConfigTipoMovEntrada) &&
                                                 m.MovimientoDisponible > 0 && m.MovimientoEstado == EstadoMovimiento.Abierto).ToList();
                    }//if (!string.IsNullOrEmpty(sSearch))
                }
                catch
                {
                    movimientosList = new List <Movimiento>();
                }// try
            }
            else
            {
                movimientosList = new List <Movimiento>();
            }//if (HttpContext.Current.Session != null)

            Count = movimientosList.Count;

            movimientosList = movimientosList.OrderByDescending(m => m.MovimientoFechaCrea)
                              .Skip(iDisplayStart).Take(iDisplayLength).ToList();


            var CustomerPaged = new SysDataTablePager();

            CustomerPaged.draw            = sEcho;
            CustomerPaged.recordsTotal    = Count;
            CustomerPaged.recordsFiltered = Count;
            CustomerPaged.data            = movimientosList.Select(m => new { m.MovimientoId, m.ProductoId, m.producto.ProductoDesc, m.MovimientoFechaCrea, m.MovimientoValor, m.MovimientoCantidad, m.MovimientoDisponible, m.MovimientoReservado, m.MovimientoLinea });

            return(CustomerPaged);
        }
示例#22
0
        //public string ViewModal { get; set; }
        void IAuthorizationFilter.OnAuthorization(AuthorizationContext filterContext)
        {
            try
            {
                Seguridad seguridad = new Seguridad();

                Seguridadcll seguridadcll = (Seguridadcll)filterContext.HttpContext.Session["seguridad"];
                if (seguridadcll == null)
                {
                    if (isModal == false)
                    {
                        string ViewModal = "~/Views/Usuarios/Login.cshtml";
                        filterContext.Result = new ViewResult()
                        {
                            ViewData = new ViewDataDictionary {
                                { "ReturnUrl", "Prueba" }
                            },
                            ViewName = ViewModal
                        };
                        //filterContext.HttpContext.Request.Url.AbsoluteUri
                        //filterContext.Controller.TempData["Url"] = filterContext.HttpContext.Request.Url.AbsoluteUri;//Request.Url.AbsoluteUri;


                        filterContext.Result = new RedirectToRouteResult(
                            new RouteValueDictionary
                        {
                            { "controller", "Usuarios" },
                            { "action", "Login" },
                            { "ReturnUrl", filterContext.HttpContext.Request.Url.AbsoluteUri }
                        }
                            );
                    }
                    else
                    {
                        //string ViewModal = "~/Views/Home/_NotAccess.cshtml";
                        //filterContext.Result = new ViewResult()
                        //{
                        //    //ViewData = new ViewDataDictionary { { "UsuarioId", seguridadcll.Usuario.UsuarioId }, { "ObjetoId", ObjetoId } },

                        //    ViewName = ViewModal
                        //};
                    }
                }
                else
                {
                    //Seguridadcll seguridadcll = (Seguridadcll)filterContext.HttpContext.Session["seguridad"];
                    string controller = filterContext.RouteData.Values["controller"].ToString();
                    string action     = filterContext.RouteData.Values["action"].ToString();

                    string ObjetoId      = controller + "/" + action;
                    bool   seguridadFlag = seguridad.validaSeguridad(seguridadcll, ObjetoId);
                    if (!seguridadFlag)
                    {
                        filterContext.Controller.TempData["UsuarioId"] = seguridadcll.Usuario.UsuarioId;
                        filterContext.Controller.TempData["ObjetoId"]  = ObjetoId;

                        if (isModal == false)
                        {
                            filterContext.Result = new RedirectToRouteResult(
                                new RouteValueDictionary
                            {
                                { "controller", "Home" },
                                { "action", "NotAccess" }
                            });
                        }
                        else
                        {
                            //filterContext.Controller.ViewBag.Error = "IsModal sin permisos";
                            string ViewModal = "~/Views/Home/_NotAccess.cshtml";
                            filterContext.Result = new ViewResult()
                            {
                                ViewData = new ViewDataDictionary {
                                    { "UsuarioId", seguridadcll.Usuario.UsuarioId }, { "ObjetoId", ObjetoId }
                                },
                                ViewName = ViewModal
                            };
                        }
                        //new ViewResult();
                        //filterContext.Controller.ViewBag.UsuarioId = seguridadcll.Usuario.UsuarioId;
                        //filterContext.Controller.ViewBag.ObjetoId = ObjetoId;
                    }
                }
            }
            catch //(System.Runtime.Serialization.SerializationException s)
            {
                filterContext.Result = new RedirectToRouteResult(
                    new RouteValueDictionary
                {
                    { "controller", "Usuarios" },
                    { "action", "Login" },
                    { "ReturnUrl", filterContext.HttpContext.Request.Url.AbsoluteUri }
                }
                    );
            }
        }
示例#23
0
        public override void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext.ActionDescriptor.GetCustomAttributes(typeof(AllowAnonymousAttribute), false).Any())
            {
                return;
            }

            if (filterContext.HttpContext.Request.IsAuthenticated)
            {
                Seguridadcll seguridadcll = (Seguridadcll)filterContext.HttpContext.Session["seguridad"];

                if (seguridadcll == null)
                {
                    using (var db = new MMSContext())
                    {
                        var usuario = db.Usuarios.FirstOrDefault(u => u.UsuarioId == filterContext.HttpContext.User.Identity.Name && u.Usuarioactivo);
                        seguridadcll = new UsuariosController().CargueSeguridad(usuario, HttpContext.Current);
                    }
                }

                string host    = filterContext.HttpContext.Request.Url.Host;
                string appName = host.Substring(0, host.IndexOf('.'));

                seguridadcll.Aplicacion = seguridadcll.Aplicaciones.FirstOrDefault(a => a.Link == appName);

                if (seguridadcll.Aplicacion == null) // no tiene permiso para la app
                {
                    base.HandleUnauthorizedRequest(filterContext);
                    return;
                }

                HttpContext.Current.Session["seguridad"] = seguridadcll;

                if (!filterContext.HttpContext.Request.IsAjaxRequest()) // no crear menu cuando sea una peticion Ajax
                {
                    var menus = seguridadcll.ObjetosMenuList
                                .Concat(seguridadcll.ObjetosMenuDirectorioList)
                                .Where(o => o.AplicacionObjetos.Any(ao => ao.AplicacionId == seguridadcll.Aplicacion.Id))
                                .Select(o => new Menu()
                    {
                        Objeto = o,
                        Active = false
                    })
                                .ToList();

                    var    sbMenu  = new StringBuilder();
                    string urlMenu = filterContext.HttpContext.Request.Url.AbsolutePath;

                    if (urlMenu.StartsWith("/"))
                    {
                        urlMenu = urlMenu.Remove(0, 1);
                    }

                    if (urlMenu.EndsWith("/"))
                    {
                        urlMenu = urlMenu.Remove(urlMenu.LastIndexOf('/'));
                    }

                    if (!urlMenu.ToLower().EndsWith("/index") && filterContext.HttpContext.Request.Url.Segments.Length == 2)
                    {
                        urlMenu += "/Index";
                    }

                    var menu = menus.Where(m => m.Objeto.ObjetoId == urlMenu).FirstOrDefault();

                    if (menu == null && filterContext.HttpContext.Request.Url.Segments.Length > 2)
                    {
                        for (int i = 2; i < filterContext.HttpContext.Request.Url.Segments.Length; i++)
                        {
                            urlMenu = urlMenu.Remove(urlMenu.LastIndexOf('/'));
                        }
                    }

                    if (!urlMenu.ToLower().EndsWith("/index"))
                    {
                        urlMenu += "/Index";
                    }

                    menu = menus.Where(m => m.Objeto.ObjetoId.ToLower() == urlMenu.ToLower()).FirstOrDefault();

                    while (menu != null)
                    {
                        menu.Active = true;
                        menu        = menus.Where(m => m.Objeto.ObjetoId == menu.Objeto.ObjetoIdPadre).FirstOrDefault();
                    }

                    var menusProcesar = menus.Where(m => m.Objeto.ObjetoIdPadre == null).OrderBy(m => m.Objeto.ObjetoOrden).ToList();
                    GenerarMenu(menusProcesar, menus, sbMenu);

                    filterContext.Controller.ViewBag.SidebarMenuHtml = sbMenu.ToString();
                }
            }

            base.OnAuthorization(filterContext);
        }
示例#24
0
        private async Task <ActionResult> GetView(int id)
        {
            Seguridadcll seguridadcll = (Seguridadcll)Session["seguridad"];

            ViewBag.UsuarioNombre = seguridadcll.Usuario.UsuarioId + " - " + seguridadcll.Usuario.UsuarioNombre;
            ViewBag.UsuarioId     = seguridadcll.Usuario.UsuarioId;

            var novedad = await db.Novedad
                          .FindAsync(id);

            if (novedad == null)
            {
                return(HttpNotFound());
            }


            var items = await db.NovedadItem
                        .Include(gi => gi.Items)
                        .Include(gi => gi.MotivoPQRS)
                        .Where(di => di.NovedadId == id).ToListAsync();

            var archivos = await db.NovedadArchivo
                           .Where(ga => ga.NovedadId == id)
                           .Select(ga => new NovedadViewModel.Archivos {
                Order = ga.Order, FileName = ga.FileName
            })
                           .ToListAsync();


            if (GetCrudMode() == Fn.CrudMode.Edit || GetCrudMode() == Fn.CrudMode.Delete)
            {
                if (novedad.Estado == EstadoFormatoPQRS.Deleted || novedad.Estado == EstadoFormatoPQRS.Completed)
                {
                    return(RedirectToAction("Index", GetReturnSearch()));
                }

                foreach (var item in items)
                {
                    if (novedad.Estado == EstadoFormatoPQRS.In_Process)
                    {
                        var pqrs = await db.PQRSRecords
                                   .Where(p => p.Id == item.PQRSRecordId && p.PasoActual == true && p.FlujoPQRSTipoPaso == TipoPaso.LlenarFormato && p.TipoPQRS == TipoPQRS.Novedad)
                                   .FirstOrDefaultAsync();

                        if (pqrs == null)
                        {
                            ViewData["has_pqrs_" + item.NovedadId + "_" + item.Id + "_" + item.MotivoPQRSId] = "hide";
                        }
                        else
                        {
                            var usuarioPQRS = await db.PQRSRecordUsuarios
                                              .Where(pu => pu.PQRSRecordId == pqrs.Id && pu.PQRSRecordOrder == pqrs.Order && pu.UsuarioId == seguridadcll.Usuario.UsuarioId)
                                              .FirstOrDefaultAsync();

                            if (usuarioPQRS == null)
                            {
                                ViewData["has_pqrs_" + item.NovedadId + "_" + item.Id + "_" + item.MotivoPQRSId] = "hide";
                            }
                            else
                            {
                                ViewData["has_pqrs_" + item.NovedadId + "_" + item.Id + "_" + item.MotivoPQRSId] = "";
                            }
                        }
                    }
                    else
                    {
                        ViewData["has_pqrs_" + item.NovedadId + "_" + item.Id + "_" + item.MotivoPQRSId] = "";
                    }
                }
            }

            ViewBag.MotivoPQRS = await db.MotivosPQRS.Where(m => m.TipoPQRS == TipoPQRS.Novedad && m.Activo == true).ToListAsync();

            ViewBag.CausaPQRS = await db.CausaPQRS.Where(m => m.TipoPQRS == TipoPQRS.Novedad).ToListAsync();

            return(View(GetCrudMode().ToString(), new NovedadViewModel
            {
                Novedad = novedad,
                Items = items,
                NovedadArchivos = archivos
            }));
        }