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 <ActionResult> UpdateRoomDetailsAsync(RoomRequestModel roomRequestModel)
{
int id = roomRequestModel.Id;
var room = await _roomService.UpdateRoomDetailsAsync(roomRequestModel);
return(Ok(room));
}
public async Task <RoomResponseModel> UpdateRoom(RoomRequestModel roomRequestModel)
{
var room = _mapper.Map <Room>(roomRequestModel);
var updatedRoom = await _roomRepository.UpdateAsync(room);
return(_mapper.Map <RoomResponseModel>(updatedRoom));
}
public ActionResult AssignRoom(int requestId)
{
UserModel session = (UserModel)Session["CurrentUser"];
if (session == null || !session.IsAdmin)
{
return(RedirectToAction("Index", "Login"));
}
RoomRequestModel roomrequestmodel = new RoomRequestModel();
var request = (from req in entity.User_RoomRequest where req.Id == requestId select req).FirstOrDefault();
var user = helper.FindUserById(request.UserId);
var address = user.User_Address.Where(x => x.IsPrimary && x.UserId == request.UserId).FirstOrDefault();
var city = (from ct in entity.Cities where ct.Id == address.CityId select ct.City1).FirstOrDefault();
var state = (from stat in entity.States where stat.Id == address.StateId select stat.State1).FirstOrDefault();
var country = (from cntry in entity.Countries where cntry.Id == address.CountryId select cntry.Country1).FirstOrDefault();
var course = (from uc in entity.User_Courses
join c in entity.Courses on uc.CourseId equals c.Id
select c.Name).FirstOrDefault();
var rooms = (from room in entity.HostelRooms select new RoomRequestModel.Rooms {
Roomid = room.Id,
RoomNo = room.RoomNo
}).ToList();
roomrequestmodel.RequestId = requestId;
roomrequestmodel.UserId = user.Id;
roomrequestmodel.Email = user.Email;
roomrequestmodel.FirstName = user.FirstName;
roomrequestmodel.LastName = user.LastName;
roomrequestmodel.Address = address.Address1 + " " + address.Address2 + " " + city + " " + state + ", " + country + " " + address.PostCode;
roomrequestmodel.Mobile = user.Mobile;
roomrequestmodel.Course = course;
roomrequestmodel.RoomModel = rooms;
roomrequestmodel.Budegt = user.User_RoomRequest.FirstOrDefault().Budegt;
return(View(roomrequestmodel));
}
public ActionResult Index(string KeySearch, int page = 1, int pageSize = 10)
{
Employee employee = (Employee)Session[CommonConstants.EMPLOYEE_SESSION];
User user = (User)Session[CommonConstants.USER_SESSION];
RoomRequestModel model = new RoomRequestModel();
model = _roomRepo.GetListAllRoom(employee, user, KeySearch, page, pageSize);
return(View(model));
}
private RoomRequestModel GetTestRoomModel()
{
var room = new RoomRequestModel()
{
Name = "Test Room",
};
return(room);
}
public async Task <ActionResult <RoomModel> > PostAsync(RoomRequestModel roomRequestModel)
{
var response = await _roomService.PostAsync(roomRequestModel);
if (response.IsError)
{
return(StatusCode((int)response.ErrorCode, response.ErrorDescription));
}
return(Ok(response.Data));
}
public async Task <IActionResult> AddRoomAsync([FromForm] RoomRequestModel room)
{
try
{
var resp = await _roomService.AddARoomAsync(room);
return(Ok(resp));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Post(RoomRequestModel model)
{
if (await IsRoomExistingAsync(model.Number))
{
return(this.BadRequest(new { error_message = "The specified room number is already existing! " }));
}
var roomToCreate = Mapper.Map <Room>(model);
await this.Context.Rooms.AddAsync(roomToCreate);
await this.Context.SaveChangesAsync();
return(Ok(Mapper.Map <AdminDetailedRoomResponseModel>(roomToCreate)));
}
public RoomRequestModel GetListAllRoom(Employee employee, User user, string KeySearch, int page, int pageSize)
{
RoomRequestModel request = new RoomRequestModel();
List <Room> lst = new List <Room>();
if (user != null)
{
lst = db.Rooms.Where(x => x.IsDeleted == 0).ToList();
}
else if (employee.Role == 2)
{
lst = db.Rooms.Where(x => x.IsDeleted == 0 && x.id == employee.RoomID).ToList();
}
request.totalRecord = lst.Count;
request.page = page;
request.pageSize = pageSize;
int startRow = (page - 1) * pageSize;
if (!string.IsNullOrEmpty(KeySearch))
{
request.data = lst.Where(x => x.IsDeleted == 0 && x.RoomName.Contains(KeySearch) || x.RoomShortName.Contains(KeySearch)).OrderBy(x => x.id).Skip(startRow).Take(pageSize).ToList();
}
else
{
request.data = lst.OrderBy(x => x.RoomShortName).Skip(startRow).Take(pageSize).ToList();
}
int totalPage = 0;
if (request.totalRecord % pageSize == 0)
{
totalPage = request.totalRecord / pageSize;
}
else
{
totalPage = request.totalRecord / pageSize + 1;
}
request.totalPage = totalPage;
return(request);
}
public async Task <IActionResult> Put(string number, RoomRequestModel model)
{
var roomToModify = await this.Context.Rooms
.Include(r => r.CurrentResidents)
.FirstOrDefaultAsync(r => r.Number == number);
if (roomToModify == null)
{
return(this.NotFound());
}
if (number != model.Number && await IsRoomExistingAsync(model.Number))
{
return(this.BadRequest(new { error_message = "The specified room number is already existing! " }));
}
if (model.Capacity < roomToModify.CurrentResidents.Count)
{
return(this.BadRequest(new { error_message = "The capacity cannot be lower than the current number of residents" }));
}
if (roomToModify.CurrentResidents.Any(s => s.IsMale != model.IsMale))
{
return(this.BadRequest(new { error_message = "There are residents from the opposite sex already occupying this room!" }));
}
roomToModify.Number = model.Number;
roomToModify.Capacity = (byte)model.Capacity;
roomToModify.IsRA = (bool)model.IsRA;
roomToModify.IsMale = (bool)model.IsMale;
roomToModify.IsReserved = (bool)model.IsReserved;
roomToModify.Comments = model.Comments;
await this.Context.SaveChangesAsync();
return(this.Ok(Mapper.Map <AdminDetailedRoomResponseModel>(roomToModify)));
}
private async void ExecuteSendToServerCommand()
{
GeolocationAccessStatus accessStatus = await Geolocator.RequestAccessAsync();
if (accessStatus == GeolocationAccessStatus.Denied)
{
return;
}
Geolocator geolocator = new Geolocator();
Geoposition position = await geolocator.GetGeopositionAsync();
double latitude = position.Coordinate.Latitude;
double longitude = position.Coordinate.Longitude;
this.Room.Latitude = latitude;
this.Room.Longitude = longitude;
RoomRequestModel roomDatabaseModel = new RoomRequestModel
{
Geometry = await RoomGeometryViewModel.CreateFromRoom(this.Room),
Room = this.Room
};
string requestBody = JsonConvert.SerializeObject(roomDatabaseModel);
HttpStringContent requestContent = new HttpStringContent(requestBody, UnicodeEncoding.Utf8, "application/json");
Data data = new Data();
UserDatabaseModel currentUser = await data.GetCurrentUser();
if (currentUser == null || string.IsNullOrEmpty(currentUser.Token))
{
MessageDialogNotifier.Notify("You must be logged in to send room information on the server.");
return;
}
string token = currentUser.Token;
Requester requester = new Requester();
string serverResult = string.Empty;
try
{
serverResult = await requester.PostJsonAsync("/api/roomGeometry", requestContent, token);
}
catch (COMException)
{
MessageDialogNotifier.Notify("There was an error on the server. Please contact the server administrators..");
}
RoomRequestModel result = JsonConvert.DeserializeObject<RoomRequestModel>(serverResult);
if (result == null)
{
MessageDialogNotifier.Notify("The room information was not valid or you are not authenticated.");
}
else
{
MessageDialogNotifier.Notify("The room information was successfully saved in the database.");
}
}
public async Task <ObjectResult> AddAsync([FromBody] RoomRequestModel model)
{
var result = await _roomService.AddAsync(model);
return(BaseResult(result));
}
public async Task DeleteRoom(RoomRequestModel roomRequestModel)
{
var room = _mapper.Map <Room>(roomRequestModel);
await _roomRepository.DeleteAsync(room);
}
public async Task <ObjectResult> UpdateAsync([FromRoute] int id, [FromBody] RoomRequestModel model)
{
var result = await _roomService.UpdateAsync(id, model);
return(BaseResult(result));
}
public async Task <IActionResult> Delete([FromBody] RoomRequestModel model)
{
await _roomService.DeleteRoom(model);
return(Ok());
}
public async Task <IActionResult> Update([FromBody] RoomRequestModel model)
{
var response = await _roomService.UpdateRoom(model);
return(Ok(response));
}
public async Task <ActionResult> AddNewRoomAsync(RoomRequestModel roomRequestModel)
{
var room = await _roomService.AddNewRoomAsync(roomRequestModel);
return(Ok(room));
}
