public async Task <IActionResult> Create(CreateRoomModel model)
{
User user = await CurrentUser;
if (user == null)
{
return(Redirect("/Error"));
}
if (ModelState.IsValid && user != null)
{
if (_repository.isNameUniq(model.Name))
{
Room room = new Room
{
Name = model.Name,
Description = model.Description,
Creator = user,
Private = false
};
int roomId = _repository.CreateRoom(room, user);
return(RedirectToAction("Room", new { roomId }));
}
ModelState.AddModelError("notUniq", "Room with this name already exist.");
}
return(View(model));
}
public Room CreateRoom(CreateRoomModel model)
{
var entity = model.ToDest();
PrepareCreate(entity);
return(context.Room.Add(entity).Entity);
}
// constructor
public CreateRoomViewModel()
{
createRoomModel = new CreateRoomModel();
room = new RoomModel();
CreateRoomCommand = new DelegateCommand(CreateRoom);
ShowCreateRoomCommand = new DelegateCommand(ShowCreateRoom);
}
public async Task AddRoomAsync(CreateRoomModel createRoomModel)
{
await Context.Room.AddAsync(new Room
{
RoomNumber = createRoomModel.RoomNumber,
Capacity = createRoomModel.Capacity,
MovieTheater = createRoomModel.Id
});
await Context.SaveChangesAsync();
}
public void FillForm(CreateRoomModel createRoomModel)
{
_roomIdInput.ActionSendKeys(createRoomModel.RoomNumber);
_typeDropDown.SelectFromDropdownByText(createRoomModel.Type);
_accessibleDropDown.SelectFromDropdownByText(createRoomModel.Accessible);
_roomPriceInput.ActionSendKeys(createRoomModel.Price);
if (string.IsNullOrEmpty(createRoomModel.RoomDetails))
{
return;
}
_roomDetailsLabels.GetElements().First(x => x.Text == createRoomModel.RoomDetails).Click();
}
public IActionResult Post([FromBody] CreateRoomModel newRoom, [FromServices] ICreateRoomCommand createRoomCommand)
{
if (ModelState.IsValid)
{
var storedRoom = createRoomCommand.Execute(newRoom);
return(Created(Request.Path.Value + "/" + storedRoom.Id, storedRoom));
}
else
{
return(BadRequest("Something went wrong"));
}
}
public ValidationData ValidateCreateRoom(ClaimsPrincipal principal,
CreateRoomModel model)
{
var validationData = new ValidationData();
if (string.IsNullOrWhiteSpace(model.Code))
{
validationData.Fail(mess: "Code required", code: AppResultCode.FailValidation);
}
if (string.IsNullOrWhiteSpace(model.Name))
{
validationData.Fail(mess: "Name required", code: AppResultCode.FailValidation);
}
return(validationData);
}
public async Task <int> CreateRoomAsync(CreateRoomModel model, int userId)
{
Room room = _mapper.Map <CreateRoomModel, Room>(model);
var user = await _userManager.FindByIdAsync(userId.ToString());
if (user != null)
{
room.OwnerId = userId;
room.Users.Add(user);
user.UserStatus = UserStatus.InRoom;
user.RoomOrderNumber = 1;
_roomRepository.CreateRoom(room);
await _roomRepository.SaveAsync();
}
return(room.Id);
}
private bool IsCreateRoomModelValid(CreateRoomModel model, Dictionary <string, string> errors)
{
if (string.IsNullOrEmpty(model.RoomName))
{
errors.Add("roomName", "Unesite naziv sobe");
}
else if (model.RoomName.Length > 26)
{
errors.Add("roomName", "Unesite kraći naziv sobe");
}
if (model.IsPrivate && string.IsNullOrEmpty(model.RoomPassword))
{
errors.Add("roomPassword", "Unesite lozinku sobe");
}
return(errors.Count == 0);
}
public async Task <IActionResult> Create(CreateRoomModel createRoom)
{
var errorMessage = String.Empty;
if (!createRoom.ValidateCreateModel(out errorMessage))
{
ModelState.AddModelError(string.Empty, errorMessage);
}
else if (!RoomService.ValidateRoom(createRoom.Id, createRoom.RoomNumber, out errorMessage))
{
ModelState.AddModelError(string.Empty, errorMessage);
}
else
{
await RoomService.AddRoomAsync(createRoom);
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public IActionResult CreateRoom(CreateRoomModel model)
{
var validationData = _service.ValidateCreateRoom(User, model);
if (!validationData.IsValid)
{
return(BadRequest(AppResult.FailValidation(data: validationData)));
}
using (var trans = context.Database.BeginTransaction())
{
var entity = _service.CreateRoom(model);
//log event
var ev = _sysService.GetEventForCreateRoom(
$"Admin {UserEmail} created a new room", User, entity);
_sysService.CreateAppEvent(ev);
//end log event
context.SaveChanges();
trans.Commit();
}
return(NoContent());
}
public async Task <JsonResult> CreateRoom(CreateRoomModel model)
{
Dictionary <string, string> errors = new Dictionary <string, string>();
if (IsCreateRoomModelValid(model, errors))
{
var userId = User.GetUserId();
var roomId = await _roomService.CreateRoomAsync(model, userId);
if (roomId > 0)
{
await _lobbyHubContext.Clients.All.SendAsync("UpdateRoomList");
await _roomHubContext.Clients.All.SendAsync("UpdateUserList");
await _lobbyHubContext.Clients.All.SendAsync("UpdateUserList");
return(Json(new { success = true }));
}
}
return(Json(new { errors }));
}
public async Task <IActionResult> Create([FromBody] CreateRoomModel model)
{
if (false == ModelState.IsValid)
{
return(BadRequest(model));
}
try
{
var id = await mediator.Send(new CreateRoomCommand(model.Name, model.Description));
var room = await mediator.Send(new GetRoomQuery(id));
return(Created(
Url.Action("Get", "Room", new { id }),
mapper.Map <RoomCreatedResult>(room)
));
}
catch (Exception exception)
{
return(BadRequest(exception.Message));
}
}
private static bool IsModelValid(CreateRoomModel model)
{
return(null != model && false == String.IsNullOrEmpty(model.Description));
}
/// <summary>
/// PUT http://localhost:8080/api/room/test1
/// </summary>
/// <param name="alias"></param>
/// <param name="model"></param>
/// <returns></returns>
public async Task <IHttpActionResult> Post([FromUri(Name = "id")] string alias, [FromBody] CreateRoomModel model)
{
if (null == alias)
{
return(NotFound());
}
if (false == IsModelValid(model))
{
return(BadRequest("Bad parameters"));
}
var chat = GrainClient.GrainFactory.GetGrain <IChat>(0);
var room = await chat.RegisterRoomAsync(alias, model.Description);
var link = Url.Link("DefaultApi", new { id = room.Id });
return(Created(new Uri(link), new ExistingRoomModel
{
Id = room.Id,
Alias = room.Alias,
Description = room.Description
}));
}
public async Task <IActionResult> CreateGameRoom([FromHeader] string authToken, [FromBody] CreateRoomModel room)
{
var errMsg = string.Empty;
if (UserContext.User.IsInRoom())
{
return(await GenericResponse(ResponseType.NotAllowed, Constants.Instance.ErrorMessage.Is_In_Game_Room));
}
var gameRoom = EnergoServer.Current.CreateGameRoom(UserContext.User, room.Name, out errMsg);
if (!string.IsNullOrWhiteSpace(errMsg))
{
return(await GenericResponse(ResponseType.InvalidModel, errMsg));
}
ToggleReadyResponse response = null;
if (room.SetReadyMark)
{
response = EnergoServer.Current.RouteAction(new ToggleReadyAction(UserContext.User));
}
return(await SuccessResponse(() =>
{
ServerContext.Current.Chat.AddChannel(UserContext.User, ChatChannelType.Room, gameRoom.Id);
var broadcast = new GameRoomModel(gameRoom).GetInfo(new RoomModelViewOptions(true)
{
UserViewOptions = new UserModelViewOptions(false)
}).AddItem(BroadcastReason, Request.Path.Value);
ServerContext.Current.DuplexNetwork.Broadcast(broadcast);
return new GameRoomModel(gameRoom).GetInfo(new RoomModelViewOptions(true)
{
IsInGame = false,
UserCount = false,
UserViewOptions = new UserModelViewOptions(false)
{
ReadyMark = true
}
});
}).Invoke());
}
public IActionResult CreateRoom(CreateRoomModel model)
{
if (ModelState.IsValid)
{
string protocol = Url.ActionContext.HttpContext.Request.Scheme.ToString();
string host = Url.ActionContext.HttpContext.Request.Host.ToString();
model.Image = model.Image.Replace(protocol + "://", string.Empty);
model.Image = model.Image.Replace(host, string.Empty);
// TODO: Придумать другую проверку
model.Image = Url.IsLocalUrl(model.Image) ? model.Image : null;
User user = GetCurrentUserAsync().Result;
Calendar calendar = new Calendar
{
Id = Guid.NewGuid().ToString(),
DateFrom = model.DateFrom,
DateTo = model.DateTo
};
_context.Calendar.Add(calendar);
Room room = new Room
{
Id = Guid.NewGuid().ToString(),
Name = model.Name,
Calendar = calendar,
CalendarId = calendar.Id,
CreationDate = DateTime.Now,
CreatorId = user.Id,
Image = model.Image ?? "/images/room_avatar/default.png" // TODO: Работать с файловой системой сервера
};
_context.Room.Add(room);
UserRoom userRoom = new UserRoom
{
UserId = user.Id,
User = user,
Room = room,
RoomId = room.Id,
ConnectionDate = DateTime.Now,
ExitDate = DateTime.Now, // TODO: Исправить ошибку с недопустимым значением NULL
};
_context.UserRoom.Add(userRoom);
_context.SaveChanges();
// Возврат пользователя на предыдущую страницу веб-приложения
//UserRoom filledUserRoom = RoomController.GetFilledUserRoom(userRoom.User, userRoom.RoomId, _context);
return(RedirectToAction("Index", "Room", new { id = userRoom.RoomId }));
// При редиректе не успевает пройти анимация
//return Content(userRoom.RoomId);
//return Json(new { status = "success", id = room.Id });
//return RedirectToAction("Index");
}
else
{
//ModelState.AddModelError(String.Empty, "Ошибка при создании комнаты");
return(BadRequest(ModelState));
}
}
public override void SetController(BaseController c)
{
base.SetController(c);
Inst = this;
}
