public void Setup()
{
repo = new RoomRepository();
repo.Add(new Room(1, "kitchen", 23));
repo.Add(new Room(2, "bedroom", 26));
repo.Add(new Room(3, "bathroom", 19));
}
public void SetupController()
{
//arrange
var testRoom1 = new Room(1, "testRoom1", new DateTime(2000, 12, 12));
var testRoom2 = new Room(2, "testRoom2", new DateTime(2001, 12, 12));
var testAccount = new Account(1, "ashley", "*****@*****.**", AccountType.Full);
_authenticationManager = new MockTimeWarpAuthenticationManager();
var token = _authenticationManager.AddUser(new AccountPassword(testAccount, ""));
_request = HttpRequestMock.MockRequest();
_request.Headers.Add("login-token", token);
_roomRepository = new MockRoomRepository();
_roomRepository.Add(testRoom1);
_roomRepository.Add(testRoom2);
_accountRepository = new MockAccountsRepository();
_accountRepository.Add(testAccount);
_nowProvider = new FakeNowProvider();
var roomsController = new RoomInfoController(_roomRepository, _accountRepository, _authenticationManager,
_nowProvider);
_globalRoomInfoController = new GlobalRoomInfoController(_roomRepository);
_roomInfoController = roomsController;
}
public async Task <RoomResponse> Create(CreateRoomRequest model)
{
Room room = _mapper.Map <CreateRoomRequest, Room>(model);
await _roomRepository.Add(room);
RoomResponse response = _mapper.Map <Room, RoomResponse>(room);
return(response);
}
public RoomService()
{
if (_repoReference == null)
{
_repoReference = new RoomRepository();
_repoReference.Add(new Room(1, "kitchen"));
_repoReference.Add(new Room(2, "bedroom"));
_repoReference.Add(new Room(3, "bathroom"));
_repoReference.Add(new Room(4, "livingroom"));
}
}
public void Post(HttpRequestMessage request)
{
var token = request.GetToken();
if (string.IsNullOrWhiteSpace(token))
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
ReasonPhrase = "no token"
});
}
Log.DebugFormat("logout for token ({0})", token);
long accountId;
if (_authenticationManager.TryAuthenticateForWriteOperation(token, out accountId))
{
_authenticationManager.Invalidate(token);
var account = _accountRepository.Get(accountId);
if (account.AccountType == AccountType.Quick)
{
var rooms = _roomRepository.GetRooms(accountId);
foreach (var room in rooms)
{
room.Remove(account);
_roomRepository.Add(room);
}
}
}
}
public async Task <IActionResult> CreateRoom([FromBody] SaveRoomResource roomResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var room = mapper.Map <SaveRoomResource, Room>(roomResource);
var nameExist = await repository.RoomNameExist(room);
if (nameExist != null)
{
return(Conflict("Room name already exists"));
}
repository.Add(room);
await unitOfWork.CompleteAsync();
room = await repository.GetRoom(room.Id);
var result = mapper.Map <Room, RoomResource>(room);
return(Ok(result));
}
public Room Add(RoomEntity info)
{
Room resultRoom = new Room();
try
{
if (info != null)
{
var room = new Room
{
FullName = info.FullName,
Email = info.Email,
UserID = info.UserID,
RoomName = info.RoomName,
Alias = info.Alias,
Phone = info.Phone,
Address = info.Address,
RoomTypeID = info.RoomTypeID,
Image = info.Image,
MoreImages = info.MoreImages,
WardID = info.WardID,
DistrictID = info.DistrictID,
ProvinceID = info.ProvinceID,
Acreage = info.Acreage,
Price = info.Price,
Lat = info.Lat,
Lng = info.Lng,
Description = info.Description,
Content = info.Content,
CreateDate = DateTime.Now,
Status = false,
};
if (info.MoreInfomations != null)
{
MoreInfomation modal = new MoreInfomation
{
BedroomNumber = info.MoreInfomations.BedroomNumber,
Compass = info.MoreInfomations.Compass,
Convenient = info.MoreInfomations.Convenient,
ElectricPrice = info.MoreInfomations.ElectricPrice,
FloorNumber = info.MoreInfomations.FloorNumber,
ToiletNumber = info.MoreInfomations.ToiletNumber,
WaterPrice = info.MoreInfomations.WaterPrice
};
var result = _moreInfomationRepository.Add(modal);
_unitOfWork.Commit();
room.MoreInfomationID = result.MoreInfomationID;
}
resultRoom = _roomRepository.Add(room);
_unitOfWork.Commit();
}
}
catch (Exception ex)
{
string FunctionName = string.Format("AddRoom('{0}')", info);
Common.Logs.LogCommon.WriteError(ex.ToString(), FunctionName);
return(null);
}
return(resultRoom);
}
public ActionResult Create(Room room, HttpPostedFileBase filesInput)
{
if (ModelState.IsValid)
{
string fileName = "";
if (filesInput != null && filesInput.ContentLength > 0)
{
try
{
fileName = Path.GetFileName(filesInput.FileName);
string path = Path.Combine(Server.MapPath(_ImagesPath), fileName);
filesInput.SaveAs(path);
}
catch (Exception)
{
throw;
}
}
var resultAdd = _roomRepository.Add(room);
if (resultAdd)
{
return(Content($"<script language='javascript' type='text/javascript'> alert('Thêm thành công'); window.location.href='https://localhost:44316/Admin/HotelsManagement/Edit/'+{room.HotelId} </script>"));
}
}
return(Content("<script language='javascript' type='text/javascript'> alert('Thêm thất bại '); window.location.href='https://localhost:44316/Admin/HotelsManagement' </script>"));
}
public IRoom CreateNewRoom(int roomNumber, double price, int capacity)
{
var room = _factory.Create(roomNumber, capacity, price);
_repository.Add(room);
return(room);
}
public async Task <ActionResult <Room> > PostRoom(Room room)
{
repo.Add(room);
repo.SaveChanges();
return(StatusCode(201));
}
public void AddNewRoom(RoomInput input)
{
var room = RoomMapping.Map(input);
_repository.Add(room);
_unitOfWork.Commit();
}
public async Task <Room> CreateRoom(int gameTypeID)
{
var gameType = await _gameTypeRepository.GetById(gameTypeID);
if (gameType == null)
{
throw new NotFoundException("Invalid Game Type", $"Game Type ID {gameTypeID} is not valid.");
}
if (!gameType.IsActive)
{
throw new NotFoundException("Invalid Game Type", $"Game Type is not available at the moment. Please try again later!");
}
// TODO: ensure uniqueness among game type and room code
var roomCode = GenerateRoomCode();
var room = new Room
{
GameType = gameType,
RoomCode = roomCode,
ExpireDate = DateTime.Now.AddMinutes(60)
};
await _roomRepository.Add(room);
return(room);
}
public void InsertRoom(RoomDto r)
{
try
{
//check if exist room with the same name
var exist = _roomRepository.GetAll().Any(x => x.Name.ToLower() == r.Name.ToLower());
if (!exist)
{
var newR = new Room()
{
Name = r.Name,
SeatsNumber = r.SeatsNumber,
IsAvailable = r.IsAvailable,
BuildingId = r.BuildingId,
CreatedOn = DateTime.Now,
UpdatedOn = DateTime.Now
};
_roomRepository.Add(newR);
LogManager.Debug($"Inserita nuova sala (Nome:{newR.Name}, Sedute:{newR.SeatsNumber})");
}
else
{
throw new Exception($"E' già presente una sala con nome '{r.Name}'");
}
}
catch (Exception ex)
{
LogManager.Error(ex);
throw ex;
}
}
public CreateRoomResponse CreateRoom(CreateRoomRequest request)
{
CreateRoomResponse response = new CreateRoomResponse();
Room room = new Room();
room.RoomName = request.RoomName;
room.Address = request.Address;
room.PhoneNumber = request.PhoneNumber;
room.Users = request.Users.ConvertToUsers();
if (room.GetBrokenRules().Count() > 0)
{
response.Errors = room.GetBrokenRules().ToList();
}
else
{
try {
_roomRepository.Add(room);
_uow.Commit();
response.Errors = new List <BusinessRule>();
} catch (Exception ex)
{
List <BusinessRule> errors = new List <BusinessRule>();
do
{
errors.Add(new BusinessRule("DAL", "DAL_ERROR: " + ex.Message));
ex = ex.InnerException;
} while (ex != null);
response.Errors = errors;
}
}
return(response);
}
public void CreateRoom(CreateRoomDTO roomDTO)
{
var roomDomain = _mapper.Map <CreateRoomDTO, Room>(roomDTO);
_repository.Add(roomDomain);
_repository.Save();
}
public async Task <IActionResult> Create([FromBody] RoomViewModel model)
{
if (model == null)
{
return(StatusCode(400, "Invalid parameter(s)."));
}
Room room = new Room
{
RoomCode = model.RoomCode,
HasSmartboard = model.HasSmartboard,
HasComputer = model.HasComputer,
HasWindows = model.HasWindows,
StudentCapacity = model.StudentCapacity
};
// Insert room
var result = await _roomRepository.Add(room);
if (result == null)
{
return(StatusCode(500, "A problem occured while saving the room. Please try again!"));
}
return(Ok(new RoomViewModel
{
RoomCode = result.RoomCode,
HasComputer = result.HasComputer,
HasSmartboard = result.HasSmartboard,
HasWindows = result.HasWindows,
StudentCapacity = result.StudentCapacity
}));
}
public void Add(Room room)
{
if (_roomRepository.GetAll().Any(r => r.Number == room.Number))
{
throw new InvalidOperationException("Комната с таким номером уже существует!");
}
_roomRepository.Add(room);
}
public void Handle(CreateRoomCommand Message)
{
if (Message != null)
{
var room = _mapper.Map <Room>(Message);
_repository.Add(room);
}
}
public IActionResult PostRoom([FromBody] Room room)
{
using (var scope = new TransactionScope())
{
_roomRepository.Add(room);
scope.Complete();
return(CreatedAtAction(nameof(GetRoom), new { id = room.RoomId }, room));
}
}
public async Task <ActionResult <Room> > PostRoom(Room room)
{
if (!_repo.isRoomExist(room))
{
_repo.Add(room);
return(StatusCode(201));
}
return(StatusCode(409));
}
public RoomSimpleModel Execute(CreateRoomModel model)
{
var room = _mapper.Map <Room>(model);
_roomRepository.Add(room);
room.RoomCode = GenerateRoomCode();
_unitOfWork.Save();
return(_mapper.Map <RoomSimpleModel>(room));
}
public ActionResult Create([Bind(Include = "ID,Size,Type")] Room room)
{
if (ModelState.IsValid)
{
_roomRepository.Add(room);
return(RedirectToAction("Index"));
}
return(View(room));
}
public ActionResult Create([Bind(Include = "Id,Type,Size")] Room room)
{
if (ModelState.IsValid && (room.Size == 2 || room.Size == 3 || room.Size == 5) && room.Type != null && (room.Type == "Weeb" || room.Type == "Game" || room.Type == "Werk" || room.Type == "Rust" || room.Type == "Vecht"))
{
_roomRepository.Add(room);
return(RedirectToAction("Index"));
}
return(View(room));
}
public Room Add(Room room)
{
if (!room.IsValid())
{
return(room);
}
return(_roomRepository.Add(room));
//Validations here
}
public ValidationResult Add(Room room)
{
if (!room.IsValid)
{
return(room.ValidationErrors.ToValidationResult());
}
_validationResult.Entity = _repository.Add(room);
return(_validationResult);
}
public async Task Add(string code)
{
var codeExist = await _roomRepository.CodeExist(code);
if (codeExist)
{
throw new Exception("Code already exist");
}
_roomRepository.Add();
}
public long AddRoom(Room room)
{
if (room == null)
{
return(0);
}
var addRoom = _roomRepository.Add(room);
var idRoom = addRoom;
return(idRoom);
}
public Room Add(RoomCreationDto roomCreationDto)
{
var uploadResult = UploadImageToFileHostingService(roomCreationDto.Image);
var roomEntity = _mapper.Map <RoomEntity>(roomCreationDto);
roomEntity.ImageUrl = uploadResult.JsonObj["url"].ToString();
var createdRoom = _roomRepository.Add(roomEntity);
return(_mapper.Map <Room>(createdRoom));
}
public ActionResult <ReturnRequest> Post([FromQuery] string nameroom)
{
ReturnRequest result = new ReturnRequest();
result.status = "success";
if (!string.IsNullOrEmpty(nameroom))
{
result.data = roomRepository.Add(nameroom);
}
return(Ok(result));
}
public ActionResult Create([Bind(Include = "Id,Name,Size,Price,Image")] Room room)
{
if (ModelState.IsValid)
{
_rooms.Add(room);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View("Create", room));
}
