コード例 #1
0
        public IEnumerable <RoomVM> GetAllRooms()
        {
            var mng   = new RoomManager();
            var rooms = RoomMapper.MapListOfRooms(mng.GetAllRooms());

            return(rooms);
        }
コード例 #2
0
        public Node EnableRoomEncryption(EnableRoomEncryptionRequest request)
        {
            _client.Executor.CheckApiServerVersion();

            #region Parameter Validation

            request.MustNotNull(nameof(request));
            request.DataRoomRescueKeyPassword.MustNotNullOrEmptyOrWhitespace(nameof(request.DataRoomRescueKeyPassword), true);
            request.Id.MustPositive(nameof(request.Id));

            #endregion

            ApiUserKeyPair apiDataRoomRescueKey = null;
            if (request.DataRoomRescueKeyPassword != null)
            {
                try {
                    UserKeyPair cryptoPair = Crypto.Sdk.Crypto.GenerateUserKeyPair(request.DataRoomRescueKeyPassword);
                    apiDataRoomRescueKey = UserMapper.ToApiUserKeyPair(cryptoPair);
                } catch (CryptoException ce) {
                    DracoonClient.Log.Debug(Logtag, $"Generation of user key pair failed with '{ce.Message}'!");
                    throw new DracoonCryptoException(CryptoErrorMapper.ParseCause(ce), ce);
                }
            }

            ApiEnableRoomEncryptionRequest apiEnableRoomEncryptionRequest =
                RoomMapper.ToApiEnableRoomEncryptionRequest(request, apiDataRoomRescueKey);
            IRestRequest restRequest = _client.Builder.PutEnableRoomEncryption(request.Id, apiEnableRoomEncryptionRequest);
            ApiNode      result      = _client.Executor.DoSyncApiCall <ApiNode>(restRequest, RequestType.PutEnableRoomEncryption);
            return(NodeMapper.FromApiNode(result));
        }
コード例 #3
0
        public List <Room> RetrieveAllById(int hotel)
        {
            var roomMapper = new RoomMapper();

            try
            {
                var lstResult = SqlDao.GetInstance()
                                .ExecuteQueryProcedure(
                    roomMapper.GetRetriveAllByIdStatement(hotel)
                    );

                if (lstResult.Count <= 0)
                {
                    return(default(List <Room>));
                }

                var obj = EntityObjectMapper.BuildObjects(lstResult);

                return(obj.Cast <Room>().ToList());
            }
            catch (Exception e)
            {
                ManageException(e);
            }

            return(null);
        }
コード例 #4
0
        public void ToApiCreateRoomRequest()
        {
            // ARRANGE
            GroupMemberAcceptance paramGMA = GroupMemberAcceptance.AutoAllow;
            string expectedGMAValue        = "autoallow";

            ApiCreateRoomRequest expected = FactoryRoom.ApiCreateRoomRequest;

            expected.NewGroupMemberAcceptance = expectedGMAValue;

            CreateRoomRequest param = new CreateRoomRequest(expected.Name)
            {
                ParentId = expected.ParentId.Value,
                Quota    = expected.Quota,
                Notes    = expected.Notes,
                RecycleBinRetentionPeriod = expected.RecycleBinRetentionPeriod,
                HasInheritPermissions     = expected.InheritPermissions.Value,
                AdminUserIds             = expected.AdminIds,
                AdminGroupIds            = expected.AdminGroupIds,
                NewGroupMemberAcceptance = paramGMA
            };

            Mock.Arrange(() => EnumConverter.ConvertGroupMemberAcceptanceToValue(paramGMA)).Returns(expectedGMAValue);

            // ACT
            ApiCreateRoomRequest actual = RoomMapper.ToApiCreateRoomRequest(param);

            // ASSERT
            Assert.Equal(expected, actual, new ApiCreateRoomRequestComparer());
        }
コード例 #5
0
        public T RetrieveByRoomNumber <T>(Room room)
        {
            var roomMapper = new RoomMapper();

            try
            {
                var instance  = SqlDao.GetInstance();
                var operation = roomMapper.GetRetrieveByRoomNumberStatement(room.IdHotel, room.RoomNumber);
                var lstResult = instance.ExecuteQueryProcedure(operation);

                if (lstResult.Count <= 0)
                {
                    return(default(T));
                }

                var objs = EntityObjectMapper.BuildObjects(lstResult);

                return(objs.Cast <T>().ToList()[0]);
            }
            catch (Exception e)
            {
                ManageException(e);
            }

            return(default(T));
        }
コード例 #6
0
 //Constructor
 public ReservationConsole()
 {
     TimeSlotMapper.getInstance().initializeDirectory();
     ReservationMapper.getInstance().initializeDirectory();
     UserMapper.getInstance().initializeDirectory();
     RoomMapper.getInstance().initializeDirectory();
     updateDirectories();
 }
コード例 #7
0
        public int Add(DTORoom dtoRoom)
        {
            Room entityRoom = RoomMapper.GetEntityRoom(dtoRoom);

            UnitOfWork.RoomRepository.Add(entityRoom);
            UnitOfWork.Commit();

            return(entityRoom.Id);
        }
コード例 #8
0
        public IHttpActionResult CreateRoom(RoomVM res)
        {
            var mng = new RoomManager();

            var room = RoomMapper.MapRoomVM(res);

            mng.AddNewRoom(room);

            return(Ok(res));
        }
コード例 #9
0
        public List <DTORoom> GetAll()
        {
            List <DTORoom> dtoRoomsList = new List <DTORoom>();

            foreach (var item in UnitOfWork.RoomRepository.GetAll())
            {
                dtoRoomsList.Add(RoomMapper.GetDTORoom(item));
            }
            return(dtoRoomsList);
        }
コード例 #10
0
        public IHttpActionResult GetRoom(int id)
        {
            var mng  = new RoomManager();
            var room = RoomMapper.MapRoom(mng.GetRoomById(id));

            if (room == null)
            {
                return(NotFound());
            }
            return(Ok(room));
        }
コード例 #11
0
ファイル: MessageHub.cs プロジェクト: SVlado1270/dnet_test
        public MessageHub(DataContext dataContext)
        {
            _repositoryWrapper = new RepositoryWrapper(dataContext);
            var messageMapper = new MessageMapper();
            var roomMapper    = new RoomMapper();
            var userMapper    = new UserMapper();
            var configuration = new MapperConfiguration(cfg => cfg.AddProfile(messageMapper));

            configuration = new MapperConfiguration(cfg => cfg.AddProfile(roomMapper));
            configuration = new MapperConfiguration(cfg => cfg.AddProfile(userMapper));
            _mapper       = new Mapper(configuration);
        }
コード例 #12
0
 public ActionResult GetAllRooms()
 {
     List<RoomDTO> roomDTOs = new List<RoomDTO>();
     try
     {
         _roomService.ViewRooms().ForEach(room => roomDTOs.Add(RoomMapper.BackendRoomToGraphicalEditorRoom(room)));
         return Ok(roomDTOs);
     }
     catch (NotFoundException exception)
     {
         return NotFound(exception.Message);
     }
 }
コード例 #13
0
ファイル: RoomController.cs プロジェクト: navidtrc/Hotel
        public ActionResult Edit(RoomViewModel room)
        {
            if (ModelState.IsValid)
            {
                _unitOfWork.Room_List.Update(RoomMapper.Map(room,
                                                            _unitOfWork.RoomType_List.GetAll().FirstOrDefault(f => f.Type == room.Type).ID.ToString(),
                                                            _unitOfWork.HotelData_List.GetAll().FirstOrDefault(f => f.Name == room.Hotel).ID.ToString()));
                Ok();
                return(RedirectToAction("Index", "Room", null));
            }

            Forbidden();
            return(Content(GenerateError()));
        }
コード例 #14
0
ファイル: RoomController.cs プロジェクト: navidtrc/Hotel
 public ActionResult Create(RoomViewModel room)
 {
     if (ModelState.IsValid)
     {
         Room instance = RoomMapper.Map(room,
                                        _unitOfWork.RoomType_List.GetAll().FirstOrDefault(f => f.Type == room.Type).ID.ToString(),
                                        _unitOfWork.HotelData_List.GetAll().FirstOrDefault(f => f.Name == room.Hotel).ID.ToString());
         _unitOfWork.Room_List.Add(instance);
         Ok();
         return(Json(new { RoomID = instance.ID.ToString() }));
     }
     Forbidden();
     return(Content(GenerateError()));
 }
コード例 #15
0
        public void ToApiEnableRoomEncryptionRequest()
        {
            // ARRANGE
            ApiEnableRoomEncryptionRequest expected = FactoryRoom.ApiEnableRoomEncryptionRequest;

            EnableRoomEncryptionRequest param = new EnableRoomEncryptionRequest(1234, expected.IsEncryptionEnabled)
            {
                DataRoomRescueKeyPassword = "******",
                UseDataSpaceRescueKey     = expected.UseDataSpaceRescueKey,
            };

            // ACT
            ApiEnableRoomEncryptionRequest actual = RoomMapper.ToApiEnableRoomEncryptionRequest(param, expected.DataRoomRescueKey);

            // ASSERT
            Assert.Equal(expected, actual, new ApiEnableRoomEncryptionRequestComparer());
        }
コード例 #16
0
        // Method used to update the lists inside each directories
        public void updateDirectories()
        {
            // Updating timeSlots of each reservations
            List <TimeSlot> timeSlotList = TimeSlotMapper.getInstance().getAllTimeSlot().Values.ToList();

            timeSlotList.Sort((x, y) => x.hour.CompareTo(y.hour));
            for (int i = 0; i < ReservationMapper.getInstance().getListOfReservations().Count; i++)
            {
                foreach (TimeSlot timeSlot in timeSlotList)
                {
                    if (ReservationMapper.getInstance().getListOfReservations()[i].reservationID == timeSlot.reservationID && !ReservationMapper.getInstance().getListOfReservations()[i].timeSlots.Contains(timeSlot))
                    {
                        ReservationMapper.getInstance().getListOfReservations()[i].timeSlots.Add(timeSlot);
                    }
                }
            }

            // Updating the waitList of each timeSlot
            for (int i = 0; i < TimeSlotMapper.getInstance().getListOfTimeSlots().Count; i++)
            {
                List <int> waitList = TimeSlotMapper.getInstance().getAllUsers(TimeSlotMapper.getInstance().getListOfTimeSlots()[i].timeSlotID);
                if (waitList != null)
                {
                    for (int j = 0; j < waitList.Count; j++)
                    {
                        if (!TimeSlotMapper.getInstance().getListOfTimeSlots()[i].waitlist.Contains(waitList[j]))
                        {
                            TimeSlotMapper.getInstance().getListOfTimeSlots()[i].waitlist.Enqueue(waitList[j]);
                        }
                    }
                }
            }

            // Updating the reservations for each room
            for (int i = 0; i < RoomMapper.getInstance().getListOfRooms().Count; i++)
            {
                foreach (KeyValuePair <int, Reservation> reservation in ReservationMapper.getInstance().getAllReservation())
                {
                    if (reservation.Value.roomID == RoomMapper.getInstance().getListOfRooms()[i].roomID)
                    {
                        RoomMapper.getInstance().getListOfRooms()[i].roomReservations.Add(reservation.Value);
                    }
                }
            }
        }
コード例 #17
0
        public void ToApiUpdateRoomRequest()
        {
            // ARRANGE
            ApiUpdateRoomRequest expected = FactoryRoom.ApiUpdateRoomRequest;

            UpdateRoomRequest param = new UpdateRoomRequest(12)
            {
                Name  = expected.Name,
                Quota = expected.Quota,
                Notes = expected.Notes
            };

            // ACT
            ApiUpdateRoomRequest actual = RoomMapper.ToApiUpdateRoomRequest(param);

            // ASSERT
            Assert.Equal(expected, actual, new ApiUpdateRoomRequestComparer());
        }
コード例 #18
0
        public Node UpdateRoom(UpdateRoomRequest request)
        {
            _client.Executor.CheckApiServerVersion();

            #region Parameter Validation

            request.MustNotNull(nameof(request));
            request.Name.MustNotNullOrEmptyOrWhitespace(nameof(request.Name));
            request.Id.MustPositive(nameof(request.Id));
            request.Quota.NullableMustNotNegative(nameof(request.Quota));

            #endregion

            ApiUpdateRoomRequest apiUpdateRoomRequest = RoomMapper.ToApiUpdateRoomRequest(request);
            IRestRequest         restRequest          = _client.Builder.PutRoom(request.Id, apiUpdateRoomRequest);
            ApiNode result = _client.Executor.DoSyncApiCall <ApiNode>(restRequest, RequestType.PutRoom);
            return(NodeMapper.FromApiNode(result));
        }
コード例 #19
0
        // Hotel Rooms HotelSearchRoom
        public HotelSearchRoom GetAvailableRoom(string SessionId, int ResIndex, string HotelCode, string SID)
        {
            //var roomexists=
            //if (true)
            //{

            //}
            var Result = RoomAvailabiltyService.Availabilty(SessionId, ResIndex, HotelCode, SID);
            //map tbo rooms rsp to general res
            HotelSearchRoom hotelSearchRoom = RoomMapper.MapTboRoomRspTogenrl(Result, SID);
            // apply business rules on rooms
            //ApplyRoomsBusiness(rooms);
            //save rooms in DB
            SearchRepo manager = new SearchRepo();

            manager.SaveSearchRooms(hotelSearchRoom.Packages, SID, HotelCode);

            var Res = manager.GetTBOHotelDetails(hotelSearchRoom, HotelCode, SID);


            // return Res;
            return(hotelSearchRoom);
        }
コード例 #20
0
        public Node CreateRoom(CreateRoomRequest request)
        {
            _client.Executor.CheckApiServerVersion();

            #region Parameter Validation

            request.MustNotNull(nameof(request));
            request.ParentId.MustPositive(nameof(request.ParentId));
            request.Name.MustNotNullOrEmptyOrWhitespace(nameof(request.Name));
            request.Quota.NullableMustNotNegative(nameof(request.Quota));
            request.RecycleBinRetentionPeriod.NullableMustNotNegative(nameof(request.RecycleBinRetentionPeriod));
            if (request.AdminUserIds.CheckEnumerableNullOrEmpty() && request.AdminGroupIds.CheckEnumerableNullOrEmpty())
            {
                throw new ArgumentNullException(nameof(request.AdminUserIds) + " | " + nameof(request.AdminGroupIds),
                                                "Room must have an admin user or admin group.");
            }

            if (request.AdminUserIds != null)
            {
                request.AdminUserIds.EnumerableMustNotNullOrEmpty(nameof(request.AdminUserIds));
                request.AdminUserIds.ForEach(id => id.MustPositive(nameof(request.AdminUserIds) + " element"));
            }

            if (request.AdminGroupIds != null)
            {
                request.AdminGroupIds.EnumerableMustNotNullOrEmpty(nameof(request.AdminGroupIds));
                request.AdminGroupIds.ForEach(id => id.MustPositive(nameof(request.AdminGroupIds) + " element"));
            }

            #endregion

            ApiCreateRoomRequest apiCreateRoomRequest = RoomMapper.ToApiCreateRoomRequest(request);
            IRestRequest         restRequest          = _client.Builder.PostRoom(apiCreateRoomRequest);
            ApiNode result = _client.Executor.DoSyncApiCall <ApiNode>(restRequest, RequestType.PostRoom);
            return(NodeMapper.FromApiNode(result));
        }
コード例 #21
0
        public async Task <IActionResult> AddRoom([FromBody] RoomModel admin)
        {
            var name = await _roomService.AddRoom(RoomMapper.Map(admin));

            return(Ok(name));
        }
コード例 #22
0
        public async Task <IActionResult> UpdateAdmin([FromBody] RoomModel room)
        {
            var name = await _roomService.UpdateRoom(RoomMapper.Map(room));

            return(Ok(name));
        }
コード例 #23
0
 public List <Room> getAllRooms()
 {
     return(RoomMapper.getInstance().getListOfRooms());
 }
コード例 #24
0
ファイル: RoomService.cs プロジェクト: MangelDark/Coworking
        public async Task <Room> Get(int id)
        {
            var room = await _roomRepository.Get(id);

            return(RoomMapper.Map(room));
        }
コード例 #25
0
ファイル: RoomService.cs プロジェクト: MangelDark/Coworking
        public async Task <Room> Update(Room room)
        {
            var data = await _roomRepository.Update(RoomMapper.Map(room));

            return(room);
        }
コード例 #26
0
        public async Task <Room> GetRoom(int id)
        {
            var entity = await _roomRepository.Get(id);

            return(RoomMapper.Map(entity));
        }
コード例 #27
0
        public async Task <Room> AddRoom(Room room)
        {
            var addedEntity = await _roomRepository.Add(RoomMapper.Map(room));

            return(RoomMapper.Map(addedEntity));
        }
コード例 #28
0
 public RoomsController()
 {
     this._service = new RoomService();
     this._mapper  = new RoomMapper();
 }
コード例 #29
0
 public RoomService()
 {
     repository = RoomRepository.GetInstance();
     mapper     = new RoomMapper();
 }
コード例 #30
0
        public async Task <Room> UpdateRoom(Room room)
        {
            var updated = await _roomRepository.Update(RoomMapper.Map(room));

            return(RoomMapper.Map(updated));
        }