public IActionResult Post([FromBody] CreateRoomViewModel createRoomViewModel)
{
try
{
Room room = new Room()
{
ID = createRoomViewModel.ID,
Number = createRoomViewModel.Number,
RoomType = createRoomViewModel.RoomType,
RoomReservations = createRoomViewModel.RoomReservations
};
if (room.RoomType != null && room.RoomType.ID != 0)
{
RoomType roomTypeFromDropDownList = iRoomTypeRepository.GetRoomTypeByID(room.RoomType.ID);
room.RoomType = roomTypeFromDropDownList;
}
iRoomRepository.CreateRoom(room);
Uri uri = new Uri(Url.Link("GetRoomByID", new { Id = room.ID }));
iUnitOfWork.Save();
return(Created(uri, room.ID.ToString()));
}
catch (Exception ex)
{
return(Content(ex.ToString(), BadRequest().ToString()));
}
}
public ActionResult Create(CreateRoomViewModel createRoomViewModel)
{
if (!ModelState.IsValid)
{
return(View(createRoomViewModel));
}
if (createRoomViewModel.ImageFile != null)
{
string filename = Path.GetFileNameWithoutExtension(createRoomViewModel.ImageFile.FileName);
string extension = Path.GetExtension(createRoomViewModel.ImageFile.FileName);
filename = filename + DateTime.Now.ToString("yymmssfff") + extension;
createRoomViewModel.Image = "~/Images/" + filename;
filename = Path.Combine(Server.MapPath("~/Images/"), filename);
createRoomViewModel.ImageFile.SaveAs(filename);
}
else
{
createRoomViewModel.Image = "~/Images/noimage.jpg";
}
db.Rooms.Add(CreateRoomViewModelToRoom.CreateMapper()
.Map <CreateRoomViewModel, Room>(createRoomViewModel));
db.SaveChanges();
return(RedirectToAction("Index"));
}
// GET: Rooms/Create
public IActionResult Create()
{
//Deny non-users:
if (HttpContext.Session.GetString("Username") == null)
{
return(Redirect("/Home/Login"));
}
//Deny non-admins:
FileMember user = _context.FileMembers.Single(u => u.Email == HttpContext.Session.GetString("Username"));
if (user.Role != Role.Admin)
{
return(Redirect("/Buildings/Index"));
}
//ViewData["BuildingID"] = new SelectList(_context.Buildings, "ID", "ID");
CreateRoomViewModel createRoomVM = new CreateRoomViewModel();
createRoomVM.Buildings = _context.Buildings.Select(p => new SelectListItem()
{
Value = p.ID.ToString(), Text = p.Name
}).ToList();
return(View(createRoomVM));
}
private void Create_Click(object sender, RoutedEventArgs e)
{
CreateRoomViewModel vm = DataContext as CreateRoomViewModel;
OnDialogCompleted(new CreateDialogCompletedEventArgs(DialogResult.OK,
new RoomPlan(vm.RoomName, vm.RoomNumber, vm.TilesX, vm.TilesY, assignedProject)));
}
public async Task <IActionResult> CreateRoom(CreateRoomViewModel vm)
{
if (ModelState.IsValid)
{
var user = await userManager.GetUserAsync(User);
if (!db.Rooms.Any(r => r.Number == vm.Number && r.HotelId == user.HotelId))
{
var newRoom = new Room()
{
Number = vm.Number,
Square = vm.Square,
Price = vm.Price,
IsFamilyRoom = vm.IsFamilyRoom,
Type = vm.Type,
Hotel = user.Hotel
};
await db.Rooms.AddAsync(newRoom);
await db.SaveChangesAsync();
return(RedirectToAction("Rooms"));
}
else
{
ModelState.AddModelError(string.Empty, "Такая комната уже существует");
}
}
return(View(vm));
}
public async Task <IActionResult> Create(CreateRoomViewModel model)
{
int er = 0;
if (ModelState.IsValid && (er = db.Rooms.Count(p => p.RoomType == model.RoomType)) == 0)
{
Room room = new Room
{
RoomType = model.RoomType,
RoomCapacity = model.RoomCapacity,
RoomDescription = model.RoomDescription,
RoomPrice = model.RoomPrice
};
await db.Rooms.AddAsync(room);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
if (er != 0)
{
ModelState.AddModelError("RoomType", "Record with the same type already exists");
}
return(View(model));
}
public async Task <IActionResult> Create([Bind("Capacity,Type,Free,Price,PriceChildren,Number")] CreateRoomViewModel roomVM)
{
if (roomVM.Price < 0)
{
ModelState.AddModelError("Price", "The price must be positive");
}
if (roomVM.PriceChildren < 0)
{
ModelState.AddModelError("PriceChildren", "The price for children must be positive");
}
if (await _context.Rooms.Where(x => x.Number == roomVM.Number).CountAsync() != 0)
{
ModelState.AddModelError("Number", "Room with the same number already exists");
}
if (ModelState.IsValid)
{
var room = new Room
{
Id = Guid.NewGuid().ToString(),
Capacity = roomVM.Capacity,
Type = roomVM.Type,
Price = roomVM.Price,
PriceChildren = roomVM.PriceChildren,
Number = roomVM.Number,
Free = true
};
_context.Add(room);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(roomVM));
}
public async Task <ActionResult> Create(CreateRoomViewModel viewModel)
{
var user = await GetApplicationUser();
if (user == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var room = new Room()
{
CreatedAt = DateTime.Now,
LatestBroadcastDate = DateTime.Now,
AccessCode = viewModel.AccessCode,
Description = viewModel.Description,
DisplayName = viewModel.DisplayName,
IsHidden = viewModel.IsHidden,
IsPrivate = viewModel.IsPrivate,
Name = viewModel.Name,
Id = Guid.NewGuid().ToString(),
Owner = user,
BroadcastToken = Guid.NewGuid().ToString()
};
db.Rooms.AddOrUpdate(room);
await db.SaveChangesAsync();
return(RedirectToAction("Details", new { name = room.Name }));
}
public IActionResult Index(CreateRoomViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
var user = new User {
Name = vm.UserName
};
var room = new Room
{
Name = vm.Name,
Uid = Guid.NewGuid().ToString().Replace("-", string.Empty),
Creator = user,
};
user.Room = room;
//_userService.Save(user, true);
_roomservice.Save(room, true);
string roomAndUserUid = WebUtility.UrlEncode(_encryptService.Encrypt($"{room.Uid}&{user.Name}"));
return(RedirectToAction("Room", new { roomAndUserUid = roomAndUserUid }));
}
public async Task <IActionResult> CreateRoom(CreateRoomViewModel model)
{
if (ModelState.IsValid)
{
Room newRoom = new Room
{
Number = model.Number,
Floor = model.Floor,
Capacity = model.Capacity,
Price = model.Price,
IsReady = model.IsReady,
Comfort = model.Comfort,
Description = model.Description ?? string.Empty
};
await this._applicationContext.Rooms.AddAsync(newRoom);
await this._applicationContext.SaveChangesAsync();
await this.UploadAsync(model.Photos, model.Number);
return(RedirectToAction(nameof(Rooms)));
}
return(View(model));
}
public ActionResult CreateRoom()
{
var model = new CreateRoomViewModel();
model.Categories = context.Categories.ToList();
model.Hotels = context.Hotels.ToList();
return(View(model));
}
private void CheckRoomNameExists()
{
if (assignedProject != null)
{
CreateRoomViewModel vm = DataContext as CreateRoomViewModel;
vm.RoomNameExists = assignedProject.RoomPlans.Any(x => x.RoomPlan.Name == vm.RoomName);
}
}
// GET: Room/Create
public IActionResult Create()
{
CreateRoomViewModel viewModel = new CreateRoomViewModel();
viewModel.Room = new Room();
viewModel.Locations = new SelectList(_context.Location, "LocationID", "NameAndPlace");
return(View(viewModel));
}
public IActionResult CreateRoom()
{
var allTopics = _topicService.GetAllTopics();
var model = new CreateRoomViewModel
{
ListOfTopics = allTopics.ToSelectList(0, false, x => x.Id, x => x.TopicName)
};
return(View(model));
}
public IActionResult Post([FromBody] CreateRoomViewModel vm)
{
return(ApiAction(() =>
{
var contract = _mapper.Map <CreateRoomContract>(vm);
var returnContract = _RoomService.Create(contract);
return Created("Get", _mapper.Map <CreatedRoomViewModel>(returnContract));
}));
}
public async Task <IActionResult> CreateRoom(CreateRoomViewModel model)
{
if (this.ModelState.IsValid)
{
await _specialityRepository.CreateRoomAsync(model);
return(this.RedirectToAction($"Details/{model.SpecialityId}"));
}
return(this.View(model));
}
public async Task <IActionResult> Create(CreateRoomViewModel viewModel)
{
if (ModelState.IsValid)
{
_context.Add(viewModel.Room);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
viewModel.Locations = new SelectList(_context.Location, "LocationID", "NameAndPlace", viewModel.Room.LocationID);
return(View(viewModel));
}
public void PostCreateNewRoomDelegatesToRoomRepository()
{
var controller = CreateController();
var viewModel = new CreateRoomViewModel {
NewRoomName = "Test Room"
};
controller.Create(viewModel);
mockRoomRepository.Verify(repository => repository.CreateRoom("Test Room"));
}
public IActionResult Create(CreateRoomViewModel model)
{
var user = _applicationDbContext.Users.First(u => u.Id.Equals(User.GetUserId()));
var room = new Room {
VideoId = model.VideoId, Name = model.Name, Description = model.Description, Duration = model.Duration, CreatedBy = user
};
_applicationDbContext.Rooms.Add(room);
_applicationDbContext.SaveChanges();
_emailSender.SendEmailAsync(user.Email, "New room", "Congratulations! You have created a new room for syncronizing videoes. What a time to be alive!");
return(RedirectToAction("Show", new { id = room.Id }));
}
public IActionResult CreateRoom(CreateRoomViewModel model)
{
if (!ModelState.IsValid)
{
AddErrors("Error on creating room!");
return(View());
}
var roomDto = _mapper.Map <CreateRoomViewModel, CreateRoomDTO>(model);
_roomService.CreateRoom(roomDto);
return(RedirectToHomePage());
}
public ActionResult CreateRoom(CreateRoomViewModel room)
{
if (ModelState.IsValid)
{
var config = new MapperConfiguration(x => x.CreateMap <CreateRoomViewModel, Room>()).CreateMapper();
var newRoom = config.Map <CreateRoomViewModel, Room>(room);
context.Rooms.Add(newRoom);
context.SaveChanges();
TempData["color"] = "green";
TempData["message"] = string.Format(" Кімнату категорії \"{0}\" створено", newRoom.Category);
return(RedirectToAction("RoomList"));
}
return(View());
}
public void PostCreateNewRoomRedirectsToViewResult()
{
var controller = CreateController();
var viewModel = new CreateRoomViewModel {
NewRoomName = "Test Room"
};
var result = controller.Create(viewModel);
Assert.That(result, Is.InstanceOf <RedirectToRouteResult>());
var redirectResult = result as RedirectToRouteResult;
Assert.That(redirectResult.RouteValues["Action"], Is.EqualTo("List"));
}
public void PostCreateNewRoomWithInvalidRoomNameCausesValidationError(string roomName)
{
var controller = CreateController();
var viewModel = new CreateRoomViewModel {
NewRoomName = roomName
};
var context = new ValidationContext(viewModel, serviceProvider: null, items: null);
var results = new List <ValidationResult>();
var isValid = Validator.TryValidateObject(viewModel, context, results);
Assert.That(isValid, Is.False);
}
public void PostCreateNewRoomWithInvalidRoomNameCausesValidationError(string roomName)
{
// Arrange
var controller = CreateRoomController();
var model = new CreateRoomViewModel {
NewRoomName = roomName
};
var context = new ValidationContext(model, null, null);
var results = new List <ValidationResult>();
// Act
var isValid = Validator.TryValidateObject(model, context, results);
// Assert
Assert.IsFalse(isValid);
}
public ActionResult Create(CreateRoomViewModel model)
{
ActionResult result;
if (ModelState.IsValid)
{
roomRepository.CreateRoom(model.NewRoomName);
result = RedirectToAction("List");
}
else
{
result = View("Create", model);
}
return(result);
}
public void PostCreateNewRoomWithInvalidRoomNameShowsCreateView(string roomName)
{
var controller = CreateController();
var viewModel = new CreateRoomViewModel {
NewRoomName = roomName
};
controller.ViewData.ModelState.AddModelError("Room Name", "Room name is required");
var result = controller.Create(viewModel);
Assert.That(result, Is.InstanceOf <ViewResult>());
var viewResult = result as ViewResult;
Assert.That(viewResult.View, Is.Null);
Assert.That(viewResult.Model, Is.EqualTo(viewModel));
}
public ActionResult CreateRoom(CreateRoomViewModel room)
{
if (ModelState.IsValid)
{
var config = new MapperConfiguration(x => x.CreateMap <CreateRoomViewModel, Room>()).CreateMapper();
var newRoom = config.Map <CreateRoomViewModel, Room>(room);
newRoom.Category = context.Categories.Find(room.SelectedCategoryId);
newRoom.Hotel = context.Hotels.Find(room.SelectedHotelId);
context.Rooms.Add(newRoom);
context.SaveChanges();
TempData["color"] = "green";
TempData["message"] = string.Format(" Комната категории \"{0}\" добавлена в отель \"{1}\"", newRoom.Category.Name, newRoom.Hotel.Name);
}
room = new CreateRoomViewModel();
room.Categories = context.Categories.ToList();
room.Hotels = context.Hotels.ToList();
return(View(room));
}
public async Task <ActionResult> Create(CreateRoomViewModel createRoomViewModel)
{
try
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
using (db)
{
String username = User.Identity.Name;
ApplicationUser user = await UserManager.FindByNameAsync(username);
Room newRoom = new Room()
{
floor = createRoomViewModel.Number, created_by = user.Id, created_at = DateTime.Now
};
db.Rooms.Add(newRoom);
//ActionLog action = new ActionLog() { UserId=user.Id,ModelName="Room", ActionType="Create" ,ActionPayload=JsonConvert.SerializeObject(newRoom,Formatting.Indented)};
//db.ActionLogs.Add(action);
await db.SaveChangesAsync();
TempData["actionStatus"] = "success";
TempData["actionMessage"] = "Room created successfully";
return(RedirectToAction("Index", "Home"));
}
}
else
{
TempData["actionStatus"] = "danger";
TempData["actionMessage"] = "Model State is invalid";
}
return(View(createRoomViewModel));
}
catch (Exception e)
{
TempData["actionStatus"] = "danger";
TempData["actionMessage"] = e.Message;
return(View(createRoomViewModel));
}
}
public ActionResult AddRoom(CreateRoomViewModel newRoom, HttpPostedFileBase file)
{
if (ModelState.IsValid)
{
var roomDto = new RoomDto();
roomDto.Capacity = newRoom.Capacity;
roomDto.HasAirCondition = newRoom.HasAirCondition;
roomDto.HasBalcony = newRoom.HasBalcony;
roomDto.HasKitchen = newRoom.HasKitchen;
roomDto.HasPrivateBathroom = newRoom.HasPrivateBathroom;
roomDto.HasTv = newRoom.HasTv;
roomDto.Price = newRoom.Price;
roomDto.Quadrature = newRoom.Quadrature;
roomDto.Type = newRoom.Type;
roomDto.PhotoData = FileToByteArray(file);
_hotelsManager.AddRoom(roomDto);
return(RedirectToAction("Menage"));
}
else
{
return(View(newRoom));
}
}
public CreateRoomPopup()
{
InitializeComponent();
vm = new CreateRoomViewModel();
BindingContext = vm;
}
