public IActionResult UpdateGroup([FromBody] UpdateGroupModel model)
{
var userId = this.GetUserId();
this.groupService.UpdateGroup(model, userId);
return(this.NoContent());
}
public async Task <Result> Update(string groupId, UpdateGroupModel updateGroupModel)
{
ValidationResult validationResult = _updateGroupModelValidator.Validate(updateGroupModel);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid {typeof(UpdateGroupModel).Name} model");
return(Result.Fail(validationResult.ToResultError()));
}
Result <GroupEntity> getGroupResult = await _groupStore.SingleOrDefault(groupId);
if (getGroupResult.Failure)
{
return(Result.Fail(getGroupResult));
}
GroupEntity groupEntity = getGroupResult.Value;
string guid = Guid.NewGuid().ToString();
groupEntity.Name = updateGroupModel.GroupName;
bool updateResult = await _groupDAO.Update(groupEntity);
if (!updateResult)
{
_logger.LogError($"Failed to update group. GroupId {groupId}");
return(Result.Fail(FAILED_TO_UPDATE_USER));
}
return(Result.Ok());
}
public ActionResult Update(UpdateGroupModel model)
{
var groupManager = new GroupManager();
try
{
if (!ModelState.IsValid)
{
return(PartialView("_Update", model));
}
var group = groupManager.FindByIdAsync(model.Id).Result;
if (group == null)
{
return(PartialView("_Update", model));
}
group.Name = model.Name;
group.Description = model.Description;
groupManager.UpdateAsync(group);
return(Json(new { success = true }));
}
finally
{
groupManager.Dispose();
}
}
// All in one, becouse I work on the same attachment
public void GroupTest()
{
string groupName = "TestGroup";
var groupModel = new PostGroupModel()
{
Name = groupName,
Users = new string[] { this.userId.ToString() },
};
this.groupService.AddGroup(groupModel, this.userId);
var groups = this.groupService.GetAllGroups(this.userId);
var group = groups.Where(g => g.Name == groupName).FirstOrDefault();
Assert.NotNull(group);
string editedName = groupName + "Edited";
var updateGroupModel = new UpdateGroupModel()
{
Id = group.Id.ToString(),
Name = editedName,
Users = Array.Empty <string>(),
};
this.groupService.UpdateGroup(updateGroupModel, this.userId);
groups = this.groupService.GetAllGroups(this.userId);
group = groups.Where(g => g.Name == editedName).FirstOrDefault();
Assert.NotNull(group);
Assert.True(group.Name == editedName);
Assert.True(group.UserGroups.Count == 0);
}
public void UpdateGroup(UpdateGroupModel model, Guid ownerId)
{
ICollection <UserGroup> userGroups = new HashSet <UserGroup>();
Guid groupId = Guid.Parse(model.Id);
foreach (string item in model.Users)
{
userGroups.Add(new UserGroup()
{
UserId = Guid.Parse(item), GroupId = groupId
});
}
Group group = new Group()
{
Id = groupId,
Name = model.Name,
GroupOwnerId = ownerId,
UserGroups = userGroups,
};
//Update(group);
var groups = this.context.Groups.Where(x => x.GroupOwnerId == ownerId && x.Id == groupId)
.Include(g => g.UserGroups);
var groupToUpdate = groups.FirstOrDefault();
groupToUpdate.Name = model.Name;
groupToUpdate.UserGroups = userGroups;
this.context.SaveChanges();
}
public async Task <IActionResult> Delete([FromRoute] string groupId, [FromBody] UpdateGroupModel updateGroupModel)
{
if (!_identityUIEndpoints.CanRemoveGroup)
{
return(NotFound());
}
Result result = await _groupService.RemoveAsync(groupId);
return(result.ToApiResult());
}
public async Task <IActionResult> Update([FromRoute] string groupId, [FromBody] UpdateGroupModel updateGroupModel)
{
if (!_identityUIEndpoints.CanChangeGroupName)
{
return(NotFound());
}
Result result = await _groupService.Update(groupId, updateGroupModel);
return(result.ToApiResult());
}
/// <summary>
/// ToDo: Documentation
/// </summary>
/// <param name="groupId"></param>
/// <returns></returns>
public ActionResult Update(long groupId)
{
var groupManager = new GroupManager();
try
{
var group = groupManager.FindByIdAsync(groupId).Result;
return(PartialView("_Update", UpdateGroupModel.Convert(group)));
}
finally
{
groupManager.Dispose();
}
}
public IHttpActionResult UpdateDomain(long groupId, UpdateGroupModel group)
{
if (groupId == 0 || group.groupName.Equals(null) || group.groupName == string.Empty)
{
return(BadRequest("enter a value for group name"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
long output = Storage.updateGroup(groupId, group.groupName, group.desc, group.userNames);
return(new StatusCodeResult(HttpStatusCode.NoContent, this));
}//UpdateDomain
public static async Task <long> UpdateAsync(long groupId, string groupName, string desc, List <string> userNames)
{
UpdateGroupModel fromBodyGroup = new UpdateGroupModel();
fromBodyGroup.groupId = groupId;
fromBodyGroup.groupName = groupName;
fromBodyGroup.desc = desc;
fromBodyGroup.userNames = userNames;
long output = -1;
HttpResponseMessage response = await MyClient.client.PostAsJsonAsync(string.Format("security/group/{0}", groupId), fromBodyGroup);
if (response.IsSuccessStatusCode)
{
output = await response.Content.ReadAsAsync <long>();
}
return(output);
}
public IActionResult Update(int id, [FromBody] UpdateGroupModel model)
{
// map model to entity and set id
var group = _mapper.Map <Group>(model);
group.Id = id;
try
{
// update group
_groupService.Update(group, LoggedInUser);
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public ActionResult Update(UpdateGroupModel model)
{
var groupManager = new GroupManager();
try
{
// check wheter model is valid or not
if (!ModelState.IsValid)
{
return(PartialView("_Update", model));
}
// check if a group with the incoming id exist
var group = groupManager.FindByIdAsync(model.Id).Result;
if (group == null)
{
return(PartialView("_Update", model));
}
// check group name exist
if (groupManager.FindByNameAsync(model.Name).Result != null &&
!groupManager.FindByNameAsync(model.Name).Result.Id.Equals(model.Id))
{
ModelState.AddModelError("Name", "The name exists already.");
if (!ModelState.IsValid)
{
return(PartialView("_Update", model));
}
}
group.Name = model.Name;
group.DisplayName = group.Name;
group.Description = model.Description;
groupManager.UpdateAsync(group);
return(Json(new { success = true }));
}
finally
{
groupManager.Dispose();
}
}
public async Task Update(UpdateGroupModel model)
{
var group = await groupsRepository.GetQuery().FirstAsync(x => x.Id == model.Id);
if (group != null)
{
group.Name = model.Name;
foreach (var user in await usersRepository.GetQuery().ToListAsync())
{
user.GroupId = null;
if (model.Users != null && model.Users.Contains(user.Id))
{
user.GroupId = group.Id;
}
}
await dataContext.SaveChangesAsync();
}
}
public ActionResult UpdateGroupPermission([FromBody] UpdateGroupModel model)
{
var grp = mapper.GetGroupByGroupName(model.GroupName);
foreach (ModulePermission module in grp.ModulePermissions)
{
if (module.Name == model.ModuleName)
{
module.UserRight = model.UserRight;
break;
}
}
var result = mapper.UpdateGroupPermission(grp);
if (result.Result.IsAcknowledged)
{
return(Json(new List <GroupModel>()
{
mapper.GetGroupByGroupName(model.GroupName)
}));
}
return(Json(result.Status));
}
public async Task <ActionResult> Update(UpdateGroupModel model)
{
await groupService.Update(model);
return(Ok());
}
