Beispiel #1
0
        public static IEnumerable <RoleProfile> FilterRoleProfiles(
            IEnumerable <RoleProfile> roleProfiles,
            string?searchString,
            int minMatchScore,
            bool stripStopWords
            )
        {
            if (searchString == null)
            {
                return(roleProfiles);
            }

            if (stripStopWords)
            {
                searchString = CleanSearchedWords(searchString);
            }

            var query = new RoleProfile
            {
                RoleProfileName = searchString.ToLower()
            };

            if (stripStopWords)
            {
                var results = Process.ExtractSorted(
                    query,
                    roleProfiles,
                    roleProfile => roleProfile.RoleProfileName.ToLower(),
                    ScorerCache.Get <DefaultRatioScorer>(),
                    minMatchScore
                    );
                return(results.Select(result => result.Value));
            }
            else
            {
                var results = Process.ExtractSorted(
                    query,
                    roleProfiles,
                    roleProfile => roleProfile.RoleProfileName.ToLower(),
                    ScorerCache.Get <PartialRatioScorer>(),
                    minMatchScore
                    );
                return(results.Select(result => result.Value));
            }
        }
 public bool InsertRoleOwnership(String userName, String roleName)
 {
     using (DockerDBEntities dockerEntities = new DockerDBEntities()) {
         aspnet_Users user = (from p in dockerEntities.aspnet_Users
                              where p.UserName == userName select p).First();
         RoleProfile roleProfile = new RoleProfile();
         roleProfile.UserId               = user.UserId;
         roleProfile.RoleId               = GetRoleIDByRoleName(roleName);
         roleProfile.PropertyNames        = "RoleOwner";
         roleProfile.PropertyValuesString = roleName;
         roleProfile.LastUpdateDate       = DateTime.Now;
         if (!(user.RoleProfiles).Select(role => role.PropertyValuesString.ToLower() == roleName.ToLower()).FirstOrDefault())
         {
             user.RoleProfiles.Add(roleProfile);
             dockerEntities.SaveChanges();
             return(true);
         }
         return(false);
     }
 }
Beispiel #3
0
        private Role GetRole(Group group, string name, RoleProfile profile)
        {
            var role = group.Roles.FirstOrDefault(g => g.Name.Value.AnyValue == name);

            if (role == null)
            {
                role = new Role(Guid.NewGuid());
                role.Name.Value[Language.German] = name;
                role.Group.Value = group;
                _db.Save(role);

                switch (profile)
                {
                case RoleProfile.SysAdmin:
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.CustomDefinitions, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.Structure, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.Contact, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.Subscription, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.RoleAssignments, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.TagAssignments, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.Demography, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.Documents, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.Mailings, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.Anonymous, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.Journal, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SystemWide, PartAccess.Crypto, AccessRight.Write);
                    break;

                case RoleProfile.BoardAdmin:
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.CustomDefinitions, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Structure, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Contact, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Subscription, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.RoleAssignments, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.TagAssignments, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Demography, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Documents, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Mailings, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Anonymous, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Journal, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Crypto, AccessRight.Write);
                    break;

                case RoleProfile.BoardMember:
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.CustomDefinitions, AccessRight.Read);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Structure, AccessRight.Read);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Subscription, AccessRight.Read);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.RoleAssignments, AccessRight.Read);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Contact, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.TagAssignments, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Demography, AccessRight.Read);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Documents, AccessRight.Read);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Mailings, AccessRight.Write);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Anonymous, AccessRight.Read);
                    AddPermission(role, SubjectAccess.SubFeed, PartAccess.Journal, AccessRight.Read);
                    break;

                case RoleProfile.GroupAdmin:
                    AddPermission(role, SubjectAccess.Group, PartAccess.CustomDefinitions, AccessRight.Read);
                    AddPermission(role, SubjectAccess.Group, PartAccess.Structure, AccessRight.Read);
                    AddPermission(role, SubjectAccess.Group, PartAccess.Subscription, AccessRight.Read);
                    AddPermission(role, SubjectAccess.Group, PartAccess.RoleAssignments, AccessRight.Write);
                    AddPermission(role, SubjectAccess.Group, PartAccess.Contact, AccessRight.Write);
                    AddPermission(role, SubjectAccess.Group, PartAccess.TagAssignments, AccessRight.Write);
                    AddPermission(role, SubjectAccess.Group, PartAccess.Demography, AccessRight.Read);
                    AddPermission(role, SubjectAccess.Group, PartAccess.Documents, AccessRight.Read);
                    AddPermission(role, SubjectAccess.Group, PartAccess.Mailings, AccessRight.Write);
                    AddPermission(role, SubjectAccess.Group, PartAccess.Anonymous, AccessRight.Read);
                    AddPermission(role, SubjectAccess.Group, PartAccess.Journal, AccessRight.Read);
                    break;

                case RoleProfile.GroupMember:
                    AddPermission(role, SubjectAccess.Group, PartAccess.Anonymous, AccessRight.Read);
                    break;
                }
            }

            return(role);
        }
 public void RemoveRole(RoleProfile role)
 {
     this.Delete(this.FindById(role.RoleId));
 }
Beispiel #5
0
        public ActionResult GetData(FormCollection frm, RoleProfile m)
        {
            var str  = "";
            var sect = frm["sect"];
            var edid = Convert.ToInt32((string.IsNullOrEmpty(frm["edid"]) ? "0" : frm["edid"]));

            if (sect == null)
            {
                return(Content("Sorry"));
            }

            if (sect == "frm")
            {
                _ent.Pages        = _db.Pages.ToList();
                _ent.RoleProfile  = (edid == 0 ? new RoleProfile() : _db.RoleProfiles.FirstOrDefault(x => x.Id == edid));
                _ent.RoleProfiles = (edid == 0 ? new List <RoleProfile>() : _db.RoleProfiles.Where(x => x.Title == _ent.RoleProfile.Title).ToList());
                str = PartialView("_Frm", _ent).RenderToString();
            }
            else if (sect == "detail")
            {
                var title = frm["Title"];
                var m2    = _db.RoleProfiles.Where(x => x.Title == title).ToList();
                var list  = JsonConvert.SerializeObject(m2, Formatting.None, new JsonSerializerSettings()
                {
                    ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
                });
                return(Content(list, "application/json"));
            }
            else if (sect == "sav")
            {
                var cnt   = Convert.ToInt32(frm["cnt"]);
                var nums  = frm["nums"];
                var arr   = nums.Split(',');
                var title = frm["RoleProfile.Title"];
                for (var i = 1; i < arr.Length; i++)
                {
                    var xx             = Convert.ToInt32(arr[i]);
                    var newRoleProfile = new RoleProfile();
                    var id             = Convert.ToInt16(frm["id-" + xx]);
                    var p    = Convert.ToInt16(frm["p-" + xx]);
                    var c    = Convert.ToBoolean(frm["c-" + xx]);
                    var r    = Convert.ToBoolean(frm["r-" + xx]);
                    var u    = Convert.ToBoolean(frm["u-" + xx]);
                    var d    = Convert.ToBoolean(frm["d-" + xx]);
                    var test = frm["d-" + xx];
                    newRoleProfile.Title  = title;
                    newRoleProfile.PageId = p;
                    newRoleProfile.Create = c;
                    newRoleProfile.Read   = r;
                    newRoleProfile.Update = u;
                    newRoleProfile.Delete = d;

                    if (id == 0)
                    {
                        _db.RoleProfiles.Add(newRoleProfile);
                    }
                    else
                    {
                        var old = _db.RoleProfiles.FirstOrDefault(x => x.Id == id);
                        old.Title  = title;
                        old.PageId = p;
                        old.Create = c;
                        old.Read   = r;
                        old.Update = u;
                        old.Delete = d;
                    }
                    _db.SaveChanges();
                }
            }
            else if (sect == "del")
            {
                var title = frm["Title"];
                var m2    = _db.RoleProfiles.Where(x => x.Title == title).ToList();
                _db.RoleProfiles.RemoveRange(m2);
                _db.SaveChanges();
                str = "Done";
            }

            return(Content(str));
        }
Beispiel #6
0
 void Awake()
 {
     roleProfile = new RoleProfile("风云丶一笑", 0, 15000000, 120000, 70000, 30000, 25000, 45000, 40000);
     hp          = roleProfile.HP;
 }
Beispiel #7
0
        public async Task <JsonResult> _EditRole([FromServices] SignInManager <GearUser> signInManager,
                                                 [FromServices] INotificationHub hub, string id, UpdateRoleViewModel model)
        {
            if (id != model.Id)
            {
                return(Json(new { success = false, message = "Not found" }));
            }

            if (!ModelState.IsValid)
            {
                return(Json(new { success = false, message = "Model is not valid" }));
            }

            var applicationRole = await RoleManager.FindByIdAsync(id);

            applicationRole.Name      = model.Name;
            applicationRole.Title     = model.Title;
            applicationRole.IsDeleted = model.IsDeleted;
            var result = await RoleManager.UpdateAsync(applicationRole);

            if (!result.Succeeded)
            {
                return(Json(new { success = false, message = "Cant update role" }));
            }

            var roleProfilesId = ApplicationDbContext.Set <RoleProfile>()
                                 .Where(x => x.ApplicationRoleId == applicationRole.Id);

            ApplicationDbContext.RemoveRange(roleProfilesId);
            await ApplicationDbContext.SaveChangesAsync();

            if (model.SelectedProfileId == null)
            {
                return(Json(new { success = false, message = "Select profile" }));
            }

            var role = await ApplicationDbContext.Roles.SingleOrDefaultAsync(m => m.Name == model.Name);

            if (role != null)
            {
                foreach (var _ in model.SelectedProfileId)
                {
                    var newRoleProfile = new RoleProfile
                    {
                        ApplicationRoleId = role.Id,
                        ProfileId         = Guid.Parse(_)
                    };
                    await ApplicationDbContext.AddAsync(newRoleProfile);

                    await ApplicationDbContext.SaveChangesAsync();
                }

                //Delete previous permissions
                var rolePermissionId = ApplicationDbContext.Set <RolePermission>()
                                       .Where(x => x.RoleId == applicationRole.Id);
                ApplicationDbContext.RemoveRange(rolePermissionId);
                await ApplicationDbContext.SaveChangesAsync();

                if (model.SelectedPermissionId != null)
                {
                    foreach (var _ in model.SelectedPermissionId)
                    {
                        var permission =
                            await ApplicationDbContext.Permissions.SingleOrDefaultAsync(x => x.Id == Guid.Parse(_));

                        if (permission != null)
                        {
                            var newRolePermission = new RolePermission
                            {
                                PermissionCode = permission.PermissionKey,
                                RoleId         = id,
                                PermissionId   = permission.Id
                            };
                            await ApplicationDbContext.AddAsync(newRolePermission);

                            await ApplicationDbContext.SaveChangesAsync();
                        }
                    }
                }

                var onlineUsers = hub.GetOnlineUsers();
                await User.RefreshOnlineUsersClaims(ApplicationDbContext, signInManager, onlineUsers);
            }

            return(Json(new { success = true, message = "Save success!!" }));
        }
Beispiel #8
0
        public async Task <JsonResult> _CreateRole(CreateRoleViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(Json(new { success = false, message = "Model is not valid" }));
            }

            var applicationRole = new GearRole
            {
                Name      = model.Name,
                Title     = model.Title,
                IsDeleted = model.IsDeleted,
                Created   = DateTime.Now,
                Author    = User.Identity.Name,
                ClientId  = model.ClientId,
            };
            var result = await RoleManager.CreateAsync(applicationRole);

            if (!result.Succeeded)
            {
                return(Json(new { success = false, message = "Error on create role" }));
            }

            if (model.SelectedProfileId == null)
            {
                return(Json(new { success = false, message = "Select profile" }));
            }

            var roleId = await ApplicationDbContext.Roles.AsNoTracking()
                         .SingleOrDefaultAsync(x => x.Name == model.Name);

            if (roleId == null)
            {
                return(Json(new { success = false, message = "Role not found!!!" }));
            }

            foreach (var _ in model.SelectedProfileId)
            {
                var newRoleProfile = new RoleProfile
                {
                    ApplicationRoleId = roleId.Id,
                    ProfileId         = Guid.Parse(_)
                };
                try
                {
                    await ApplicationDbContext.AddAsync(newRoleProfile);

                    await ApplicationDbContext.SaveChangesAsync();
                }
                catch (Exception e)
                {
                    _logger.LogError(e.Message);
                    return(Json(new { success = false, message = "Error on save!" }));
                }
            }

            if (model.SelectedPermissionId.Any())
            {
                foreach (var _ in model.SelectedPermissionId)
                {
                    var permission =
                        await ApplicationDbContext.Permissions.SingleOrDefaultAsync(x => x.Id == Guid.Parse(_));

                    if (permission != null)
                    {
                        var newRolePermission = new RolePermission
                        {
                            PermissionCode = permission.PermissionKey,
                            RoleId         = roleId.Id,
                            PermissionId   = permission.Id
                        };
                        try
                        {
                            await ApplicationDbContext.AddAsync(newRolePermission);

                            await ApplicationDbContext.SaveChangesAsync();
                        }
                        catch (Exception e)
                        {
                            _logger.LogError(e.Message);
                            return(Json(new { success = false, message = "Error on save!" }));
                        }
                    }
                }
            }

            return(Json(new { success = true, message = "Save success!!!" }));
        }