public ActionResult RoleToPermission(int pIdRole)
        {
            Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
            Rol rol = db.Rol.Where(x => x.IdRol == pIdRole).FirstOrDefault();

            return(View(rol));
        }
        public JsonResult AssignedUsers_Read([DataSourceRequest] DataSourceRequest request, int pIdRole)
        {
            Models.Data.EkiibrateDBEntities db     = new Models.Data.EkiibrateDBEntities(true);
            List <ViewModelUsuario>         result = db.UsuarioPorRol.Where(x => x.IdRol == pIdRole).Select(x => new ViewModelUsuario
            {
                Activo        = x.Usuario.Activo,
                Contraseña    = x.Usuario.Contraseña,
                IdPersona     = x.Usuario.IdPersona,
                IdTipoUsuario = x.Usuario.IdTipoUsuario,
                IdUsuario     = x.Usuario.IdUsuario,
                NombreUsuario = x.Usuario.NombreUsuario,
                GE_Persona    = new ViewModelPersona
                {
                    Apellido  = x.Usuario.GE_Persona.Apellido,
                    Correo    = x.Usuario.GE_Persona.Correo,
                    Direccion = x.Usuario.GE_Persona.Direccion,
                    Extension = x.Usuario.GE_Persona.Extension,
                    Id        = x.Usuario.GE_Persona.Id,
                    Nombre    = x.Usuario.GE_Persona.Nombre,
                    Puesto    = x.Usuario.GE_Persona.Puesto,
                    Telefono  = x.Usuario.GE_Persona.Telefono
                }
            }).ToList();

            return(new JsonNetResult
            {
                Data = result
                       .ToTreeDataSourceResult(request),
                JsonRequestBehavior = JsonRequestBehavior.AllowGet
            });
        }
 public ActionResult Object_Create([DataSourceRequest] DataSourceRequest request, ViewModelObjeto model)
 {
     try
     {
         if (model != null && ModelState.IsValid)
         {
             Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
             Objeto obj = new Objeto
             {
                 Activo        = true,
                 Descripcion   = model.Description,
                 IdObjetoPadre = model.IdNewPermissionParent,
                 IdProducto    = model.IdProduct,
                 Nombre        = model.Name
             };
             db.Objeto.Add(obj);
             db.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         ModelState.AddModelError("Model", ex.Message);
     }
     return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
 }
        public ActionResult OperarMenu(Models.Data.Menu model)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
                    if (model.IdMenu <= 0)
                    {
                        db.Menu.Add(model);
                        db.SaveChanges();
                        //model.Add();
                    }
                    else
                    {
                        var original = db.Menu.Find(model.IdMenu);

                        if (original != null)
                        {
                            db.Entry(original).CurrentValues.SetValues(model);
                            db.SaveChanges();
                        }
                        //    model.Update();
                    }
                }
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("s", ex);
            }
            return(PartialView("Menu", model));
        }
Example #5
0
        public ActionResult User_Create([DataSourceRequest] DataSourceRequest request, ViewModelUsuario model)
        {
            try
            {
                if (model != null && ModelState.IsValid)
                {
                    Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
                    Usuario efModel = new Usuario
                    {
                        GE_Persona    = model.GE_Persona.CopyPropertiesTo(new GE_Persona()),
                        IdPersona     = model.IdPersona,
                        IdTipoUsuario = model.IdTipoUsuario,
                        NombreUsuario = model.NombreUsuario,
                    };
                    efModel.Contraseña  = model.NombreUsuario.Encrypt();
                    efModel.Activo      = true;
                    model.GE_Persona.Id = db.GE_Persona.Max(x => x.Id) + 1;
                    db.GE_Persona.Add(efModel.GE_Persona);
                    db.Usuario.Add(efModel);

                    db.SaveChanges();
                }
            }
            catch (Exception ex)
            {
                ModelState.AddModelError(string.Empty, ex.Message);
            }
            return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
        }
        public ActionResult DeleteUserToRole(int pIdRole, int pIdUser)
        {
            try
            {
                Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
                UsuarioPorRol model = db.UsuarioPorRol.Where(x => x.IdRol == pIdRole && x.IdUsuario == pIdUser).FirstOrDefault();
                db.UsuarioPorRol.Attach(model);
                db.Entry(model).State = EntityState.Deleted;

                HistoricoUsuarioPorRol model2 = new HistoricoUsuarioPorRol();
                model2.IdRol                   = model.IdRol;
                model2.IdUsuario               = model.IdUsuario;
                model2.TransacUser             = model.TransacUser;
                model2.TransacDateTime         = model.TransacDateTime;
                model2.HistoricTransacUser     = "******";
                model2.HistoricTransacDateTime = DateTime.Now;

                db.HistoricoUsuarioPorRol.Add(model2);

                db.SaveChanges();

                return(Json(new { success = true, error = "" }));
            }
            catch (Exception ex)
            {
                return(Json(new { success = false, error = ex.Message }));
            }
        }
Example #7
0
        public ActionResult User_Read([DataSourceRequest] DataSourceRequest request)
        {
            Models.Data.EkiibrateDBEntities db   = new Models.Data.EkiibrateDBEntities(true);
            List <ViewModelUsuario>         user = db.Usuario.Where(x => x.Activo == true).Select(x => new ViewModelUsuario
            {
                Activo        = x.Activo,
                Contraseña    = x.Contraseña,
                IdPersona     = x.IdPersona,
                IdTipoUsuario = x.IdTipoUsuario,
                IdUsuario     = x.IdUsuario,
                NombreUsuario = x.NombreUsuario,
                GE_Persona    = new ViewModelPersona
                {
                    Apellido  = x.GE_Persona.Apellido,
                    Correo    = x.GE_Persona.Correo,
                    Direccion = x.GE_Persona.Direccion,
                    Extension = x.GE_Persona.Extension,
                    Id        = x.GE_Persona.Id,
                    Nombre    = x.GE_Persona.Nombre,
                    Puesto    = x.GE_Persona.Puesto,
                    Telefono  = x.GE_Persona.Telefono
                }
            }).ToList();

            return(new JsonNetResult
            {
                Data = user
                       .ToDataSourceResult(request),
                JsonRequestBehavior = JsonRequestBehavior.AllowGet
            });
        }
        public ActionResult GlobalParameter_Create([DataSourceRequest] DataSourceRequest request, ViewModelParametroGeneral model)
        {
            try
            {
                ParametroGeneral efModel           = model.CopyPropertiesTo(new ParametroGeneral());
                Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
                efModel.Activo          = true;
                efModel.TransacUser     = this.HttpContext.GetActualUser().NombreUsuario;
                efModel.TransacDateTime = DateTime.Now;
                if (ModelState.IsValid)
                {
                    try
                    {
                        switch (efModel.IdParametroTipo)
                        {
                        case (int)EParametroTipo.String:
                            Convert.ToString(model.Valor);
                            break;

                        case (int)EParametroTipo.Entero:
                            Convert.ToInt32(model.Valor);
                            break;

                        case (int)EParametroTipo.Decimal:
                            Convert.ToDecimal(model.Valor);
                            break;

                        case (int)EParametroTipo.Booleano:
                            Convert.ToBoolean(model.Valor);
                            break;

                        case (int)EParametroTipo.FechaHora:
                            Convert.ToDateTime(model.Valor);
                            break;

                        case (int)EParametroTipo.Hora:
                            Convert.ToDateTime(model.Valor);
                            break;

                        case (int)EParametroTipo.EncryptString:
                            BarcoSoftUtilidades.Utilidades.Cryptography.Decrypt(model.Valor);
                            break;
                        }
                        db.ParametroGeneral.Add(efModel);
                        db.SaveChanges();
                    }
                    catch (Exception ex)
                    {
                        ModelState.AddModelError("Valor", ex.Message);
                    }
                }
            }
            catch (Exception ex)
            {
                ModelState.AddModelError(string.Empty, ex.Message);
            }
            return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
        }
 public JsonResult GetProducts(int?IdOwner)
 {
     Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
     return(Json(db.Producto.Where(y => ((y.IdPropietario == IdOwner && IdOwner != null) || IdOwner == null) && y.Activo).ToList()
                 .Select(x => new DropDownListItem
     {
         Text = x.Nombre,
         Value = x.IdProducto.ToString()
     }).OrderBy(e => e.Text).ToList(), JsonRequestBehavior.AllowGet));
 }
 /// <summary>
 /// Request de la información de propietarios.
 /// </summary>
 /// <param name="request"></param>
 /// <returns></returns>
 public ActionResult Owner_Read([DataSourceRequest] DataSourceRequest request)
 {
     Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
     return(new JsonNetResult
     {
         Data = db.Propietario.Where(x => x.Activo == true).ToList().Select(x => x.CopyPropertiesTo(new ViewModelPropietario())).ToList()
                .ToDataSourceResult(request),
         JsonRequestBehavior = JsonRequestBehavior.AllowGet
     });
 }
 public ActionResult Product_Create([DataSourceRequest] DataSourceRequest request, Producto model)
 {
     if (model != null && ModelState.IsValid)
     {
         Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
         model.Activo = true;
         db.Producto.Add(model);
         db.SaveChanges();
     }
     return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
 }
        public JsonResult GetOwners()
        {
            Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);

            return(Json(db.Propietario.Where(x => x.Activo).ToList()
                        .Select(x => new DropDownListItem
            {
                Text = x.Nombre,
                Value = x.IdPropietario.ToString()
            }).OrderBy(e => e.Text).ToList(), JsonRequestBehavior.AllowGet));
        }
 public ActionResult GlobalParameter_Read([DataSourceRequest] DataSourceRequest request, int?pIdOwner)
 {
     Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
     return(new JsonNetResult
     {
         Data = db.ParametroGeneral.Where(x => x.Activo && (pIdOwner == null || x.IdPropietario == pIdOwner)).ToList()
                .Select(x => x.CopyPropertiesTo(new ViewModelParametroGeneral()))
                .ToDataSourceResult(request),
         JsonRequestBehavior = JsonRequestBehavior.AllowGet
     });
 }
Example #14
0
 /// <summary>
 /// Elimina una relación de un permiso con un rol.
 /// </summary>
 /// <param name="IdPermission">Identificador del permiso</param>
 /// <param name="IdRole">Identificador del rol</param>
 /// <param name="UserTransac">Usuario realiza la transacción</param>
 public void Delete(int IdObjeto, int IdRol, string UserTransac)
 {
     Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
     if (IdObjeto > 0 && IdRol > 0 && UserTransac.Length > 0)
     {
         db.SP_PermisoAObjeto_Del(IdObjeto, IdRol, UserTransac);
     }
     else
     {
         throw new Exception("Error en en los identificadores.");
     }
 }
Example #15
0
        public ActionResult Users()
        {
            Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
            ViewBag.UserTypes = db.TipoUsuario.Where(x => x.Activo == true)
                                .Select(x => new DropDownListItem
            {
                Text  = x.Nombre,
                Value = x.IdTipoUsuario.ToString()
            }).OrderBy(e => e.Text).ToList();

            return(View());
        }
Example #16
0
        public ActionResult UserType_Read([DataSourceRequest] DataSourceRequest request)
        {
            Models.Data.EkiibrateDBEntities db            = new Models.Data.EkiibrateDBEntities(true);
            List <ViewModelTipoUsuario>     userTypesList = db.TipoUsuario.Where(x => x.Activo == true).ToList().Select(x => x.CopyPropertiesTo(new ViewModelTipoUsuario())).ToList();

            return(new JsonNetResult
            {
                Data = userTypesList
                       .ToDataSourceResult(request),
                JsonRequestBehavior = JsonRequestBehavior.AllowGet
            });
        }
        private string GetGlobalParametersEnum(int pIdOwner)
        {
            Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
            string result = "public enum Parameters  <br>     { <br>";

            db.ParametroGeneral.Where(y => y.Activo && y.IdPropietario == pIdOwner).ToList().ForEach(x =>
            {
                result += "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;" + x.Nombre.Replace(" ", "") + "" + x.ParametroTipo.Nombre + " = " + x.IdPropietario + ",  <br>";
            });
            result += " } ";
            return(result);
        }
        private List <Objeto> GetAllChilds(int idObjeto)
        {
            List <Objeto> result = new List <Objeto>();

            Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
            db.Objeto.Where(x => x.Activo && x.IdObjetoPadre == idObjeto).ToList().ForEach(x =>
            {
                result.Add(x);
                result.AddRange(GetAllChilds(x.IdObjeto));
            });


            return(result);
        }
        public ActionResult GlobalParameter_Update([DataSourceRequest] DataSourceRequest request, ViewModelParametroGeneral model)
        {
            try
            {
                Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);

                var original = db.ParametroGeneral.Find(model.IdParametroGeneral);
                model.TransacUser     = this.HttpContext.GetActualUser().NombreUsuario;
                model.TransacDateTime = DateTime.Now;
                if (ModelState.IsValid && original != null)
                {
                    switch (model.IdParametroTipo)
                    {
                    case (int)EParametroTipo.Entero:
                        Convert.ToInt32(model.Valor);
                        break;

                    case (int)EParametroTipo.Decimal:
                        Convert.ToDecimal(model.Valor);
                        break;

                    case (int)EParametroTipo.Booleano:
                        Convert.ToBoolean(model.Valor);
                        break;

                    case (int)EParametroTipo.FechaHora:
                        Convert.ToDateTime(model.Valor);
                        break;

                    case (int)EParametroTipo.Hora:
                        Convert.ToDateTime(model.Valor);
                        break;

                    case (int)EParametroTipo.EncryptString:
                        BarcoSoftUtilidades.Utilidades.Cryptography.Decrypt(model.Valor);
                        break;
                    }

                    db.Entry(original).CurrentValues.SetValues(model);
                    db.SaveChanges();
                }
            }
            catch (Exception ex)
            {
                ModelState.AddModelError(string.Empty, ex.Message);
            }
            return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
        }
 public ActionResult Object_Read([DataSourceRequest] DataSourceRequest request, int pIdProduct)
 {
     Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
     return(Json(db.Objeto.Where(x => x.Activo && pIdProduct == x.IdProducto).Select(y => new Models.ViewModelObjeto
     {
         IdPermission = y.IdObjeto,
         IdNewPermissionParent = y.IdObjetoPadre,
         IdProduct = y.IdProducto,
         IdPermissionParent = y.IdObjetoPadre,
         Name = y.Nombre,
         ProductName = y.Producto.Nombre,
         Description = y.Descripcion,
         IdOwner = y.Producto.IdPropietario
     }).ToList().
                 ToTreeDataSourceResult(request), JsonRequestBehavior.AllowGet));
 }
        public JsonResult GetPermission(int IdProduct, int?IdPermission)
        {
            Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
            var hijos = new List <Objeto>();

            if (IdPermission != null)
            {
                hijos = GetAllChilds((int)IdPermission);
            }
            return(Json(db.Objeto.Where(y => y.Activo && y.IdProducto == IdProduct && (IdPermission == null || (y.IdObjeto != IdPermission && hijos.Where(z => z.IdObjeto == y.IdObjeto).Count() == 0)))
                        .Select(x => new DropDownListItem
            {
                Text = x.Nombre,
                Value = x.IdObjeto.ToString()
            }).OrderBy(e => e.Text).ToList(), JsonRequestBehavior.AllowGet));
        }
        public ActionResult Menu(int pIdObject, string pObject)
        {
            Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
            var menu = db.Menu.Where(x => x.IdObjeto == pIdObject);//new SecurityBL.General.Menu().GetActive().Where(x => x.IdPermission == pIdPermission);

            if (menu.Count() == 0)
            {
                Models.Data.Menu newMenu = new Models.Data.Menu();
                newMenu.IdObjeto = pIdObject;
                newMenu.Nombre   = pObject;
                return(PartialView("Menu", newMenu));
            }
            else
            {
                return(PartialView("Menu", menu.FirstOrDefault()));
            }
        }
 public ActionResult Owner_Create([DataSourceRequest] DataSourceRequest request, Propietario model)
 {
     try
     {
         if (model != null && ModelState.IsValid)
         {
             Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
             model.Activo = true;
             db.Propietario.Add(model);
             db.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         ModelState.AddModelError(string.Empty, ex.Message);
     }
     return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
 }
        public ActionResult ObjectManager()
        {
            Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
            ViewBag.Products = db.Producto.Where(x => x.Activo == true).ToList()
                               .Select(x => new DropDownListItem
            {
                Text  = x.Nombre,
                Value = x.IdProducto.ToString()
            }).OrderBy(e => e.Text).ToList();

            ViewBag.PermissionsParent = db.Objeto.Where(x => x.Activo == true)
                                        .Select(x => new DropDownListItem
            {
                Text  = x.IdObjeto + " | " + x.Nombre,
                Value = x.IdObjeto.ToString()
            }).OrderBy(e => e.Text).ToList();
            return(View());
        }
        public ActionResult GlobalParameters()
        {
            Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
            ViewBag.Owner = db.Propietario.Where(x => x.Activo == true).ToList()
                            .Select(x => new DropDownListItem
            {
                Text  = x.Nombre,
                Value = x.IdPropietario.ToString()
            }).OrderBy(e => e.Text).ToList();

            ViewBag.ParameterType = db.ParametroTipo
                                    .Select(x => new DropDownListItem
            {
                Text  = x.Nombre,
                Value = x.IdParametroTipo.ToString()
            }).OrderBy(e => e.Value).ToList();
            return(View());
        }
 public ActionResult Products()
 {
     try
     {
         Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
         ViewBag.Owner = db.Propietario.Where(x => x.Activo == true).ToList()
                         .Select(x => new DropDownListItem
         {
             Text  = x.Nombre,
             Value = x.IdPropietario.ToString()
         }).OrderBy(e => e.Text).ToList();
     }
     catch (Exception ex)
     {
         ViewBag.Error = ex.Message;
     }
     return(View());
 }
 public ActionResult Product_Update([DataSourceRequest] DataSourceRequest request, Producto model)
 {
     try
     {
         if (model != null && ModelState.IsValid)
         {
             Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
             db.Producto.Attach(model);
             db.Entry(model).State = EntityState.Modified;
             db.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         ModelState.AddModelError(string.Empty, ex.Message);
     }
     return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
 }
 public ActionResult AddUserToRole(int pIdRole, int pIdUser)
 {
     try
     {
         Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
         UsuarioPorRol model = new UsuarioPorRol();
         model.IdRol           = pIdRole;
         model.IdUsuario       = pIdUser;
         model.TransacUser     = "******";
         model.TransacDateTime = DateTime.Now;
         db.UsuarioPorRol.Add(model);
         db.SaveChanges();
         return(Json(new { success = true, error = "" }));
     }
     catch (Exception ex)
     {
         return(Json(new { success = false, error = ex.Message }));
     }
 }
 public ActionResult Role_Read([DataSourceRequest] DataSourceRequest request)
 {
     Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
     return(new JsonNetResult
     {
         Data = db.Rol.Where(x => x.Activo == true)
                .Select(y => new ViewModelRole
         {
             Activo = y.Activo,
             Descripcion = y.Descripcion,
             IdPropietario = y.IdPropietario,
             IdRol = y.IdRol,
             Nombre = y.Nombre
         })
                .ToList()
                .ToDataSourceResult(request),
         JsonRequestBehavior = JsonRequestBehavior.AllowGet
     });
 }
        public ActionResult Role_Update([DataSourceRequest] DataSourceRequest request, Rol model)
        {
            try
            {
                Models.Data.EkiibrateDBEntities db = new Models.Data.EkiibrateDBEntities(true);
                var original = db.Rol.Find(model.IdRol);

                if (model != null && ModelState.IsValid && original != null)
                {
                    db.Entry(original).CurrentValues.SetValues(model);
                    db.SaveChanges();
                }
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("Model", ex.Message);
            }
            return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
        }