public async Task <bool> Create(Project entity)
{
try
{
entity.CreatedByName = (await _userRepository.FindAll().FirstOrDefaultAsync(x => x.ID == entity.CreatedBy)).Username ?? "";
await _projectRepository.AddAsync(entity);
await _unitOfWork.Commit();
var room = new Room
{
Name = entity.Name,
ProjectID = entity.ID
};
await _roomRepository.AddAsync(room);
await _unitOfWork.Commit();
var update = await _projectRepository.FindAll().FirstOrDefaultAsync(x => x.ID.Equals(room.ProjectID));
update.Room = room.ID;
await _unitOfWork.Commit();
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task CreateAsync(Guid playerId)
{
Room room = new Room(Guid.NewGuid(), playerId);
await _roomRepository.AddAsync(room);
await AddMemberAsync(playerId, room.Id);
}
public async Task <RoomResponseModel> CreateRoom(RoomRequestModel roomRequestModel)
{
var room = _mapper.Map <Room>(roomRequestModel);
var createdRoom = await _roomRepository.AddAsync(room);
return(_mapper.Map <RoomResponseModel>(createdRoom));
}
public async Task <RoomDto> Handle(CreateRoomCommand request, CancellationToken cancellationToken)
{
try
{
using var transaction = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
var host = await _viewerRepository.GetAsync(request.HostId, cancellationToken)
?? throw new ArgumentException($"Host {request.HostId.ToString()} could not be found");
if (request.PlaylistId == default)
{
Guid generatedPlaylistId = _identifierProvider.GenerateGuid();
var playlist = new Playlist(generatedPlaylistId, "Temporary", host)
{
IsTemporary = true
};
await _playlistRepository.AddAsync(playlist, cancellationToken);
request.PlaylistId = generatedPlaylistId;
}
Guid generatedRoomId = _identifierProvider.GenerateGuid();
string invitationToken = _identifierProvider.GenerateToken(generatedRoomId);
var room = new Room(
generatedRoomId,
request.Name,
host,
request.Type,
new Invitation(invitationToken),
request.PlaylistId,
request.Description)
{
MaxViewersQuantity = request.MaxViewersQuantity
};
await _roomRepository.AddAsync(room, cancellationToken);
transaction.Complete();
return(_mapper.Map <RoomDto>(room));
}
catch (InformativeException exception)
{
_logger.LogError(exception, $"Could not create room with name {request.Name} by user with ID " +
$"{request.HostId.ToString()}");
throw;
}
catch (Exception exception)
{
_logger.LogError(exception, $"Could not create room with name {request.Name} by user with ID " +
$"{request.HostId.ToString()}");
throw new InformativeException("Could not create room. Please retry");
}
}
public async Task <RoomResponse> SaveAsync(Room room)
{
try
{
await roomRepository.AddAsync(room);
await unitOfWork.CompleteAsync();
return(new RoomResponse(room));
}
catch (Exception ex)
{
return(new RoomResponse($"Ошибка при сохранении Залы: {ex.Message}"));
}
}
public async Task AddNewAsyncTest()
{
var roomA = _romTypeRepository.Get(s => s.RoomTypeName == "Room Type A");
var room = new Room
{
RoomCode = "R0011",
Description = "Room demo",
RoomTypeId = roomA.Id
};
room.Created(Guid.NewGuid());
await _roomRepository.AddAsync(room);
Assert.True(_context.SaveChangesAsync().Result);
}
public async Task <RoomResponse> SaveAsync(Room room)
{
try
{
await _RoomRepository.AddAsync(room);
await _UnitOfWork.CompleteAsync();
return(new RoomResponse(room));
}
catch (Exception ex)
{
// Do some logging stuff
return(new RoomResponse($"An error occurred when saving the room: {ex.Message}"));
}
}
public override async Task <ActionResult> HandleAsync([FromBody] CreateRoomRequest request, CancellationToken cancellationToken = default)
{
var Room = new Room
{
Id = request.Id,
BuildingId = request.BuildingId,
CarpetId = request.CarpetId,
Length = request.Length,
Width = request.Width,
RoomName = request.RoomName
};
await _repo.AddAsync(Room);
await _repo.SaveAsync();
return(Ok(Room));
}
public async Task CreateRoom(string roomName)
{
try
{
Match match = Regex.Match(roomName, @"^\w+( \w+)*$");
if (!match.Success)
{
await Clients.Caller.SendAsync("onError", "Invalid room name!\nRoom name must contain only letters and numbers.");
}
else if (roomName.Length < 5 || roomName.Length > 100)
{
await Clients.Caller.SendAsync("onError", "Room name must be between 5-100 characters!");
}
else if (_iRoomRepository.All.Any(r => r.Name == roomName))
{
await Clients.Caller.SendAsync("onError", "Another chat room with this name exists");
}
else
{
var user = await _iAccountRepository.All.FirstOrDefaultAsync(u => u.Email == IdentityName);
var room = new Room()
{
Name = roomName,
Admin = user
};
await _iRoomRepository.AddAsync(room);
await _iRoomRepository.SaveAsync();
if (room != null)
{
var roomViewModel = _mapper.Map <Room, RoomViewModel>(room);
_Rooms.Add(roomViewModel);
await Clients.All.SendAsync("addChatRoom", roomViewModel);
}
}
}
catch (Exception ex)
{
await Clients.Caller.SendAsync("onError", "Couldn't create chat room: " + ex.Message);
}
}
public async Task RegisterAsync(string name, string number, bool lectern, bool voting, bool sound,
bool magnetic, bool computer, bool interpreter, bool brain, bool led,
bool microphone, bool multiphone, bool lcd, bool flipchart, bool whitescren,
bool videoconference, bool projector)
{
var room = await _roomRepository.GetAsync(number);
if (room != null)
{
throw new Exception($"Room with number {number} already exists");
}
room = new Room(name, number, lectern, voting, sound,
magnetic, computer, interpreter, brain, led,
microphone, multiphone, lcd, flipchart, whitescren,
videoconference, projector);
await _roomRepository.AddAsync(room);
}
public async Task <ActionResult> Create(RoomViewModel room)
{
room.Id = System.Guid.NewGuid().ToString();
if (!ModelState.IsValid)
{
return(View(room));
}
try
{
await _repository.AddAsync(RoomViewModel.FromRoomViewModel(room));
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View(room));
}
}
public async Task <RoomResponse> SaveAsync(Room room)
{
room.Enabled ??= true;
if (!ChildEntitiesExist(room.RoomTypeID, room.HotelID, out string message))
{
return(new RoomResponse(message));
}
try
{
await _roomRepository.AddAsync(room);
await _unitOfWork.CompleteAsync();
return(new RoomResponse(room));
}
catch (Exception e)
{
//TODO - Log the exception
return(new RoomResponse($"An error ocurred while saving the Room: " +
$"{ e.Message } { e.InnerException?.Message }"));
}
}
public async Task <IActionResult> RoomCreate(RoomViewModel viewModel)
{
if (ModelState.IsValid)
{
var dto = new RoomDTO {
Description = viewModel.Description, MaxNumberOfGuests = viewModel.MaxNumberOfGuests.Value, Price = viewModel.Price.Value, HasBalcony = viewModel.HasBalcony, HasKitchen = viewModel.HasKitchen, HotelId = viewModel.HotelId
};
await _roomRepository.AddAsync(dto);
return(RedirectToAction("Index"));
}
else
{
var dtoHotels = await _hotelRepository.GetAllAsync();
viewModel.Hotels = dtoHotels;
ViewBag.HotelId = viewModel.HotelId;
return(View(viewModel));
}
}
public async Task <Guid> AddRoomAsync(Room request)
{
try
{
if (!await IsDuplicated(request.Name))
{
var entity = await _roomRepository.AddAsync(request);
await _roomRepository.CommitAsync();
return(entity.Id);
}
else
{
await _mediator.Publish(new Notification("DuplicatedRoom", $"Já existe uma sala com o nome de {request.Name}."));
}
}
catch (Exception ex)
{
await _mediator.Publish(new Notification("AddRoomAsync_Exception", $"Ocorreu um erro ao tentar adicionar a sala {request.Name}. Erro: {ex.Message}"));
}
return(new Guid());
}
public async Task <Room> AddRoom(Room room)
{
var addRoom = await _roomRepository.AddAsync(room);
return(addRoom);
}
public async Task <bool> AddRoomAsync(RoomViewModel room)
{
Room model = _mapper.Map <Room>(room);
return(await _roomRepository.AddAsync(model));
}
public async Task <int> AddRoomAsync(AddRoomDto addRoomDto)
{
return(await _repository.AddAsync(_converter.AddRoomDtoToRoom(addRoomDto)));
}
