public async Task UpdateGroupCommandHandler_ShouldUpdateGroup()
{
// Arrange
UpdateGroupCommand request = new UpdateGroupCommand
{
GroupId = 1,
Name = "Some updated name",
Description = "Some updated description"
};
IEnumerable <Group> expectedGroup = new[]
{
new Group {
GroupId = 1
}
};
IQueryable <Group> queryableMock = expectedGroup
.AsQueryable()
.BuildMock()
.Object;
_unitOfWork
.Setup(m => m.Groups.GetById(request.GroupId))
.Returns(queryableMock);
UpdateGroupCommand.Handler handler = new UpdateGroupCommand.Handler(_unitOfWork.Object);
// Act
await handler.Handle(request);
// Assert
_unitOfWork.Verify(m => m.Groups.Update(It.IsAny <Group>()), Times.Once);
_unitOfWork.Verify(m => m.CommitAsync(It.IsAny <CancellationToken>()), Times.Once);
}
public void UpdateGroup(UpdateGroupCommand command)
{
var entity = this
.GetValidGroups(command.OrganizationId)
.FirstOrDefault(g => g.GroupEntityId.Equals(command.GroupId));
var now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
entity.UpdatedAt = now;
if (!string.IsNullOrWhiteSpace(command.Name))
{
entity.Name = command.Name;
}
if (!string.IsNullOrWhiteSpace(command.Description))
{
entity.Description = command.Description;
}
if (command.ParentGroupId > 0 || command.ParentGroupId == null)
{
entity.ParentGroupId = command.ParentGroupId;
}
context.Groups.Update(entity);
this.context.SaveChanges();
}
public async Task <ActionResult> UpdateGroup([FromRoute] int groupId, [FromBody] UpdateGroupBody model, CancellationToken cancellationToken = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
GroupExistsQuery existsQuery = new GroupExistsQuery {
GroupId = groupId
};
bool exists = await _mediator.Send(existsQuery, cancellationToken);
if (!exists)
{
return(NotFound(new ErrorResource
{
StatusCode = StatusCodes.Status404NotFound,
Message = $"Group with ID '{groupId}' does not exist"
}));
}
UpdateGroupCommand updateCommand = new UpdateGroupCommand
{
GroupId = groupId,
Name = model.Name,
Description = model.Description
};
await _mediator.Send(updateCommand, cancellationToken);
return(NoContent());
}
public Result <EmptyResult> UpdateGroup(UpdateGroupCommand command)
{
if (command.OrganizationId <= 0)
{
return(new Result <EmptyResult>(GroupServiceErrors.InvalidUpdateGroupDataError(nameof(command.OrganizationId))));
}
if (command.GroupId <= 0)
{
return(new Result <EmptyResult>(GroupServiceErrors.InvalidUpdateGroupDataError(nameof(command.GroupId))));
}
if (!groupRepository.GroupExists(command.GroupId, command.OrganizationId))
{
return(new Result <EmptyResult>(GroupServiceErrors.GroupNotFoundError()));
}
if (groupRepository.GroupNameExists(command.GroupId, command.Name, command.OrganizationId))
{
return(new Result <EmptyResult>(GroupServiceErrors.GroupAlreadyExistsError()));
}
groupRepository.UpdateGroup(command);
return(new Result <EmptyResult>());
}
public async Task <GroupResponseModel> PutGroup(
int groupId,
[FromForm] GroupRequestModel model,
CancellationToken cancellationToken
)
{
cancellationToken.ThrowIfCancellationRequested();
var command = new UpdateGroupCommand(
groupId,
model.Name,
model.FacultyId,
model.CourseNumber
);
await _mediator.Send(command, cancellationToken);
var query = new FindGroupByIdQuery(groupId);
var group = await _mediator.Send(query, cancellationToken);
var response = _mapper.Map <GroupResponseModel>(group);
return(response);
}
public void UpdateGroup(Guid id, string name, string description, bool isDisabled, string externalGroupName)
{
userContext.CheckPermission(Permissions.UserMaintenance);
var command = new UpdateGroupCommand(id, name, description, isDisabled, externalGroupName);
commandBus.Value.Send(Envelope.Create(command));
}
public void TestInitialize()
{
var commandFactory = AssemblyConfiguration.Kernel.Get <CommandFactory>();
var queryFactory = AssemblyConfiguration.Kernel.Get <QueryFactory>();
_mapper = AssemblyConfiguration.Kernel.Get <IMapper>();
_createGroupCommand = commandFactory.GetInstance <CreateGroupCommand>();
_getGroupQuery = queryFactory.GetInstance <GetGroupsQuery>();
_sut = commandFactory.GetInstance <UpdateGroupCommand>();
}
public void ShouldRequireMinimumFields()
{
var command = new UpdateGroupCommand
{
Capacity = 0
};
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <ValidationException>();
}
public async Task <IActionResult> Update([FromBody] UpdateGroupCommand updateGroup)
{
var result = await Mediator.Send(updateGroup);
if (result.Success)
{
return(Ok(result.Message));
}
return(BadRequest(result.Message));
}
public async Task <IActionResult> Update(
[FromRoute] int id,
[FromBody] UpdateGroupCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
return(Ok(await Mediator.Send(command)));
}
public async Task <ActionResult> Update(int id, UpdateGroupCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
await Mediator.Send(command);
return(NoContent());
}
void AndGivenRequest()
{
var content = new UpdateGroupCommand
{
Id = 1,
Name = "group2",
LanguageFront = 2,
LanguageBack = 1
};
Request.Content = new StringContent(JsonSerializer.Serialize(content), Encoding.UTF8, "application/json");
}
public async Task <IActionResult> PutGroup(Guid id, GroupUpdateModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var command = new UpdateGroupCommand
{
Id = id,
Input = model
};
return(await ExecuteRequest(command).ConfigureAwait(false));
}
public CommandResult Update(Guid id, [FromBody] UpdateGroupCommand command)
{
command.setGroupId(id);
command.setRequestHost(HttpContext.Request.Host.ToString());
_loggingService.Log(this.GetType(), ELogType.Input, ELogLevel.Info, new { Group = this.User.Identity.Name, Path = this.Request.Path, Method = this.Request.Method });
CommandResult result = (CommandResult)_groupHandler.Handle(command);
_loggingService.Log(this.GetType(), ELogType.Output, ELogLevel.Info, new { Group = this.User.Identity.Name, Path = this.Request.Path, Method = this.Request.Method, Code = this.Response.StatusCode });
HttpContext.Response.StatusCode = result.Code;
return(result);
}
public IActionResult Update([FromBody] UpdateGroupCommand command)
{
if (command == null)
{
return(BadRequest());
}
var result = _mediator.Send(command).Result;
if (!string.IsNullOrEmpty(result.ErrorMessage))
{
return(StatusCode(200, result));
}
return(Ok(result));
}
public ICommandResult Handle(UpdateGroupCommand command)
{
ICommandResult result = new CommandResult();
_loggingService.Log(this.GetType(), ELogType.Neutral, ELogLevel.Debug, new { command.Id, command.Name, command.Description, command.RequestHost }, "GroupCommandHandler.Handle(Update)");
try
{
Group group = new Group(command.Name, command.Description);
if (group.Valid)
{
if (_groupRepository.CheckExists(command.Id))
{
if (!_groupRepository.CheckExists(group.Name))
{
if (_groupRepository.Update(command.Id, group))
{
result = new CommandResult(200);
}
}
else if (_groupRepository.Valid)
{
result = new CommandResult(400, new Notification("Name", "Already in Use"));
}
}
else if (_groupRepository.Valid)
{
result = new CommandResult(400, new Notification("Group", "Could not be found"));
}
}
else
{
result = new NewGroupCommandResult(400, group.Notifications);
}
}
catch (Exception e)
{
_loggingService.Log(this.GetType(), ELogType.Neutral, ELogLevel.Error, new { command.Id, command.Name, command.Description, command.RequestHost }, e);
}
return(result);
}
public IHttpActionResult UpdateGroup(Guid groupId, UpdateGroupCommand command)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
if (groupId == Guid.Empty)
{
throw new ArgumentException("groupId must be defined.");
}
if (string.IsNullOrWhiteSpace(command.Name))
{
throw new ArgumentException("Group name must be defined.");
}
identityManagementService.UpdateGroup(groupId, command.Name, command.Description, command.IsDisabled, command.ExternalGroupName);
return(Ok());
}
public async Task ThrowNotFoundException_WhenGroupIsNotExists()
{
var request = new UpdateGroupCommand
{
Id = 100,
Name = "Test Group Edited",
SpecialityId = 1,
StudentsCount = 10,
EducationalDegreeId = 1,
Year = 1
};
var handler = new UpdateGroupCommandHandler(Context);
var exception = Assert.ThrowsAsync <NotFoundException>(async() => await handler.Handle(request, CancellationToken.None));
Assert.AreEqual(exception.Message, ExceptionMessagesBuilderHelper.GetNotFoundExceptionMessage(nameof(Group), request.Id));
}
public async Task ThrowDuplicateException_WhenGroupNameExists()
{
var request = new UpdateGroupCommand
{
Id = 1,
Name = "Group 2",
StudentsCount = 10,
SpecialityId = 1,
Year = 1,
EducationalDegreeId = 1
};
var handler = new UpdateGroupCommandHandler(Context);
var exception = Assert.ThrowsAsync <DuplicateException>(async() => await handler.Handle(request, CancellationToken.None));
Assert.AreEqual(exception.Message, ExceptionMessagesBuilderHelper.GetDuplicateExceptionMessage(nameof(Group), "Name", request.Name));
}
public async Task ShouldUpdateGroup()
{
var group = await AddGroupAsync();
var command = new UpdateGroupCommand
{
GroupId = group.Id,
Capacity = 10,
Name = "Den Hague"
};
await SendAsync(command);
var list = await FindAsync <Group>(group.Id);
list.Should().NotBeNull();
list.Name.Should().Be(command.Name);
list.Capacity.Should().Be(command.Capacity);
}
public void When_UpdateGroupName_Expect_GroupUpdate()
{
var errorMessage = string.Empty;
var guid = Guid.NewGuid().ToString();
var newGroupCommand = new CreateGroupCommand()
{
Group = new Group()
{
Name = guid, CurrentCapacity = 100M
}
};
var actionResult = _groupController.Create(newGroupCommand);
var createdGroup = ActionResultParser.ParseCreatedResult <Group>(actionResult, out errorMessage);
CheckErrorMessage(errorMessage);
if (createdGroup.Id == 0)
{
Assert.Fail();
}
var newGuid = Guid.NewGuid().ToString();
var groupUpdateCommand = new UpdateGroupCommand()
{
Group = new Group()
{
Id = createdGroup.Id, CurrentCapacity = createdGroup.CurrentCapacity, Name = newGuid
}
};
actionResult = _groupController.Update(groupUpdateCommand);
var updatedGroup = ActionResultParser.ParseOkObjectResult <Group>(actionResult, out errorMessage);
CheckErrorMessage(errorMessage);
Assert.AreEqual(newGuid, updatedGroup.Name);
DeleteGroup(updatedGroup);
}
public CredentialGroup UpdateGroup(CredentialGroup toBeUpdated, CredentialGroup updated)
{
if (String.IsNullOrWhiteSpace(updated.Name))
{
throw new InvalidOperationException("Der Name darf nicht leer sein.");
}
else if (_currentData.Any(g => g.Name == updated.Name))
{
throw new InvalidOperationException("Eine Gruppe mit diesem Namen existiert bereits.");
}
ICommand command = new UpdateGroupCommand()
{
ToBeUpdated = toBeUpdated,
UpdatedCredential = updated
};
toBeUpdated = (CredentialGroup)ExecuteCommand(command);
return(toBeUpdated);
}
public async Task UpdateGroup()
{
var request = new UpdateGroupCommand
{
Id = 1,
Name = "Test Group 1 edited",
StudentsCount = 10,
SpecialityId = 1,
EducationalDegreeId = 1,
Year = 1
};
var handler = new UpdateGroupCommandHandler(Context);
await handler.Handle(request, CancellationToken.None);
Assert.IsTrue(Context.Groups.Where(x => x.Id == request.Id &&
x.Name == request.Name &&
x.EducationalDegreeId == request.EducationalDegreeId &&
x.SpecialityId == request.SpecialityId &&
x.Year == request.Year).Count() == 1);
}
public async Task ShouldNotUpdateIfTotalCurrentExceedsNewCapacity()
{
var group = await AddGroupAsync();
var chargeStation = await AddChargeStationAsync(group.Id);
await AddConnectorAsync(chargeStation.Id, 1, 30);
var command = new UpdateGroupCommand
{
GroupId = group.Id,
Capacity = 10,
Name = "Den Hague"
};
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <EntityUpdateException>();
var list = await FindAsync <Group>(group.Id);
list.Should().NotBeNull();
list.Name.Should().Be(group.Name);
list.Capacity.Should().Be(group.Capacity);
}
public async Task <IActionResult> UpdateGroupAsync([FromRoute] string groupId, [FromBody] UpdateGroupCommand updateGroupCommand)
{
return(Ok(await _mediator.Send(updateGroupCommand)));
}
public async Task <ActionResult <int> > Update(UpdateGroupCommand command)
{
return(await Mediator.Send(command));
}
public async Task <IActionResult> Update([FromBody] UpdateGroupCommand updateGroup)
{
return(GetResponseOnlyResultMessage(await Mediator.Send(updateGroup)));
}
public async Task <ActionResult <GroupDto> > Update([FromBody] UpdateGroupCommand command)
{
return(Ok(await Mediator.Send(command)));
}
public GroupMutation()
{
Name = "GroupMutation";
this.FieldAsyncWithScope <StringGraphType, string>(
"create",
arguments:
new QueryArguments
(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "name"
}
),
resolve: async(ctx, mediator) =>
{
var command = new CreateGroupCommand()
{
Name = ctx.GetString("name")
};
var id = await mediator.Send(command);
return(id);
}
);
this.FieldAsyncWithScope <BooleanGraphType, bool>(
"delete",
arguments:
new QueryArguments
(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "id"
}
),
resolve: async(ctx, mediator) =>
{
var command = new DeleteGroupCommand()
{
Id = ctx.GetString("id")
};
await mediator.Send(command);
return(true);
}
);
this.FieldAsyncWithScope <BooleanGraphType, bool>(
"update",
arguments:
new QueryArguments
(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "id"
},
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "name"
}
),
resolve: async(ctx, mediator) =>
{
var command = new UpdateGroupCommand()
{
Id = ctx.GetString("id"),
Name = ctx.GetString("name")
};
await mediator.Send(command);
return(true);
}
);
this.FieldAsyncWithScope <BooleanGraphType, bool>(
"addUser",
arguments:
new QueryArguments
(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "userId"
},
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "groupId"
}
),
resolve: async(ctx, mediator) =>
{
var command = new AddUserToGroupCommand()
{
UserId = ctx.GetString("userId"),
GroupId = ctx.GetString("groupId")
};
await mediator.Send(command);
return(true);
}
);
this.FieldAsyncWithScope <BooleanGraphType, bool>(
"removeUser",
arguments:
new QueryArguments
(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "userId"
},
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "groupId"
}
),
resolve: async(ctx, mediator) =>
{
var command = new RemoveUserFromGroupCommand()
{
UserId = ctx.GetString("userId"),
GroupId = ctx.GetString("groupId")
};
await mediator.Send(command);
return(true);
}
);
}
public void Handle(UpdateGroupCommand message)
{
this.Handle(message.AcSession, message.Input, true);
}
