public async Task <IActionResult> CreateRoom(string name)
{
if (name == null)
{
return(RedirectToAction("index"));
}
var room = new CreateRoomDto
{
Name = name,
isPublic = true,
UserId = 1
};
using (var httpClient = new HttpClient())
{
StringContent content = new StringContent
(JsonConvert.SerializeObject(room), Encoding.UTF8, "application/json");
using (var response = await httpClient.PostAsync(WebApiRouteContans.CreateRoomUrl, content))
{
try
{
response.EnsureSuccessStatusCode();
}
catch (HttpRequestException ex)
{
throw ex;
}
}
}
return(RedirectToAction("index"));
}
public void Execute(CreateRoomDto dto)
{
this.editRoomValidation.ValidateAndThrow(dto);
var room = this.context.Rooms
.Include(r => r.Amenities)
.FirstOrDefault(r => r.Id == dto.Id);
if (room == null)
{
throw new EntityNotFoundException(dto.Id);
}
room.Amenities.Where(amenities => amenities.RoomId == room.Id)
.ToList()
.ForEach(amenity => room.Amenities.Remove(amenity));
foreach (var amenity in dto.Amenities)
{
room.Amenities.Add(new RoomAmenity
{
AmenityId = amenity.AmenityId,
RoomId = room.Id
});
}
this.mapper.Map(dto, room);
this.context.SaveChanges();
}
public IActionResult Put(int id,
[FromBody] CreateRoomDto dto,
[FromServices] IEditRoomCommand editRoomCommand)
{
dto.Id = id;
_dispatcher.DispatchCommand(editRoomCommand, dto);
return(NoContent());
}
public void Execute(CreateRoomDto dto)
{
this.createRoomValidation.ValidateAndThrow(dto);
var room = this.mapper.Map <Room>(dto);
this.context.Rooms.Add(room);
this.context.SaveChanges();
}
public bool CreateRoom(CreateRoomDto dto)
{
Room room = new Room();
room.Id = dto.id;
room.Name = dto.name;
room.DepartmentId = 1;
_roomRepository.Repository.Create(room);
return(true);
}
public Room CreateRoom(CreateRoomDto createRoomDto)
{
var client = new RestClient(AllConstants.ConnectionUrl);
var request = new RestRequest("/api/hospital/room/create-room", Method.POST);
request.AddParameter(AllConstants.AuthorizationTokenKey, LoggedUser.Cookie, ParameterType.Cookie);
request.AddJsonBody(JsonConvert.SerializeObject(createRoomDto));
var response = client.Post <Room>(request);
return(response.Data);
}
public IActionResult Create([FromBody] CreateRoomDto dto)
{
try
{
var result = _repo.CreateRoomAndOwner(dto);
return(Ok(result));
}
catch (Exception ex)
{
logger.Error($"An error occured: {ex.Message}");
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> CreateRoom([FromBody] CreateRoomDto createRoom)
{
var id = RoomId.New;
var roomCreatedOrError =
await _commandBus.PublishAsync(new CreateRoom(id, createRoom.Number), CancellationToken.None);
if (roomCreatedOrError.IsSuccess)
{
return(Json(id.GetGuid()));
}
return(BadRequest(roomCreatedOrError));
}
public RoomDto CreateRoomAndOwner(CreateRoomDto dto)
{
var newRoomID = Guid.NewGuid();
var newOwnerID = Guid.NewGuid();
var newRoom = new RoomDto
{
RoomID = newRoomID,
RoomName = dto.RoomName,
OwnerID = newOwnerID,
canVote = false,
showVotes = false
};
_roomCache.SetCache("Room_" + newRoom.RoomID.ToString().ToLowerInvariant(), new List <RoomDto> {
newRoom
});
var newOwner = new UserDto
{
UserID = newOwnerID,
UserName = dto.RoomOwnerName,
RoomID = newRoomID
};
_userCache.SetCache("User_" + newOwner.RoomID.ToString().ToLowerInvariant(), new List <UserDto> {
newOwner
});
var t = _roomCache.GetCache("Room_" + newRoom.RoomID.ToString().ToLowerInvariant());
//var createUserDto = new CreateUserDto
//{
// RoomID = newRoomID,
// UserName = dto.RoomOwnerName
//};
//var t = _userCache.GetCache(newRoomID.ToString().ToLowerInvariant());
newRoom.Users = new List <UserDto>()
{
newOwner
};
return(newRoom);
}
public async Task CreateRoom(CreateRoomDto chatRoom)
{
var chatRoomType = chatRoom.isPublic ? ChatType.Room : ChatType.Private;
var itemToSave = new Chat
{
Name = chatRoom.Name,
Type = chatRoomType,
Users = new List <ChatUser>()
};
itemToSave.Users.Add(new ChatUser
{
UserId = chatRoom.UserId,
Role = UserRole.Admin
});
await _uow.ChatRoom.Add(itemToSave);
await _uow.Complete();
}
private void SeparateEquipmentClick(object sender, RoutedEventArgs e)
{
if (Room2Name.Text.Equals("") || WorkTime2.Text.Equals(""))
{
MessageBox.Show("Enter Room2 data");
}
else
{
equipmentRelocated = true;
int id = FindAvailableId();
CreateRoomDto createRoomDto = new CreateRoomDto()
{
id = id,
name = Room2Name.Text
};
createdRoom = roomServerController.CreateRoom(createRoomDto);
schDto.DestinationRoomId = id;
ISearchResultStrategy strategy = new SearchResultStrategy(new EquipmentSeparation(schDto));
SearchResultDialog equipmentRelocationDialog = new SearchResultDialog(strategy.GetSearchResult(), SearchType.EquipmentSeparation, schDto);
equipmentRelocationDialog.ShowDialog();
}
}
public IActionResult CreateRoom(CreateRoomDto dto) => Ok(_roomService.CreateRoom(dto));
public Room CreateRoom(CreateRoomDto createRoomDto)
{
return(roomTypeServerService.CreateRoom(createRoomDto));
}
public async Task <IActionResult> SaveChatRoom(CreateRoomDto chatRoom)
{
await _chatRoomService.CreateRoom(chatRoom);
return(StatusCode(201));
}
public IActionResult Post([FromBody] CreateRoomDto dto,
[FromServices] ICreateRoomCommand createRoomCommand)
{
_dispatcher.DispatchCommand(createRoomCommand, dto);
return(StatusCode(StatusCodes.Status201Created));
}
