public async Task <IActionResult> Edit(int id, [Bind("GroupRolesId,roles,ApplicationGroupId")] GroupRoles groupRoles)
{
if (id != groupRoles.GroupRolesId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
groupRoles.roles = groupRoles.roles.ToLower();
_context.Update(groupRoles);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GroupRolesExists(groupRoles.GroupRolesId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationGroupId"] = new SelectList(_context.ApplicationGroup, "ApplicationGroupId", "ApplicationGroupId", groupRoles.ApplicationGroupId);
return(View(groupRoles));
}
public void AddGoupRoles(List <AvatarGroup> groups)
{
if (_Prim0 != null)
{
foreach (AvatarGroup avatarGroup in groups)
{
AddGroup(avatarGroup.GroupID);
}
}
GroupRoles = GroupRoles ?? new Dictionary <UUID, AvatarGroup>();
lock (GroupRoles)
foreach (var avatarGroup in groups)
{
var id = avatarGroup.GroupID;
AvatarGroup prev;
if (GroupRoles.TryGetValue(id, out prev))
{
if (false && prev.GroupPowers != avatarGroup.GroupPowers)
{
Debug("GroupPowers changed = " + prev + " -> " + avatarGroup);
}
}
GroupRoles[id] = avatarGroup;
}
}
public static void Initialize(ApplicationDbContext context)
{
context.Database.EnsureCreated();
if (context.ApplicationGroup.Any())
{
return; //Kalo udah ada seed nya ga akan tumbuh
}
ApplicationGroup admingroup = new ApplicationGroup()
{
akses = "admin"
};
ApplicationGroup membergroup = new ApplicationGroup()
{
akses = "member"
};
context.ApplicationGroup.Add(admingroup);
context.ApplicationGroup.Add(membergroup);
context.SaveChanges();
GroupRoles admin = new GroupRoles()
{
roles = "admin", ApplicationGroupId = admingroup.ApplicationGroupId
};
GroupRoles member = new GroupRoles()
{
roles = "member", ApplicationGroupId = membergroup.ApplicationGroupId
};
context.GroupRoles.Add(admin);
context.GroupRoles.Add(member);
context.SaveChanges();
}
public async Task <List <int> > GetGroupMembersForGivenRole(int groupID, GroupRoles groupRoles)
{
GetGroupMembersForGivenRoleRequest request = new GetGroupMembersForGivenRoleRequest()
{
AuthorisingUserID = -1,
GroupId = groupID,
GroupRole = new RoleRequest()
{
GroupRole = groupRoles
}
};
string path = $"/api/GetGroupMembersForGivenRole";
using (HttpResponseMessage response = await _httpClientWrapper.GetAsync(HttpClientConfigName.GroupService, path, request, CancellationToken.None).ConfigureAwait(false))
{
string jsonResponse = await response.Content.ReadAsStringAsync();
var getGroupMembersForGivenRoleResponse = JsonConvert.DeserializeObject <ResponseWrapper <GetGroupMembersForGivenRoleResponse, GroupServiceErrorCode> >(jsonResponse);
if (getGroupMembersForGivenRoleResponse.HasContent && getGroupMembersForGivenRoleResponse.IsSuccessful)
{
GetGroupMembersForGivenRoleResponse resp = getGroupMembersForGivenRoleResponse.Content;
return(resp.UserIDs);
}
return(null);
}
}
public ActionResult Grant(GroupRoles gr)
{
string msg = "";
// 1. Gán
// 2. Hủy
// Kiểm tra quyền đã có hay chưa
if (_groupRole.GetAll().Any(x => x.GroupId == gr.GroupId && x.BusinessId == gr.BusinessId && x.RoleId == gr.RoleId))
{
// Quyền đã tồn tại => Hủy
var _gr = _groupRole.SingleBy(x => x.GroupId == gr.GroupId && x.BusinessId == gr.BusinessId && x.RoleId == gr.RoleId);
// Hủy quyền (xóa)
_groupRole.Remove(_gr);
msg = "Hủy quyền thành công!";
}
else
{
// Quyền chưa tồn tại => Gán quyền
_groupRole.Add(gr);
msg = "Gán quyền thành công!";
}
return(Json(new
{
StatusCode = 200,
Message = msg
}, JsonRequestBehavior.AllowGet));
}
public static string FriendlyName(this GroupRoles role)
{
return(role switch
{
GroupRoles.UserAdmin => "User Admin",
GroupRoles.UserAdmin_ReadOnly => "User Admin (Read-only)",
GroupRoles.TaskAdmin => "Request Admin",
GroupRoles.RequestSubmitter => "Request Submitter",
_ => role.ToString()
});
public void AddGroupRole(String roleId, String groupId)
{
var groupRole = new GroupRoles()
{
RoleId = roleId,
GroupId = groupId
};
_context.GroupRoles.Add(groupRole);
_context.SaveChanges();
}
public async Task <IActionResult> Create([Bind("GroupRolesId,roles,ApplicationGroupId")] GroupRoles groupRoles)
{
if (ModelState.IsValid)
{
groupRoles.roles = groupRoles.roles.ToLower();
_context.Add(groupRoles);
await _context.SaveChangesAsync();
await _role.UpdateRole(groupRoles.ApplicationGroupId);
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationGroupId"] = new SelectList(_context.ApplicationGroup, "ApplicationGroupId", "ApplicationGroupId", groupRoles.ApplicationGroupId);
return(View(groupRoles));
}
protected void GroupItemChanging(GroupsModel newValue)
{
if (newValue != null)
{
GroupRolesSource.Clear();
var roles = GroupRoles.Where(x => x.GrolrGIdFk == newValue.GId);
foreach (var item in roles)
{
var role = Roles.Where(x => x.RoleId == item.GrolrRoleIdFk).FirstOrDefault();
if (role != null)
{
GroupRolesSource.Add(role.FillRoles(item));
}
}
}
}
public void Subscribe(int groupId, int userId, GroupRoles role)
{
GroupRole groupRole = dbContext.GroupRoles.Where(r => r.Title == role.ToString()).First();
ReaderProfileState state = dbContext.ReaderProfileStates
.Where(s => s.Title == ReaderProfileStates.FullAccess.ToString()).First();
ReaderProfile profile = new ReaderProfile()
{
GroupId = groupId,
UserId = userId,
GroupRoleId = groupRole.Id,
ReaderProfileStateId = state.Id
};
dbContext.ReaderProfiles.Add(profile);
dbContext.SaveChanges();
}
public void SelectIndexChanged(GroupsModel group)
{
if (group != null)
{
GroupRolesSource.Clear();
var roles = GroupRoles.Where(x => x.GrolrGIdFk == group.GId);
foreach (var item in roles)
{
var role = Roles.Where(x => x.RoleId == item.GrolrRoleIdFk).FirstOrDefault();
if (role != null)
{
GroupRolesSource.Add(role.FillRoles(item));
}
}
}
}
public bool InGroup(UUID uuid)
{
if (CogbotHelpers.IsNullOrZero(uuid))
{
return(false);
}
if (GroupRoles != null)
{
if (GroupRoles.ContainsKey(uuid))
{
return(true);
}
}
var ag = AvatarGroups;
return(ag != null && ag.Contains(uuid));
}
public void CreateGroupRoles()
{
ApplicationDbContext db = new ApplicationDbContext();
var roles = db.GroupRoles;
var creatorFound = false;
var adminFound = false;
var userFound = false;
foreach (GroupRoles role in roles)
{
if (role.RoleName == "Creator")
{
creatorFound = true;
}
if (role.RoleName == "Admin")
{
adminFound = true;
}
if (role.RoleName == "User")
{
userFound = true;
}
}
if (!creatorFound)
{
var newRole = new GroupRoles();
newRole.RoleName = "Creator";
db.GroupRoles.Add(newRole);
db.SaveChanges();
}
if (!adminFound)
{
var newRole = new GroupRoles();
newRole.RoleName = "Admin";
db.GroupRoles.Add(newRole);
db.SaveChanges();
}
if (!userFound)
{
var newRole = new GroupRoles();
newRole.RoleName = "User";
db.GroupRoles.Add(newRole);
db.SaveChanges();
}
}
public bool editRoleForUser(int idUser, int idGroupWantAddUser, int idGroupWantRemoveUser)
{
try
{
User user = db.Users.Find(idUser);
GroupRoles groupRoleWantAddUser = db.GroupRoles.Find(idGroupWantAddUser);
groupRoleWantAddUser.listUser.Add(user);
GroupRoles groupRoleWantRemoveUser = db.GroupRoles.Find(idGroupWantRemoveUser);
groupRoleWantRemoveUser.listUser.Remove(user);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
public void Refresh()
{
GroupRoles.Clear();
new Thread(() =>
{
List <GroupsModel> dataSource = null;
Thread inProgress = new Thread(() =>
{
IsInProgress = true;
try
{
dataSource = DataAccess.GroupsData();
GroupRoles = DataAccess.GroupRolesData();
Roles = DataAccess.RolesData();
}
catch { MessageBox.Show("could not open connection with server!\nCheck your internet connection or server is connected", "Warning", MessageBoxButton.OK, MessageBoxImage.Warning); }
})
{
IsBackground = true
};
inProgress.Start();
while (inProgress.IsAlive)
{
if (RotateAngle > 360)
{
RotateAngle = 0;
}
RotateAngle += 18.25;
Thread.Sleep(50);
}
while (RotateAngle > 0 && RotateAngle < 365)
{
RotateAngle += 18.25;
Thread.Sleep(50);
}
RotateAngle = 0;
DataGridSource.ReFill(dataSource);
IsInProgress = false;
})
{
IsBackground = true
}.Start();
GroupRolesSource.Clear();
}
public DbContext()
{
var client = new MongoClient("mongodb://localhost:27017/?readPreference=primary&appname=MongoDB%20Compass&ssl=false");
_dbContext = client.GetDatabase("Identity");
var userFilter = Builders <User> .Filter.Empty;
var moduleFilter = Builders <Module> .Filter.Empty;
var groupFilter = Builders <Group> .Filter.Empty;
var actionFilter = Builders <Action> .Filter.Empty;
var groupRoleFilter = Builders <GroupRole> .Filter.Empty;
var userDocument = Users.Count(userFilter);
var moduleDocument = Modules.Count(moduleFilter);
var groupDocument = Groups.Count(groupFilter);
var actionDocument = Actions.Count(actionFilter);
var groupRoleDocument = GroupRoles.Count(groupRoleFilter);
if (userDocument == 0)
{
UserSeed();
}
if (moduleDocument == 0)
{
ModuleSeed();
}
if (groupDocument == 0)
{
GroupSeed();
}
if (actionDocument == 0)
{
ActionSeed();
}
if (groupRoleDocument == 0)
{
GroupRoleSeed();
}
}
public async Task <bool> GetUserHasRole(int userId, int groupId, GroupRoles role, bool allowRoleFromParentGroup, CancellationToken cancellationToken)
{
var userGroupRoles = await GetUserGroupRoles(userId, cancellationToken);
if (GetUserHasRole(userGroupRoles, groupId, role))
{
return(true);
}
else if (allowRoleFromParentGroup)
{
var group = await _groupService.GetGroupById(groupId, cancellationToken);
if (group.ParentGroupId.HasValue)
{
return(await GetUserHasRole(userId, group.ParentGroupId.Value, role, false, cancellationToken));
}
}
return(false);
}
public void Edit()
{
if (SelectedDataItem != null)
{
var item = SelectedDataItem;
for (int i = 0; i < Roles.Count; i++)
{
var role = GroupRolesSource.Where(x => x.RoleId == Roles[i].RoleId).FirstOrDefault();
if (role != null)
{
var groupRoles = GroupRoles.Where(x => x.GrolrRoleIdFk == Roles[i].RoleId && x.GrolrGIdFk == item.GId).FirstOrDefault();
Roles[i].IsChecked = true;
Roles[i].GroleAdd = groupRoles.GroleAdd;
Roles[i].GroleEdit = groupRoles.GroleEdit;
Roles[i].GroleDelete = groupRoles.GroleDelete;
Roles[i].GroleExport = groupRoles.GroleExport;
Roles[i].GrolePrint = groupRoles.GrolePrint;
Roles[i].GroleView = groupRoles.GroleView;
}
else
{
Roles[i].IsChecked = false;
Roles[i].GroleAdd = false.ToIntState();
Roles[i].GroleEdit = false.ToIntState();
Roles[i].GroleDelete = false.ToIntState();
Roles[i].GroleExport = false.ToIntState();
Roles[i].GrolePrint = false.ToIntState();
Roles[i].GroleView = false.ToIntState();
}
}
VGroupsEdit edit = new VGroupsEdit(Roles, item);
if (edit.ShowDialog() == true)
{
var dataContext = edit.DataContext as VMGroupsEdit;
DataGridSource.Remove(SelectedDataItem);
DataGridSource.Add(dataContext.EditGroup);
GroupRoles.RemoveAll(x => x.GrolrGIdFk == item.GId);
GroupRoles.AddRange(dataContext.DataGridSource.Where(x => x.RoleSelected()).Select(x => x.ToGroupRoles(item.GId)));
}
GroupRolesSource.Clear();
}
}
protected void GroupItemChanging(GroupsModel newValue)
{
IsInProgress = true;
new Thread(() =>
{
})
{
IsBackground = true
}.Start();
if (newValue != null)
{
GroupRolesSource.Clear();
var roles = GroupRoles.Where(x => x.GrolrGIdFk == newValue.GId);
foreach (var item in roles)
{
var role = Roles.Where(x => x.RoleId == item.GrolrRoleIdFk).FirstOrDefault();
if (role != null)
{
GroupRolesSource.Add(role.FillRoles(item));
}
}
}
}
public void Add()
{
foreach (var item in Roles)
{
item.IsChecked = false;
item.GroleAdd = false.ToIntState();
item.GroleEdit = false.ToIntState();
item.GroleDelete = false.ToIntState();
item.GroleExport = false.ToIntState();
item.GrolePrint = false.ToIntState();
item.GroleView = false.ToIntState();
}
VGroupsAdd add = new VGroupsAdd(Roles);
if (add.ShowDialog() == true)
{
DataGridSource.Add((add.DataContext as VMGroupsAdd).AddedGroup);
foreach (var item in (add.DataContext as VMGroupsAdd).AddedGroupRoles)
{
GroupRoles.Add(item);
}
}
GroupRolesSource.Clear();
}
public GroupRolesRequirement(GroupRoles role)
{
Roles = role;
}
public async Task <GroupPermissionOutcome> PostRevokeRole(int userId, int groupId, GroupRoles role, int authorisedByUserID)
{
PostRevokeRoleRequest postRevokeRoleRequest = new PostRevokeRoleRequest()
{
AuthorisedByUserID = authorisedByUserID,
GroupID = groupId,
UserID = userId,
Role = new RoleRequest()
{
GroupRole = role
}
};
var response = await PostAsync <BaseRequestHelpResponse <PostAssignRoleResponse> >($"/api/PostRevokeRole", postRevokeRoleRequest);
if (response.HasContent && response.IsSuccessful)
{
return(response.Content.Outcome);
}
throw new Exception("Bad response from PostRevokeRole");
}
public async Task WhenCreatedByUserIsSameAsVolunteerUserID_ReturnsSuccess(GroupRoles role)
{
_updateJobStatusOutcome = UpdateJobStatusOutcome.Success;
_request = new PutUpdateJobStatusToInProgressRequest
{
CreatedByUserID = 1,
JobID = 1,
VolunteerUserID = 1
};
_getUserGroupsReponse = new GetUserGroupsResponse()
{
Groups = new List <int>()
{
1
}
};
_getGroupsForJobResponse = new List <int>()
{
1
};
_referringGroupId = 1;
Dictionary <int, List <int> > roles = new Dictionary <int, List <int> >();
roles.Add(1, new List <int>()
{
(int)role
});
_getJobDetailsResponse = new GetJobDetailsResponse()
{
JobSummary = new JobSummary()
{
JobID = 1,
SupportActivity = SupportActivities.Shopping
}
};
_getGroupMemberResponse = new GetGroupMemberResponse()
{
UserInGroup = new UserInGroup()
{
GroupId = 1,
UserId = 1,
GroupRoles = new List <GroupRoles>()
{
GroupRoles.Member
},
ValidCredentials = new List <int>()
{
-1
}
}
};
_getGroupActivityCredentialsResponse = new GetGroupActivityCredentialsResponse()
{
CredentialSets = new List <List <int> > {
new List <int>()
{
-1
}
}
};
_hasPermission = true;
var response = await _classUnderTest.Handle(_request, CancellationToken.None);
_repository.Verify(x => x.JobIsInProgressWithSameVolunteerUserId(It.IsAny <int>(), It.IsAny <int?>()), Times.Once);
_groupService.Verify(x => x.GetUserGroups(It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
_groupService.Verify(x => x.GetGroupMember(It.IsAny <GetGroupMemberRequest>()), Times.Once);
_groupService.Verify(x => x.GetGroupActivityCredentials(It.IsAny <GetGroupActivityCredentialsRequest>()), Times.Once);
_repository.Verify(x => x.GetGroupsForJobAsync(It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
_repository.Verify(x => x.GetReferringGroupIDForJobAsync(It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
_groupService.Verify(x => x.GetGroupMember(It.IsAny <GetGroupMemberRequest>()), Times.Once);
_groupService.Verify(x => x.GetGroupActivityCredentials(It.IsAny <GetGroupActivityCredentialsRequest>()), Times.Once);
_repository.Verify(x => x.UpdateJobStatusInProgressAsync(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
_communicationService.Verify(x => x.RequestCommunication(It.IsAny <RequestCommunicationRequest>(), It.IsAny <CancellationToken>()), Times.Once);
Assert.AreEqual(UpdateJobStatusOutcome.Success, response.Outcome);
}
public bool IsGroupRole(string roleName)
{
return(GroupRoles.Contains(roleName));
}
private bool HasRole(GroupRoles roles, GroupRoles role) => (roles & role) == role;
public async Task <GroupPermissionOutcome> PostRevokeRole(int userId, int groupId, GroupRoles role, int authorisedByUserID, CancellationToken cancellationToken)
{
var result = await _groupRepository.PostRevokeRole(userId, groupId, role, authorisedByUserID);
if (result == GroupPermissionOutcome.Success)
{
// Cannot do this due to circular dependency
//_requestService.TriggerCacheRefresh(userId, cancellationToken);
await _memDistCache.RefreshDataAsync(async (cancellationToken) =>
{
return(await GetUserRoles(userId, cancellationToken));
}, $"{CACHE_KEY_PREFIX}-user-roles-user-{userId}", cancellationToken);
}
return(result);
}
public async Task WhenAccessRestrictedByRole_ReturnsCorrectResponse(int createdByUserId, GroupRoles role, Fulfillable fulfillable, int timesGroupMemberCalled)
{
requestId = 1;
_validPostcode = true;
_emailSent = true;
int referringGroupId = -20;
Guid guid = Guid.NewGuid();
var request = new PostNewRequestForHelpRequest
{
HelpRequest = new HelpRequest
{
RequestorType = RequestorType.Myself,
Recipient = new RequestPersonalDetails
{
Address = new Address
{
Postcode = "test",
}
},
VolunteerUserId = 1,
CreatedByUserId = createdByUserId,
ReferringGroupId = referringGroupId
},
NewJobsRequest = new NewJobsRequest
{
Jobs = new List <Job>
{
new Job
{
Guid = guid,
HealthCritical = true,
DueDays = 5,
SupportActivity = SupportActivities.Shopping
}
}
}
};
_formVariantResponse = new GetRequestHelpFormVariantResponse()
{
AccessRestrictedByRole = true,
RequestorDefinedByGroup = true,
RequestHelpFormVariant = RequestHelpFormVariant.Default,
TargetGroups = TargetGroups.GenericGroup,
RequestorPersonalDetails = new RequestPersonalDetails()
{
FirstName = "First",
LastName = "Last",
EmailAddress = "Email",
MobileNumber = "Mobile",
OtherNumber = "Other"
},
SuppressRecipientPersonalDetails = true
};
_getGroupMemberResponse = new GetGroupMemberResponse()
{
UserInGroup = new UserInGroup()
{
UserId = 1,
GroupId = 1,
GroupRoles = new List <GroupRoles>()
{
role
}
}
};
_getGroupResponse = new GetGroupResponse()
{
Group = new Group()
{
GroupId = referringGroupId
}
};
_getUserRolesResponse = new GetUserRolesResponse()
{
UserGroupRoles = new Dictionary <int, List <int> >()
};
_getNewRequestActionsResponse = new GetNewRequestActionsResponse()
{
Actions = new Dictionary <Guid, TaskAction>(), RequestTaskActions = new Dictionary <NewTaskAction, List <int> >()
};
_getNewRequestActionsResponse.Actions.Add(guid, new TaskAction()
{
TaskActions = new Dictionary <NewTaskAction, List <int> >()
});
_getNewRequestActionsResponse.Actions[guid].TaskActions.Add(NewTaskAction.AssignToVolunteer, new List <int>()
{
1
});
var response = await _classUnderTest.Handle(request, new CancellationToken());
_groupService.Verify(x => x.GetRequestHelpFormVariant(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <CancellationToken>()), Times.Once);
_groupService.Verify(x => x.GetGroupMember(It.IsAny <GetGroupMemberRequest>()), Times.Exactly(timesGroupMemberCalled));
Assert.AreEqual(fulfillable, response.Fulfillable);
}
private bool GetUserHasRole(List <UserGroup> userGroupRoles, int groupId, GroupRoles role)
{
return(userGroupRoles?.Where(g => g.GroupId == groupId).FirstOrDefault()?.UserRoles.Contains(role) ?? false);
}
