public ActionResult <RoomResponse> CreateRoom([FromBody] RoomCreateInput roomInput)
{
if (roomInput == null)
{
return(BadRequest("Wrong input parameters"));
}
if (roomInput.Number == default)
{
return(BadRequest("Room Number required"));
}
if (roomInput.RoomType == default)
{
return(BadRequest("Room Type required"));
}
if (roomInput.Capacity == default)
{
return(BadRequest("Room Capacity required"));
}
var roomResponse = new CreateRoomCommand(roomInput)
.InTransactionScope()
.Execute(_roomRepository);
var selfLink = GetRoomSelfLinkById(roomResponse.Id.Value);
return(Created(selfLink.Rel, roomResponse.WithLinks(selfLink)));
}
public void EndGameRunningIsFalseTest()
{
// Arrange
var repositoryMock = new Mock <IRepository <Room, long> >(MockBehavior.Strict);
var publisherMock = new Mock <IEventPublisher>(MockBehavior.Strict);
var endCommand = new EndGameCommand()
{
RoomId = 1
};
var foundRoom = new Room()
{
Id = 1, Name = "Chess-01", Running = true
};
repositoryMock.Setup(x => x.Find(1)).Returns(foundRoom);
repositoryMock.Setup(x => x.Update(foundRoom)).Returns(1);
var target = new RoomService(repositoryMock.Object, publisherMock.Object);
var createRoomCommand = new CreateRoomCommand()
{
RoomName = "Chess-01"
};
// Act
var result = target.EndGame(endCommand);
// Assert
repositoryMock.Verify(x => x.Find(endCommand.RoomId), Times.Once());
repositoryMock.Verify(x => x.Update(It.IsAny <Room>()), Times.Once());
Assert.IsNotNull(result);
Assert.AreEqual(foundRoom.Name, result.Name);
Assert.IsFalse(result.Running);
}
public void Execute(CreateRoomCommand command)
{
var room = new Room();
if (_repo.RoomExists(command.RoomName))
{
throw new FunctionalException(new FunctionalError("US003.1", $"A room with the name '{command.RoomName}' already exists"));
}
room.Create(command.RoomName, command.GameID);
_repo.Create(room);
room.Join(command.PlayerID, command.Colour);
_repo.Save(room);
var createdEvent = new RoomCreatedEvent()
{
RoomName = room.Name, GameID = room.GameID
};
_publisher.Publish(createdEvent);
var joinedEvent = new PlayerJoinedRoomEvent()
{
RoomName = room.Name, PlayerID = command.PlayerID, Colour = command.Colour
};
_publisher.Publish(joinedEvent);
}
public async Task <Room> GetOrCreateRoom(string channelId, string channelName, long userId)
{
var roomId = await _mediator.Send(new GetObjectIdByLinkValueQuery(LinkType.Room, channelId)).ConfigureAwait(false);
if (roomId > 0)
{
return(await _mediator.Send(new GetRoomQuery(roomId)).ConfigureAwait(false));
}
var command = new CreateRoomCommand(
id: await _idGenerator.GenerateAsync().ConfigureAwait(false),
name: channelName,
userId: userId
);
await _mediator.Send(command).ConfigureAwait(false);
//add link
await _mediator.Send(new CreateLinkCommand(command.Id, LinkType.Room, channelId)).ConfigureAwait(false);
return(new Room
{
Id = command.Id,
Name = command.Name,
CreatedDate = DateTimeOffset.MinValue //dunno this value *shrug*
});
}
public void StartGameRoomSameNameAsGameRoomCommandTest()
{
// Arrange
var repositoryMock = new Mock <IRepository <Room, long> >(MockBehavior.Strict);
var publisherMock = new Mock <IEventPublisher>(MockBehavior.Strict);
repositoryMock.Setup(x => x.Insert(It.IsAny <Room>())).Returns(1);
publisherMock.Setup(x => x.Publish(It.IsAny <DomainEvent>()));
var target = new RoomService(repositoryMock.Object, publisherMock.Object);
var createRoomCommand = new CreateRoomCommand()
{
RoomName = "Chess-01"
};
// Act
var result = target.StartGame(createRoomCommand);
// Assert
repositoryMock.Verify(x => x.Insert(It.IsAny <Room>()), Times.Once());
publisherMock.Verify(x => x.Publish(It.IsAny <DomainEvent>()), Times.Once());
Assert.IsNotNull(result);
Assert.AreEqual(createRoomCommand.RoomName, result.Name);
}
public async Task <IActionResult> Add(CreateRoomCommand command)
{
var result = await _mediator.Send(command);
ModelState.Clear();
return(View());
}
public async Task <IActionResult> CreateRoom(
[FromHeader] string userCode,
[FromBody] CreateRoomCommand request)
{
if (!request.UserCodes.Contains(userCode))
{
var userCodes = request.UserCodes.ToList();
userCodes.Add(userCode);
request.UserCodes = userCodes;
}
try
{
Room createdRoom = await _mediator.Send(request);
return(this.OkResult(createdRoom));
}
catch (ChattingDomainException ex)
{
return(this.ErrorResult(ex.ErrorCode, ex.Message, ex, HttpStatusCode.BadRequest));
}
catch (Exception ex)
{
return(this.ErrorResult("", ex.Message, ex, HttpStatusCode.InternalServerError));
}
}
public void GameInstanceHasRoomCreatedIfEmpty()
{
GameInstance game = new GameInstance();
var CreateRoomCommand = new CreateRoomCommand(game);
CreateRoomCommand.Execute();
Assert.Single(game.Rooms.Values);
}
public CreateRoomViewModel(RoomsViewModel roomsViewModel)
{
_roomsViewModel = roomsViewModel;
CreateRoomCommand = new CreateRoomCommand(this);
IsValid = true;
CheckValidation = false;
}
public CreateEntityCommandResult Create([FromBody] CreateRoomCommand command)
{
if (command == null)
{
command = new CreateRoomCommand();
}
return(Execute <CreateRoomCommand, CreateEntityCommandResult>(command));
}
private async Task <CreateRoomResult> Execute(string connectionId, CreateRoomCommand command)
{
await roomService.Create(command.Room);
return(new CreateRoomResult
{
ConnectionId = connectionId,
Message = $"A sala {command.Room} foi criada."
});
}
public void GameInstanceHasRoomCreatedWithExistingRooms()
{
GameInstance game = new GameInstance();
game.Rooms.Add(new Room());
game.Rooms.Add(new Room());
var CreateRoomCommand = new CreateRoomCommand(game);
CreateRoomCommand.Execute();
Assert.Equal(3, game.Rooms.Values.Count);
}
public IActionResult Post([FromBody] CreateRoomCommand command)
{
try
{
_roomService.Execute(command);
return(Ok());
}
catch (FunctionalException ex)
{
return(BadRequest(ex.FunctionalErrors.ToArray()));
}
}
public async Task <ActionResult <int> > Create([FromBody] CreateRoomCommand command)
{
var message = new Message {
From = "from@email", To = "to@email", Subject = "Notification", Body = "CREATED", Password = ""
};
var notificationService = new NotificationService();
var roomId = await Mediator.Send(command);
await notificationService.SendAsync(message);
return(Ok(roomId));
}
public void SuccesStartingGameCorrectCommand()
{
//Arrange
var mock = new Mock <RoomService>(MockBehavior.Strict);
var command = new CreateRoomCommand();
mock.Setup(x => x.StartGame(It.Is <CreateRoomCommand>(y => y == command)));
var target = new RoomController(mock.Object);
//Act
target.CreateGame(command);
//Assert
mock.Verify(x => x.StartGame(It.Is <CreateRoomCommand>(y => y == command)), Times.Once);
}
public IActionResult CreateGame([FromBody] CreateRoomCommand createCommand)
{
if (!ModelState.IsValid)
{
var error = new ErrorMessage(ErrorTypes.BadRequest, "Modelstate Invalide");
return(BadRequest(error));
}
try
{
var room = _service.StartGame(createCommand);
return(Ok(room));
}
catch (Exception)
{
var error = new ErrorMessage(ErrorTypes.Unknown,
$"Onbekende fout met volgende Command: RoomName:{createCommand.RoomName}, CommandId:{createCommand.CommandId}, TimeStamp:{createCommand.Timestamp}");
return(BadRequest(error));
}
}
public void StartGameProcessesCommandTest()
{
// Arrange
var repositoryMock = new Mock <IRepository <Room, long> >(MockBehavior.Strict);
var publisherMock = new Mock <IEventPublisher>(MockBehavior.Strict);
repositoryMock.Setup(x => x.Insert(It.IsAny <Room>())).Returns(1);
publisherMock.Setup(x => x.Publish(It.IsAny <DomainEvent>()));
var target = new RoomService(repositoryMock.Object, publisherMock.Object);
var createRoomCommand = new CreateRoomCommand();
// Act
target.StartGame(createRoomCommand);
// Assert
repositoryMock.Verify(x => x.Insert(It.IsAny <Room>()), Times.Once());
publisherMock.Verify(x => x.Publish(It.IsAny <DomainEvent>()), Times.Once());
}
public Room StartGame(CreateRoomCommand command)
{
var room = new Room()
{
Name = command.RoomName
};
_repository.Insert(room);
// (optional) throw RoomCreatedEvent
var roomCreatedEvent = new RoomCreatedEvent()
{
GUID = Guid.NewGuid().ToString(), RoutingKey = "Minor.GameRooms", TimeStamp = DateTime.UtcNow
};
_publisher.Publish(roomCreatedEvent);
return(room);
}
public async Task CreateAsync(CreateRoomCommand command)
{
Check.NotNull(command, nameof(command));
var response = await _bus.Request <CheckOfficeExistence, OfficeExistenceRespond>(new
{
command.OfficeId
});
if (response.Message.Exists == false)
{
throw new ServiceException($"Office not found with id: {command.OfficeId}");
}
Room room = _mapper.Map <Room>(command);
await _applicationContext.Rooms.AddAsync(room);
await _applicationContext.SaveChangesAsync();
}
public void Before_Each_Test()
{
mock = MockRepository.GenerateMock <IConsoleFacade>();
repository = MockRepository.GenerateMock <IRepository <Room> >();
cmd = new CreateRoomCommand(mock, repository);
}
public void Before_Each_Test()
{
mock = MockRepository.GenerateMock<IConsoleFacade>();
repository = MockRepository.GenerateMock<IRepository<Room>>();
cmd = new CreateRoomCommand(mock, repository);
}
public async Task <ActionResult <RoomViewModel> > Create([FromBody] CreateRoomCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
public async Task <ActionResult <int> > CreateRoom([FromBody] CreateRoomCommand createRoomCommand)
{
var response = await _mediator.Send(createRoomCommand);
return(Ok(response));
}
public async Task <IActionResult> CreateRoomAsync([FromBody] CreateRoomCommand command)
{
await _roomBusiness.CreateAsync(command);
return(Ok());
}
public async Task <ActionResult <RoomViewModel> > Create([FromBody] CreateRoomCommand command)
{
var roomType = await Mediator.Send(command);
return(Ok(roomType));
}
public void NullGameInstanceThrowsError()
{
var CreateRoomCommand = new CreateRoomCommand(null);
Assert.Throws <GameInstanceIsNull>(() => CreateRoomCommand.Execute());
}
public async Task CreateRoom([FromServices] CreateRoomCommand command, [FromBody] RoomInput input)
{
await command.ExecuteAsync(input);
}
public async Task <ActionResult <int> > Create([FromBody] CreateRoomCommand command)
{
var roomId = await Mediator.Send(command);
return(Ok(roomId));
}
public void Execute(CreateRoomCommand command)
{
var room = new Room();
room.Create(command);
}
public async Task <IActionResult> Post(CreateRoomCommand cmd)
{
var roomId = await _commandDispatcher.SendAsync(cmd);
return(Created($"hotels/{cmd.HotelId}/rooms/{roomId}", new { cmd.HotelId, roomId }));
}
public async Task <IActionResult> CreateRoom(CreateRoomCommand command)
{
return(Ok(await _mediator.Send(command)));
}
