public void RoomCreateTest()
{
var roomCategoryMapper = new MapperConfiguration(
cfg =>
{
cfg.CreateMap <PriceCategory, PriceCategoryDTO>().ReverseMap();
cfg.CreateMap <Category, CategoryDTO>().ReverseMap();
}).CreateMapper();
var roomDTO = new RoomDTO()
{
RoomID = 1,
RoomName = "100",
Active = true,
RoomCategory = roomCategoryMapper.Map <PriceCategory, PriceCategoryDTO>(DataForTests.PriceCategories[0])
};
EFWorkUnitMock.Setup(x => x.Rooms.Create(fromDTOMapper.Map <RoomDTO, Room>(roomDTO)));
var roomService = new RoomService(EFWorkUnitMock.Object);
roomService.Create(roomDTO);
EFWorkUnitMock.Verify(x => x.Rooms.Create(fromDTOMapper.Map <RoomDTO, Room>(roomDTO)));
}
public void CanCreateRoom()
{
var data = new Room
{
Id = 1,
Number = 100,
ComfortLevel = 1,
Capability = 3,
Price = 111,
Created = DateTime.UtcNow,
Modified = DateTime.UtcNow,
HotelId = 1
};
var mockSet = new Mock <DbSet <Room> >();
var mockContext = new Mock <ClientDbContext>();
mockContext.Setup(m => m.Rooms).Returns(mockSet.Object);
var service = new RoomService(mockContext.Object);
service.Create(data);
mockSet.Verify(m => m.Add(It.IsAny <Room>()), Times.Once());
mockContext.Verify(m => m.SaveChanges(), Times.Once);
}
public void CreateRoom_UnderNormalConditions_AddsRoomToRoomList()
{
//arrange
var originalCountOfRooms = _roomList.Count;
var roomToCreate = new RoomDto()
{
RoomId = 5,
RoomDescription = "room description 5",
RoomName = "room name 5"
};
var mockRepo = Mock.Create <IRoomRepository>();
Mock.Arrange(() => mockRepo.Create(Arg.IsAny <Room>())).DoInstead(() => _roomList.Add(roomToCreate)).OccursOnce();
_roomService = new RoomService(mockRepo);
//act
_roomService.Create(roomToCreate);
var actualCountOfRooms = _roomList.Count;
//assert
Mock.Assert(mockRepo);
Assert.That(actualCountOfRooms, Is.EqualTo(originalCountOfRooms + 1));
}
public IActionResult OnPost()
{
if (service.GetDetail(CreateDto.TheaterId, CreateDto.Name) != null)
{
ErrorMessage = CreateDto.Name + " existed";
return(Page());
}
service.Create(CreateDto);
return(Redirect("/Admin/Rooms"));
}
public long Post()
{
string password = Request.Form["password"];
string name = Request.Form["name"];
string timerMinutes = Request.Form["timer"];
if (timerMinutes == string.Empty)
{
timerMinutes = "0";
}
string deckId = Request.Form["deck"];
return(service.Create(LoggedUser, password, name, timerMinutes, deckId));
}
public ActionResult <Room> Create(Room room, string adminId)
{
if (room == null)
{
return(BadRequest());
}
room.AdminId = adminId;
room.UserIds = new List <string>();
_roomService.Create(room);
return(CreatedAtRoute("GetRoom", new { id = room.Id }, room));
}
public async Task <IActionResult> AddRoom(RoomDto room)
{
var level = await _levelService.Get(room.Level);
if (level == null)
{
return(BadRequest("Попытка добавить на несуществующий этаж"));
}
var baseRoom = _mapper.Map <BaseRoom>(room);
baseRoom.Id = Guid.NewGuid().ToString();
var result = await _roomService.Create(baseRoom);
return(JsonResponse.New(_mapper.Map <RoomDto>(result)));
}
public IActionResult Upload(string title, string city, int roomCount, int square, string ownerFullName, string ownerPhone)
{
var room = new Room()
{
Title = title,
City = city,
RoomCount = roomCount,
Square = square,
OwnerFullName = ownerFullName,
OwnerPhone = ownerPhone
};
roomService.Create(room);
return(View());
}
public ActionResult Create(string Id)
{
// ID = Room Name
var roomName = Id;
// Get writer who is creating the room.
var writer = SessionService.GetWriter(HttpContext.Session.GetString(SessionVariables.UserId));
if (writer == null)
{
throw new InvalidOperationException("Unable to create a room, you are unidentified.");
}
if (!ValidationService.ValidateRoomName(roomName).Validated)
{
SessionService.AddMessage(HttpContext.Session, "Your room name was invalid.");
return(View(writer));
}
var room = RoomService.Create(roomName, writer);
ApplicationService.AddRoom(room);
// room.Writers.Add(writer);
// room.PresentWriters.Add(writer);
if (writer.Color != null)
{
if (room.ColorsInUse.Any(c => c.Name == writer.Color.Name))
{
writer.Color = ColorService.RandomColor(room.ColorsInUse);
}
}
else
{
writer.Color = ColorService.RandomColor(room.ColorsInUse);
}
room.ColorsInUse.Add(writer.Color);
return(RedirectToAction("FirstLine", new { Id = room.Code }));
}
public static void Seed(RoomService roomService)
{
if (!roomService.GetRooms().Any())
{
var rooms = new List <Room>()
{
new Room()
{
Number = 1,
NumberOfSeats = 1,
Price = 150.0,
Description = "- 1 single bed\n" +
"- free WiFi\n" +
"- TV",
},
new Room()
{
Number = 2,
NumberOfSeats = 2,
Price = 300.0,
Description = "- 1 extra-large double bed\n" +
"- free WiFi\n" +
"- TV\n" +
"- fridge",
},
new Room()
{
Number = 3,
NumberOfSeats = 3,
Price = 450.0,
Description = "- 1 single bed\n" +
"- 1 extra-large double bed\n" +
"- free WiFi\n" +
"- TV\n" +
"- fridge",
},
};
rooms.ForEach(room => roomService.Create(room));
}
}
public async Task <ActionResult <OperationResult <CreateResponse> > > Create(CreateRequest request)
{
await _roomService.ClearExpired();
TimeSpan lifespan = TimeSpan.Parse(request.ChatLifespan);
DateTimeOffset expireAt = DateTimeOffset.UtcNow + lifespan;
ColorEnum color = ColorHelper.RandomColor();
Room room = await _roomService.Create(request.UserName, (int)color, request.Topic, expireAt, request.OnlyOwnerCanInvite);
return(OperationResult <CreateResponse> .Ok(new CreateResponse
{
RoomTopic = request.Topic,
RoomId = room.Id,
UserId = room.OwnerId,
UserPublicId = room.Owner.PublicId,
RoomExpireAt = expireAt,
OnlyOwnerCanInvite = request.OnlyOwnerCanInvite
}));
}
public async Task CreateNewRoom()
{
var userCreator = new User
{
Name = "Master"
};
await user.Create(userCreator);
var newRoom = new Room
{
Name = "TestRoom",
OwnerID = 1
};
await room.Create(newRoom);
var length = await db.Rooms.CountAsync();
Assert.That(1, Is.EqualTo(length));
}
public ActionResult <Room> Create(Room items)
{
_service.Create(items);
return(CreatedAtRoute("GetRoom", new { id = items.Id.ToString() }, items));
}
// GET: Rooms/Create
public ActionResult Create()
{
var model = _roomService.Create();
return(View(model));
}
public ActionResult <Sala> Create(Sala room)
{
_roomservice.Create(room);
return(CreatedAtRoute("GetRoom", new { id = room.Id.ToString() }, room));
}
public ActionResult Post(Room room)
{
service.Create(room);
return(Ok(room));
}
public Room Create(Room entity) => roomService.Create(entity);
public Room Create(Room room) => service.Create(room);
public async Task CreateRoom(CreateRoomEvent roomData)
{
await Clients.Caller.SendAsync("CreateRoom", await _roomService.Create(roomData));
}
public ActionResult <Room> Create(Room room)
{
_roomService.Create(room);
return(CreatedAtRoute("GetRoom", new { id = room.id.ToString() }, room));
}
static void Main(string[] args)
{
CategoryService categoryService = new CategoryService();
RoomService roomService = new RoomService();
Console.WriteLine("=================== Category =======================");
Console.WriteLine("Query for a Category");
var list = categoryService.GetList();
foreach (var item in list)
{
Console.WriteLine($"CategoryName: {item.CategoryName}, Description: {item.Description}");
}
Console.WriteLine("=================== Insert Category ================");
var category = new Categorys()
{
CategoryName = "Apartment",
Description = "Apartment",
createdBy = "",
CreatedDate = DateTime.Now,
UpdatedBy = "",
UpdatedDate = DateTime.Now
};
//categoryService.Insert(category);
Console.WriteLine("=================== Update Category ================");
var categorys = new Categorys()
{
Id = 2,
CategoryName = "Apartment",
Description = "Apartment",
createdBy = "",
CreatedDate = DateTime.Now,
UpdatedBy = "",
UpdatedDate = DateTime.Now
};
//categoryService.Update(category);
Console.WriteLine("================== DELETE ==================");
//categoryService.Delete(1);
Console.WriteLine("====================================================");
Console.WriteLine("=================== ROOMS ==========================");
Console.WriteLine("==================== GET LIST ======================");
var listRoomInfo = roomService.GetList();
foreach (var item in listRoomInfo)
{
Console.WriteLine($"Name: {item.RoomName}");
}
Console.WriteLine("====================== INSERT ROOMS======================");
var room = new Rooms()
{
RoomName = "Room1",
Address = "DA LAT",
Price = 1000000,
Description = "room 1",
CreatedBy = "",
CreatedDate = DateTime.Now,
UpdatedBy = "",
UpdatedDate = DateTime.Now,
CategoryId = 2,
};
roomService.Create(room, category);
Console.ReadKey();
}
public async Task <Response> Create()
{
return(await _roomService.Create());
}