private async void btn_create_Click(object sender, RoutedEventArgs e)
{
FormCreateRoom form = new FormCreateRoom();
form.ShowDialog();
if (form.status)
{
RoomRequest request = new RoomRequest();
request.outlet_id = Int32.Parse(outletid);
request.room_name = form.Get_Roomname();
request.max_beds = form.Get_maxbed();
request.r_type = form.Get_RoomTypeID();
progress_bar.Visibility = Visibility.Visible;
bool result = await RestAPI.CreateRoom(request);
progress_bar.Visibility = Visibility.Collapsed;
if (result)
{
if (send != null)
{
send.Invoke(outletid);
}
MessageBox.Show("Create Room Successful");
}
else
{
MessageBox.Show("Create Room Fail");
}
}
}
public Room CreateRoom(RoomRequest roomRequest)
{
var room = new Room();
Coppier <RoomRequest, Room> .Copy(roomRequest, room);
room.Cluster = dbContext.Clusters.Where(c => c.Id == roomRequest.ClusterId).FirstOrDefault();
var screenTypes = dbContext.ScreenTypes.Where(s => roomRequest.ScreenTypeIds.Contains(s.Id)).ToList();
foreach (var screen in screenTypes)
{
var roomScreenType = new RoomScreenType()
{
ScreenType = screen,
Room = room,
};
dbContext.Add(roomScreenType);
}
dbContext.Add(room);
var isSuccess = Save();
if (!isSuccess)
{
return(null);
}
return(room);
}
public Room UpdateRoom(int id, RoomRequest roomRequest)
{
var room = dbContext.Rooms.Where(r => r.Id == id).FirstOrDefault();
var screenTypesIsDelete = dbContext.RoomScreenTypes.Where(rs => rs.RoomId == id).ToList();
if (screenTypesIsDelete != null)
{
dbContext.RemoveRange(screenTypesIsDelete);
}
Coppier <RoomRequest, Room> .Copy(roomRequest, room);
room.Cluster = dbContext.Clusters.Where(c => c.Id == roomRequest.ClusterId).FirstOrDefault();
var screenTypes = dbContext.ScreenTypes.Where(s => roomRequest.ScreenTypeIds.Contains(s.Id)).ToList();
foreach (var screen in screenTypes)
{
var roomScreenType = new RoomScreenType()
{
ScreenType = screen,
Room = room,
};
dbContext.Add(roomScreenType);
}
dbContext.Update(room);
var isSuccess = Save();
if (!isSuccess)
{
return(null);
}
return(room);
}
public async Task <ActionResult <Room> > PostRoomRequest(RoomRequest roomRequest)
{
//Room room = new Room(roomRequest.GameId, new HashSet<Participant> { roomRequest.Participant });
Participant p = new Participant {
Id = roomRequest.Participant.Id,
Name = roomRequest.Participant.Name
};
_context.Participants.Add(p);
Room room = new Room {
Participants = new HashSet <Participant> {
p
}
};
if (!Room.games.Any(g => g.Id == roomRequest.GameId))
{
return(BadRequest("There is no game with the requested id"));
}
room.GameId = roomRequest.GameId;
_context.Rooms.Add(room);
_participantToGroup.Add(roomRequest.Participant.Name, room.Id.ToString());
await _context.SaveChangesAsync();
await _roomHub.Clients.All.RoomMade(room);
//Room r = _context.Rooms.Find(room.Id);
return(CreatedAtAction("GetRoom", new { id = room.Id }, room));
}
public async Task <ActionResult> UpdateAsync(int id, RoomRequest item)
{
if (id != item.Id)
{
return(BadRequest("Invalid ID"));
}
var itemRoom = await db.Rooms.FindAsync(id);
if (itemRoom == null)
{
return(NotFound(new ProblemDetails()
{
Title = $"Room id : {id.ToString()} not found"
}));
}
itemRoom.AreaSquareMeters = item.AreaSquareMeters;
itemRoom.FloorNo = item.FloorNo;
itemRoom.TypeCode = item.RoomType;
await db.SaveChangesAsync();
return(NoContent());
}
public IActionResult Put(int id, [FromBody] RoomRequest roomRequest)
{
if (roomRepository.GetRoomById(id) == null)
{
return(NotFound());
}
if (roomRequest == null)
{
return(StatusCode(400, ModelState));
}
var statusCode = ValidateRoom(roomRequest);
if (!ModelState.IsValid)
{
return(StatusCode(statusCode.StatusCode));
}
var room = roomRepository.UpdateRoom(id, roomRequest);
if (room == null)
{
var error = new Error()
{
message = "Something went wrong when save room"
};
return(StatusCode(400, error));
}
return(Ok(new RoomDTO(room)));
}
public static SearchRequest prepareSearchObj(SearchData data, string city)
{
//2019-07-27
SearchRequest searchRequest = new SearchRequest();
searchRequest.SearchDetails.ArrivalDate = Convert.ToDateTime(data.DateFrom).ToString("yyyy-MM-dd");
searchRequest.SearchDetails.Duration = Convert.ToInt32((data.DateTo - data.DateFrom).TotalDays).ToString();
searchRequest.SearchDetails.MealBasisID = "0";
searchRequest.SearchDetails.MinStarRating = "0";
searchRequest.SearchDetails.RegionID = city;
foreach (var item in data.SearchRooms)
{
RoomRequest room = new RoomRequest();
room.Adults = item.Adult.ToString();
room.Children = item.Child.Count.ToString();
room.Infants = "0";
if (item.Child.Count > 0)
{
foreach (var ch in item.Child)
{
room.ChildAges.ChildAge.Add(new ChildAge {
Age = "5"
});
}
}
searchRequest.SearchDetails.RoomRequests.RoomRequest.Add(room);
}
return(searchRequest);
}
public IActionResult Post([FromBody] RoomRequest roomRequest)
{
if (roomRequest == null)
{
return(StatusCode(400, ModelState));
}
var statusCode = ValidateRoom(roomRequest);
if (!ModelState.IsValid)
{
return(StatusCode(statusCode.StatusCode));
}
var room = roomRepository.CreateRoom(roomRequest);
if (room == null)
{
var error = new Error()
{
message = "Something went wrong when save room"
};
return(StatusCode(400, error));
}
return(Ok(new RoomDTO(room)));
}
public ActionResult Allocate(int?id, IEnumerable <int> roomNames)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Request request = db.Requests.Find(id);
request.statusID = 4;
if (request == null)
{
return(HttpNotFound());
}
foreach (var i in roomNames)
{
RoomRequest temp = new RoomRequest()
{
roomID = db.Rooms.Where(a => a.roomID == i).Select(b => b.roomID).First(),
groupSize = 42
};
request.RoomRequests.Add(temp);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IHttpActionResult> SendRoomRequest([FromBody] RoomRequestViewModel model)
{
var myUser = GetUserLogin();
var roomRq = context.RoomRequests.FirstOrDefault(t => t.UserId.Equals(model.UserId) && t.UserSendID.Equals(myUser.Id));
if (roomRq == null)
{
var rq = new RoomRequest()
{
UserSendID = myUser.Id,
UserId = model.UserId,
Content = model.Content
};
context.RoomRequests.Add(rq);
var rqbf = new RoomRequestFB()
{
ID = rq.Id.ToString(),
IDUserSend = rq.UserSendID,
IDUser = rq.UserId,
Content = rq.Content,
TimeSend = DateTime.UtcNow.ToString("mm/dd/yyyy hh:mm:ss")
};
await firebaseClient
.Child(ROOM_REQUEST)
.Child(rq.Id.ToString())
.PutAsync(rqbf);
await context.SaveChangesAsync();
}
return(Ok());
}
public async Task <ResponseDTO <Guid> > CreateRoomAsync(RoomRequest request, Guid userId)
{
var response = new ResponseDTO <Guid>();
var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == userId);
var room = new RoomEntity
{
Id = Guid.NewGuid(),
Title = request.Title,
AdminId = userId,
Participants = new List <RoomParticipants>()
};
room.Participants.Add(new RoomParticipants {
RoomId = room.Id, UserId = userId
});
await _context.Rooms.AddAsync(room);
await _context.SaveChangesAsync();
await _chatHandler.SendForAllAuthorizedUsers(
new SocketResponseDTO <RoomDTO>
{
Type = SocketMessageTypes.RoomCreated, Model = new RoomDTO(room)
});
response.Data = room.Id;
return(response);
}
public static async Task <RoomResponse> HostRoom(string token, int roomSizeVal)
{
var request = new RoomRequest {
Size = roomSizeVal
};
return(await Create(token, request));
}
public async Task <IActionResult> Update([FromForm] RoomRequest request, int roomId)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _roomService.Update(request, roomId);
return(Ok(result));
}
public async Task <IActionResult> BookRoom(RoomRequest roomRequest)
{
await Task.Delay(_rnd.Next(5000)); // Simulate slow response
if (_rnd.Next(30) == 1)
{
return(NotFound("No available rooms"));
}
return(Ok());
}
public async Task <IActionResult> Update(RoomRequest request)
{
var result = await _manage.Update(request);
if (result == 0)
{
return(BadRequest());
}
return(Ok(result));
}
public async Task <IActionResult> Create(RoomRequest request)
{
var result = await _manage.Create(request);
if (request == null)
{
return(Ok("bad"));
}
return(Ok(result));
}
public async Task <IActionResult> CancelRoom(RoomRequest roomRequest)
{
await Task.Delay(_rnd.Next(5000)); // Simulate slow response
if (_rnd.Next(30) == 1)
{
return(BadRequest("Cancellation refused"));
}
return(Ok());
}
public async Task Post([FromBody] RoomRequest roomRequest)
{
RoomData room = new RoomData()
{
Id = Guid.NewGuid(),
Name = roomRequest.Name,
IsAvailable = true,
Number = roomRequest.Number
};
await roomsService.AddOrUpdateRoomAsync(room, default(CancellationToken));
}
public async Task <int> Add(RoomRequest request)
{
var check = await _repository.ExecuteNonQuery("RoomInsert", new
{
Name = request.Name,
RoomTypeId = request.RoomTypeId,
Description = request.Description,
CreatedUserId = 1
});
return(check);
}
public async Task <int> Update(RoomRequest request)
{
var check = await _repository.ExecuteNonQuery("RoomUpdate", new
{
Id = request.Id,
Name = request.Name,
RoomTypeId = request.RoomTypeId,
Description = request.Description,
ModifiedUserId = 2
});
return(check);
}
/// <summary>
/// Sends a message and calls the callback when the response is received.
/// </summary>
/// <param name="req">The request to send.</param>
public Task <RoomResponse> SendRequest(RoomRequest req)
{
var source = new TaskCompletionSource <RoomResponse>();
lock (_sources)
{
_sources[req.RequestId] = source;
}
Send(req);
return(source.Task);
}
public async Task <string> CreateRoomAsync(RoomRequest room)
{
var content = new StringContent(JsonSerializer.Serialize(room, serializerOptions));
var response = await _httpClient.PostAsync($"{DAILY_URL}/rooms", content);
if (response.IsSuccessStatusCode)
{
var token = await CreateRoomTokenAsync(room.Name);
return(token);
}
return(null);
}
// Create Room
public async Task <int> Create(RoomRequest request)
{
var result = new MotelRoom()
{
Area = request.Area,
BedRoom = request.BedRoom,
NameRoom = request.NameRoom,
Payment = request.Payment,
Status = false,
Toilet = request.Toilet
};
_context.MotelRooms.Add(result);
return(await _context.SaveChangesAsync());
}
public override Task <RoomReply> GetRooms(RoomRequest request, ServerCallContext context)
{
RoomReply roomReply = new RoomReply();
foreach (HostelDB.Database.Models.Room room in UnitOfWork.Rooms.GetObjectList())
{
roomReply.Rooms.Add(new Room()
{
Id = room.Id,
MaxResidentsCount = room.MaxResidentsCount,
Floor = room.Floor,
Number = room.Number
});
}
return(Task.FromResult(roomReply));
}
private StatusCodeResult ValidateRoom(RoomRequest roomRequest)
{
if (roomRequest == null || !ModelState.IsValid)
{
return(BadRequest());
}
foreach (var id in roomRequest.ScreenTypeIds)
{
if (screenTypeRepository.GetScreenTypeById(id) == null)
{
ModelState.AddModelError("", $"Id {id} not found");
return(StatusCode(404));
}
}
return(NoContent());
}
// Update a room - all property
public async Task <int> Update(RoomRequest request)
{
var check = _context.MotelRooms.Find(request.idMotel);
if (check == null)
{
return(0);
}
else
{
check.NameRoom = request.NameRoom;
check.Payment = request.Payment;
check.Status = request.Status;
check.Toilet = request.Toilet;
_context.MotelRooms.Update(check);
}
return(await _context.SaveChangesAsync());
}
protected void pushToDb(List <string> room_names, List <string> facility_names, Int16 module_id, Int16 session_type, string weeks, Int16 statusID, Int16?day, Int16 periodID, Int16 sessionLength, Int16 semester, Int16 round, Int16 adhoc, Int16 prio, Int16 year)
{
Request toSubmit = new Request()
{
userID = 2, // sort
moduleID = module_id,
sessionTypeID = session_type,
dayID = day,
periodID = periodID,
sessionLength = sessionLength,
semester = semester,
round = round,
year = year,
priority = prio, // SORT
adhoc = adhoc,
specialRequirement = "There must be poop provided",
statusID = statusID,
week = weeks
};
foreach (var i in facility_names)
{
toSubmit.Facilities.Add(_db.Facilities.Where(a => a.facilityName == i).FirstOrDefault());
}
foreach (var j in room_names)
{
RoomRequest temp = new RoomRequest()
{
roomID = _db.Rooms.Where(a => a.roomCode == j).Select(b => b.roomID).FirstOrDefault(),
groupSize = 50
};
toSubmit.RoomRequests.Add(temp);
}
_db.Requests.Add(toSubmit);
_db.SaveChanges();
}
public ActionResult <RoomResponse> Create(RoomRequest item)
{
var itemRoomType = db.RoomTypes.Find(item.RoomType);
if (itemRoomType == null)
{
return(NotFound(new ProblemDetails()
{
Title = $"RoomType code : {item.RoomType} not found"
}));
}
Room newRoom = item.ToModel();
db.Add(newRoom);
db.SaveChanges();
return(CreatedAtAction(nameof(GetById), new { id = newRoom.Id }, RoomResponse.FromModel(newRoom)));
}
public static async Task <RoomResponse> Create(string token, RoomRequest request)
{
var jsonRequest = JsonConvert.SerializeObject(request);
HttpContent content = new StringContent(jsonRequest, Encoding.UTF8, "application/json");
Uri uri = new Uri(BASE_URL);
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var response = await client.PostAsync(uri, content);
var jsonResponse = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <RoomResponse>(jsonResponse));
}
throw new ApiException(JsonConvert.DeserializeObject <ErrorResponse>(jsonResponse));
}
}
public async Task CreateRoomAsync(int roomId)
{
var roomRequest = new RoomRequest(roomId, Context.GetHttpContext(), _hostEnvironment.IsDevelopment());
var room = _roomService.CreateRoom(roomRequest);
if (room == null)
{
await Clients.Client(Context.ConnectionId).SendAsync("SendInfo",
new Info("Failed to create room, room with such room number already exists in the network.", false));
return;
}
var member = room.AddMember(Context.ConnectionId, Context.GetHttpContext());
await Groups.AddToGroupAsync(Context.ConnectionId, room.Id.ToString());
await Clients.Caller.SendAsync("ConnectedToRoom", room.Id, member, room.MemberCount);
await Clients.Caller.SendAsync("SendInfo", new Info("Room Created", true));
logger.LogInformation($"Client {Context.ConnectionId} created room {roomId} with {roomRequest.Ip}");
}
