public async Task <IActionResult> EditRoom([FromBody] EditRoomCommand command)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState.Values.Select(x => x.Errors)));
            }

            var response = await _mediator.Send(command, HttpContext.RequestAborted);

            if (!response.IsValid)
            {
                return(BadRequest(response));
            }

            return(Ok(response.Value));
        }
        public AccomodationManagementViewModel()
        {
            _accomodationRepository = DataManagementService.Instance.MainRepository.AccomodationRepository;
            _locationRepository     = DataManagementService.Instance.MainRepository.LocationRepository;

            _accomodationFactory  = new AccomodationFactory();
            _accomodation         = _accomodationFactory.BuildAccomodation(_acomodationType);
            _selectedAccomodation = _accomodationFactory.BuildAccomodation(_acomodationType);

            _roomFactory  = new RoomFactory();
            _room         = _roomFactory.BuildRoom(_roomType);
            _selectedRoom = _roomFactory.BuildRoom(_roomType);

            _addAccomodationCommand    = new AddAccomodationCommand(this);
            _deleteAccomodationCommand = new DeleteAccomodationCommand(this);
            _editAccomodationCommand   = new EditAccomodationCommand(this);
            _saveAccomodationCommand   = new SaveAccomodationCommand(this);
            _addRoomCommand            = new AddRoomCommand(this);
            _editRoomCommand           = new EditRoomCommand(this);
            _saveRoomCommand           = new SaveRoomCommand(this);
        }
        public async Task <Result <EditRoomsResponse> > Handle(EditRoomCommand request, CancellationToken cancellationToken)
        {
            using (_queueUnitOfWork)
            {
                try
                {
                    var RoomExists = await _queueUnitOfWork.Repository <Rooms>().Get(x => x.Id == request.Id).FirstOrDefaultAsync();

                    if (RoomExists != null)
                    {
                        RoomExists.RoomName    = request.RoomName;
                        RoomExists.DisplayName = request.DisplayName;
                        RoomExists.Description = request.Description;
                        RoomExists.UpdateDate  = DateTime.Now;
                        RoomExists.UpdatedBy   = request.UpdatedBy;
                        RoomExists.Active      = request.Active;
                        RoomExists.DeleteFlag  = request.DeleteFlag;

                        _queueUnitOfWork.Repository <Rooms>().Update(RoomExists);
                        await _queueUnitOfWork.SaveAsync();

                        message += "The Room details have been updated successfully";
                        id       = RoomExists.Id;
                    }

                    return(Result <EditRoomsResponse> .Valid(new EditRoomsResponse
                    {
                        Message = message,
                        RoomId = id
                    }));
                }
                catch (Exception ex)
                {
                    Log.Error(ex.Message);
                    return(Result <EditRoomsResponse> .Invalid(ex.Message));
                }
            }
        }