public async Task <Result <GroupModel> > Handle(UpdateGroup request, CancellationToken cancellationToken)
{
var isValid = await _validator.IsValidAsync(request);
if (!isValid)
{
return(Result.Failure <GroupModel>("Validation failed"));
}
var user = await _context.Users.FirstAsync(u => u.Sub == request.UserSub, cancellationToken);
var group = await _context
.Groups
.Include(g => g.Admin)
.FirstAsync(g => g.AdminId == user.Id && g.Id == request.GroupId, cancellationToken);
group.Name = request.Group.Name;
await _context.SaveChangesAsync(cancellationToken);
return(new GroupModel
{
Id = group.Id,
Name = group.Name,
NumberOfMembers = group.GroupMembers.Count,
AdminId = group.AdminId,
AdminFirstName = group.Admin.FirstName,
AdminLastName = group.Admin.LastName
});
}
public bool UpdateGroup(string groupId, UpdateGroup group)
{
var request = BuildRequestAuthorization(PATCH_GROUP, Method.PATCH);
request.AddParameter("groupId", groupId, ParameterType.UrlSegment);
request.AddJsonBody(group);
var response = WebClient.Execute(request);
if (response.ResponseStatus == ResponseStatus.Completed && response.StatusCode == System.Net.HttpStatusCode.NoContent)
{
return(true);
}
if (!string.IsNullOrWhiteSpace(response.ErrorMessage))
{
throw new Exception(response.ErrorMessage);
}
if (!string.IsNullOrWhiteSpace(response.StatusDescription) && !string.IsNullOrWhiteSpace(response.Content))
{
throw new Exception($"{response.StatusDescription} || {response.Content}");
}
return(false);
}
public IHttpActionResult UpdateGroup([FromUri] int groupId, [FromBody] UpdateGroup data)
{
Group group = _repo.GetGroup(groupId);
if (group == null)
{
return(NotFound());
}
if (group.Owner_Id == RequestContext.Principal.Identity.GetUserId())
{
bool result = _repo.AddStationToGroup(group, data.stationsToAdd);
if (!result)
{
return(NotFound());
}
result = _repo.RemoveStationFromGroup(group, data.stationsToRemove);
if (!result)
{
return(NotFound());
}
}
else
{
return(Unauthorized());
}
return(Ok(_repo.GetGroup(group.Id)));;
}
public IActionResult UpdateGroup(int id)
{
var group = new UpdateGroup();
var url = $"{Common.Common.ApiUrl}/group/getlistgroupbyid/{id}";
HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
httpWebRequest.Method = "GET";
var response = httpWebRequest.GetResponse();
string responseData;
Stream responseStream = response.GetResponseStream();
try
{
StreamReader streamReader = new StreamReader(responseStream);
try
{
responseData = streamReader.ReadToEnd();
}
finally
{
((IDisposable)streamReader).Dispose();
}
}
finally
{
((IDisposable)responseStream).Dispose();
}
group = JsonConvert.DeserializeObject <UpdateGroup>(responseData);
TempData["Done"] = null;
TempData["Fail"] = null;
return(View(group));
}
public Group Handle(UpdateGroup request)
{
var group = _dataStorage.Find(request.Key);
group.Name = request.Name;
return(_dataStorage.Update(group));
}
public Group UpdateGroup(int key, [FromBody] UpdateGroup request)
{
if (key != request.Key)
{
throw new ArgumentException("request.Key is invalid and doesn't match to key");
}
return(_dispatcher.Process(request));
}
public async Task Handle(UpdateGroup message)
{
var group = await repository.Get(message.Id);
if (!string.Equals(group.Name, message.Name, StringComparison.InvariantCulture))
{
group.SetName(message.Name);
}
await repository.Save(group);
}
public async Task <ActionResult <GroupModel> > UpdateGroupAsync([FromRoute] Guid groupId, [FromBody] GroupRequest group)
{
var sub = User.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
var command = new UpdateGroup(sub, groupId, group);
var result = await _mediator.Send(command);
if (result.IsFailure)
{
return(BadRequest());
}
return(Ok(result.Value));
}
/// <summary>
/// Update information for a single member group.
/// </summary>
/// <param name="memberGroupId">The Member Group Id to be updated.</param>
/// <param name="group">The Group to be updated.</param>
/// <returns>True if the update was successful</returns>
/// <remarks>Http404 if the group does not exist.</remarks>
public bool UpdateGroup(string memberGroupId, UpdateGroup group)
{
var request = new RestRequest(Method.PUT);
request.Resource = "/{accountId}/groups/{memberIdGroup}";
request.AddUrlSegment("memberIdGroup", memberGroupId);
request.RequestFormat = DataFormat.Json;
request.JsonSerializer = new EmmaJsonSerializer();
request.AddBody(group);
return(Execute <bool>(request));
}
public IApiResult Update(UpdateGroup operation)
{
var result = operation.ExecuteAsync().Result;
if (result is ValidationsOutput)
{
return(new ApiResult <List <ValidationItem> >()
{
Data = ((ValidationsOutput)result).Errors
});
}
else
{
return(new ApiResult <object>()
{
Status = ApiResult <object> .ApiStatus.Success
});
}
}
/// <summary>
/// Update the specified group.
/// </summary>
/// <param name="request">Request.</param>
/// <returns>the group</returns>
public object Put(UpdateGroup request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.AdminOnly);
WebGroup result;
try {
context.Open();
context.LogInfo(this, string.Format("/group PUT Id='{0}'", request.Id));
Group grp = (request.Id == 0 ? null : Group.FromId(context, request.Id));
grp = request.ToEntity(context, grp);
grp.Store();
context.LogDebug(this, string.Format("Group {0} updated by user {1}", grp.Name, User.FromId(context, context.UserId).Username));
result = new WebGroup(grp);
context.Close();
} catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(result);
}
public IActionResult UpdateGroup(UpdateGroup model)
{
int result = 0;
var url = $"{Common.Common.ApiUrl}/group/updategroup";
HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = "PUT";
using (var streamWrite = new StreamWriter(httpWebRequest.GetRequestStream()))
{
var json = JsonConvert.SerializeObject(model);
streamWrite.Write(json);
}
var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var resResult = streamReader.ReadToEnd();
result = int.Parse(resResult);
}
if (result > 0)
{
TempData["Done"] = "Group edit successfully";
ModelState.Clear();
}
else
{
TempData["Fail"] = "Group edit fail";
}
return(View(new UpdateGroup()
{
}));
}
/// <summary>
/// Update information for a single member group.
/// </summary>
/// <param name="memberGroupId">The Member Group Id to be updated.</param>
/// <param name="group">The Group to be updated.</param>
/// <returns>True if the update was successful</returns>
/// <remarks>Http404 if the group does not exist.</remarks>
public bool UpdateGroup(string memberGroupId, UpdateGroup group)
{
var request = new RestRequest(Method.PUT);
request.Resource = "/{accountId}/groups/{memberIdGroup}";
request.AddUrlSegment("memberIdGroup", memberGroupId);
request.RequestFormat = DataFormat.Json;
request.JsonSerializer = new EmmaJsonSerializer();
request.AddBody(group);
return Execute<bool>(request);
}
public async Task UpdateGroup(int groupId, UpdateGroup model)
{
await _httpService.Put($"/api/Group/{groupId}", model);
}
public async Task <IActionResult> UpdateGroup(int groupId, UpdateGroup updateGroup)
{
updateGroup.GroupId = groupId;
return(Ok(await _mediator.Send(updateGroup)));
}
public async Task Create([FromRoute] string groupId, [FromBody] UpdateGroup body)
{
await _alfrescoHttpClient.UpdateGroup(groupId, new GroupBodyUpdate { DisplayName = body.Name });
}
public override void OnExecute(CommandEventArgs e)
{
IAnkhServiceEvents ci = e.GetService <IAnkhServiceEvents>();
if (ci != null)
{
ci.OnLastChanged(new LastChangedEventArgs(null, null));
}
SvnRevision rev;
bool allowUnversionedObstructions = false;
bool updateExternals = true;
bool setDepthInfinity = true;
IAnkhSolutionSettings settings = e.GetService <IAnkhSolutionSettings>();
ISvnStatusCache cache = e.GetService <ISvnStatusCache>();
IProjectFileMapper mapper = e.GetService <IProjectFileMapper>();
Uri reposRoot = null;
if (IsHeadCommand(e.Command) || e.DontPrompt)
{
rev = SvnRevision.Head;
}
else if (IsSolutionCommand(e.Command))
{
SvnItem projectItem = settings.ProjectRootSvnItem;
Debug.Assert(projectItem != null, "Has item");
using (UpdateDialog ud = new UpdateDialog())
{
ud.ItemToUpdate = projectItem;
ud.Revision = SvnRevision.Head;
if (ud.ShowDialog(e.Context) != DialogResult.OK)
{
return;
}
rev = ud.Revision;
allowUnversionedObstructions = ud.AllowUnversionedObstructions;
updateExternals = ud.UpdateExternals;
setDepthInfinity = ud.SetDepthInfinty;
}
}
else if (IsFolderCommand(e.Command))
{
SvnItem dirItem = EnumTools.GetFirst(e.Selection.GetSelectedSvnItems(false));
Debug.Assert(dirItem != null && dirItem.IsDirectory && dirItem.IsVersioned);
using (UpdateDialog ud = new UpdateDialog())
{
ud.Text = CommandStrings.UpdateFolder;
ud.FolderLabelText = CommandStrings.UpdateFolderLabel;
ud.ItemToUpdate = dirItem;
ud.Revision = SvnRevision.Head;
if (ud.ShowDialog(e.Context) != DialogResult.OK)
{
return;
}
rev = ud.Revision;
allowUnversionedObstructions = ud.AllowUnversionedObstructions;
updateExternals = ud.UpdateExternals;
setDepthInfinity = ud.SetDepthInfinty;
}
}
else
{
// We checked there was only a single repository to select a revision
// from in OnUpdate, so we can suffice with only calculate the path
SvnItem si = null;
SvnOrigin origin = null;
foreach (SccProject p in GetSelectedProjects(e))
{
ISccProjectInfo pi = mapper.GetProjectInfo(p);
if (pi == null || pi.ProjectDirectory == null)
{
continue;
}
SvnItem item = cache[pi.ProjectDirectory];
if (!item.IsVersioned)
{
continue;
}
if (si == null && origin == null)
{
si = item;
origin = new SvnOrigin(item);
reposRoot = item.WorkingCopy.RepositoryRoot;
}
else
{
si = null;
string urlPath1 = origin.Uri.AbsolutePath;
string urlPath2 = item.Uri.AbsolutePath;
int i = 0;
while (i < urlPath1.Length && i < urlPath2.Length &&
urlPath1[i] == urlPath2[i])
{
i++;
}
while (i > 0 && urlPath1[i - 1] != '/')
{
i--;
}
origin = new SvnOrigin(new Uri(origin.Uri, urlPath1.Substring(0, i)), origin.RepositoryRoot);
}
}
Debug.Assert(origin != null);
using (UpdateDialog ud = new UpdateDialog())
{
ud.Text = CommandStrings.UpdateProject;
if (si != null)
{
ud.ItemToUpdate = si;
}
else
{
ud.SvnOrigin = origin;
ud.SetMultiple(true);
}
ud.Revision = SvnRevision.Head;
if (ud.ShowDialog(e.Context) != DialogResult.OK)
{
return;
}
rev = ud.Revision;
allowUnversionedObstructions = ud.AllowUnversionedObstructions;
updateExternals = ud.UpdateExternals;
setDepthInfinity = ud.SetDepthInfinty;
}
}
Dictionary <string, SvnItem> itemsToUpdate = new Dictionary <string, SvnItem>(StringComparer.OrdinalIgnoreCase);
SortedList <string, UpdateGroup> groups = new SortedList <string, UpdateGroup>(StringComparer.OrdinalIgnoreCase);
// Get a list of all documents below the specified paths that are open in editors inside VS
HybridCollection <string> lockPaths = new HybridCollection <string>(StringComparer.OrdinalIgnoreCase);
IAnkhOpenDocumentTracker documentTracker = e.GetService <IAnkhOpenDocumentTracker>();
foreach (SvnItem item in GetAllUpdateRoots(e))
{
// GetAllUpdateRoots can (and probably will) return duplicates!
if (itemsToUpdate.ContainsKey(item.FullPath) || !item.IsVersioned)
{
continue;
}
SvnWorkingCopy wc = item.WorkingCopy;
if (!IsHeadCommand(e.Command) && reposRoot != null)
{
// Specific revisions are only valid on a single repository!
if (wc != null && wc.RepositoryRoot != reposRoot)
{
continue;
}
}
UpdateGroup group;
if (!groups.TryGetValue(wc.FullPath, out group))
{
group = new UpdateGroup(wc.FullPath);
groups.Add(wc.FullPath, group);
}
group.Nodes.Add(item.FullPath);
itemsToUpdate.Add(item.FullPath, item);
foreach (string file in documentTracker.GetDocumentsBelow(item.FullPath))
{
if (!lockPaths.Contains(file))
{
lockPaths.Add(file);
}
}
}
documentTracker.SaveDocuments(lockPaths); // Make sure all files are saved before updating/merging!
using (DocumentLock lck = documentTracker.LockDocuments(lockPaths, DocumentLockType.NoReload))
using (lck.MonitorChangesForReload())
{
SvnUpdateResult updateResult = null;
ProgressRunnerArgs pa = new ProgressRunnerArgs();
pa.CreateLog = true;
string title;
if (IsSolutionCommand(e.Command))
{
title = CommandStrings.UpdatingSolution;
}
else if (IsFolderCommand(e.Command))
{
title = CommandStrings.UpdatingFolder;
}
else
{
title = CommandStrings.UpdatingProject;
}
e.GetService <IProgressRunner>().RunModal(title, pa,
delegate(object sender, ProgressWorkerArgs a)
{
PerformUpdate(e, a, rev, allowUnversionedObstructions, updateExternals, setDepthInfinity, groups.Values, out updateResult);
});
if (ci != null && updateResult != null && IsSolutionCommand(e.Command))
{
ci.OnLastChanged(new LastChangedEventArgs(CommandStrings.UpdatedToTitle, updateResult.Revision.ToString()));
}
}
}
public async Task <ResponseMessage <Group> > UpdateGroupAsync(string objectId, UpdateGroup group)
{
var json = JsonConvert.SerializeObject(group, jsonSerializerSettings);
var responseMessage = new ResponseMessage <Group>();
try
{
var result = await b2cClient.UpdateGroupAsync(objectId, json);
responseMessage.Data = JsonConvert.DeserializeObject <Group>(result);
responseMessage.HttpStatusCode = HttpStatusCode.OK;
}
catch (HttpClientException hce)
{
responseMessage.HttpStatusCode = hce.StatusCode;
responseMessage.ErrorMessage = hce.Message;
}
return(responseMessage);
}
