CV3-49-story(Rooms): get avilable Rooms for a specific time (#508)

- ensure admin can get available rooms for a specific time before booking
- getting available rooms for a specific location

[Delivers CV3-49]

Author: Ramadhan0

api/room/schema_query.py

@@ -15,7 +15,15 @@
 from helpers.remote_rooms.remote_rooms_location import (
     map_remote_room_location_to_filter
 )
-from helpers.calendar.credentials import get_google_api_calendar_list
+from helpers.calendar.credentials import (get_google_api_calendar_list,
+                                          credentials
+                                          )
+from helpers.events_filter.events_filter import (convert_date,
+                                                 validate_date_input,
+                                                 format_range_dates,
+                                                 format_range_time,
+                                                 empty_string_checker
+                                                 )
 from api.room.schema import (RatioOfCheckinsAndCancellations,
                              BookingsAnalyticsCount)
 
@@ -109,6 +117,15 @@ class PaginatedEvents(graphene.ObjectType):
     pages = graphene.Int()
 
 
+class AvailableRooms(graphene.ObjectType):
+    id = graphene.String()
+    name = graphene.String()
+
+
+class AllAvailableRooms(graphene.ObjectType):
+    availableRoom = graphene.List(AvailableRooms)
+
+
 class Query(graphene.ObjectType):
     """
         Returns paginated rooms
@@ -308,6 +325,90 @@ def resolve_all_remote_rooms(self, info, return_all=None):
                         if not re.search(match, room.name)]
         return AllRemoteRooms(rooms=actual_rooms)
 
+    all_available_rooms = graphene.Field(
+        AllAvailableRooms,
+        start_date=graphene.String(required=True),
+        start_time=graphene.String(required=True),
+        end_date=graphene.String(required=True),
+        end_time=graphene.String(required=True),
+        time_zone=graphene.String(required=True),
+        description="Returns available rooms in a given period \
+            \n- start_time: Start time and date when you want to book room from\
+            [required]\n- end_time: time and date you want to book room upto\
+                [required]\n time_zone: The time zone of the location\
+                    [required]\n location: The location of the office's \
+                        room you want to book"
+    )
+
+    @Auth.user_roles('Admin', 'Super Admin')
+    def resolve_all_available_rooms(self, info, **kwargs):
+
+        time_zone = kwargs['time_zone']
+        empty_string_checker(time_zone)
+        validate_date_input(kwargs['start_date'], kwargs['end_date'])
+        validate_date_input(kwargs['start_time'], kwargs['end_time'])
+        format_range_dates(kwargs['start_date'], kwargs['end_date'])
+        format_range_time(kwargs['start_time'], kwargs['end_time'])
+
+        start_time = convert_date(kwargs['start_date'],
+                                  kwargs['start_time'],
+                                  time_zone
+                                  )
+        end_time = convert_date(kwargs['end_date'],
+                                kwargs['end_time'],
+                                time_zone
+                                )
+
+        # list of all remote rooms in a user's location
+        locational_remote_rooms = Query.resolve_all_remote_rooms(
+            self, info, return_all=False)
+        all_rooms = []
+        for room in locational_remote_rooms.rooms:
+            all_rooms.append({
+                "id": room.calendar_id,
+                "name": room.name
+            })
+
+        # list of all remote rooms and
+        # for each room shows whether it is free or busy in a given period.
+        service = credentials.set_api_credentials()
+        all_calendars = get_google_api_calendar_list()['items']
+        all_remote_rooms = []
+        for room in all_calendars:
+            free_busy_rooms_request_object = {
+                "timeMin": start_time,
+                "timeMax": end_time,
+                "timeZone": time_zone,
+                "items": [
+                    {
+                        "id": room['id']
+                    }
+                ]
+            }
+            res = service.freebusy().query(
+                body=free_busy_rooms_request_object
+                ).execute()
+            all_remote_rooms.append(res[u'calendars'])
+
+        # all busy remote rooms in a given period
+        busy_rooms = [key for element in all_remote_rooms for key,
+                      value in element.items() if len(value["busy"]) != 0]
+
+        # all available rooms in a user's location in a given period
+        available_rooms = [room for room in all_rooms if room[
+            'id'
+            ] not in busy_rooms]
+        all_available_rooms = [AvailableRooms(room['id'],
+                                              room['name']
+                                              ) for room in available_rooms]
+
+        def raise_no_available_rooms():
+            raise GraphQLError("No available rooms at the moment")
+
+        return AllAvailableRooms(
+            availableRoom=all_available_rooms
+        ) if available_rooms else raise_no_available_rooms()
+
     @Auth.user_roles('Admin', 'Super Admin')
     def resolve_filter_rooms_by_tag(self, info, tagId):
         rooms = Room.get_query(info).join(tags).join(

fixtures/room/available_rooms_fixtures.py

@@ -0,0 +1,65 @@
+
+available_rooms_query = '''
+query {
+  allAvailableRooms(
+              startDate: "Nov 07 2018",
+              startTime: "08:00:00",
+              endDate: "Nov 11 2018",
+              endTime: "09:45:00",
+              timeZone: "Africa/Kampala"
+  ){
+   availableRoom{
+      id
+      name
+    }
+    }
+}
+'''
+
+available_rooms_query_with_empty_input = '''
+query {
+  allAvailableRooms(
+              startDate: "",
+              startTime: "08:00:00",
+              endDate: "Nov 11 2018",
+              endTime: "09:45:00",
+              timeZone: "Africa/Kampala"
+  ){
+   availableRoom{
+      name
+    }
+    }
+}
+'''
+
+available_rooms_query_when_startDate_is_bigger_than_endDate = '''
+query {
+  allAvailableRooms(
+              startDate: "Nov 13 2018",
+              startTime: "08:00:00",
+              endDate: "Nov 11 2018",
+              endTime: "09:45:00",
+              timeZone: "Africa/Kampala"
+  ){
+   availableRoom{
+      name
+    }
+    }
+}
+'''
+
+available_rooms_query_when_startTime_is_bigger_than_endTime = '''
+query {
+  allAvailableRooms(
+              startDate: "Nov 07 2018",
+              startTime: "10:00:00",
+              endDate: "Nov 11 2018",
+              endTime: "09:45:00",
+              timeZone: "Africa/Kampala"
+  ){
+   availableRoom{
+      name
+    }
+    }
+}
+'''

helpers/events_filter/events_filter.py

@@ -4,7 +4,6 @@
 import inspect
 from dateutil import parser
 
-
 utc = pytz.utc
 
 
@@ -125,3 +124,23 @@ def calendar_dates_format(start_date, start_time, duration):
     end_date = end_date.strftime('%Y-%m-%dT%H:%M:%S')
 
     return (start_date, end_date)
+
+
+def format_range_time(start_time, end_time):
+    """
+    Raises a GraphQL error when
+    start_time is bigger than end_time
+    """
+    start_time = datetime.strptime(start_time, '%H:%M:%S')
+    end_time = datetime.strptime(end_time, '%H:%M:%S')
+
+    if start_time > end_time:
+        raise GraphQLError("Start time must be lower than end time")
+    return start_time, end_time
+
+
+def convert_date(provided_date, provided_time, time_zone):
+    date = provided_date + ' ' + provided_time
+    new_date = parser.parse(date)
+    new_date_format = str(pytz.timezone(time_zone).localize(new_date))
+    return new_date_format.replace(new_date_format[10], 'T')

tests/test_rooms/test_available_rooms.py

@@ -0,0 +1,43 @@
+from unittest.mock import patch
+from tests.base import BaseTestCase, CommonTestCases
+from helpers.calendar.calendar import get_calendar_list_mock_data
+
+from fixtures.room.available_rooms_fixtures import (
+    available_rooms_query,
+    available_rooms_query_with_empty_input,
+    available_rooms_query_when_startDate_is_bigger_than_endDate,
+    available_rooms_query_when_startTime_is_bigger_than_endTime
+)
+
+
+class AvailableRooms(BaseTestCase):
+
+    @patch("api.room.schema_query.get_google_api_calendar_list", spec=True,
+           return_value=get_calendar_list_mock_data())
+    def test_available_rooms(self, mock_get_json):
+        CommonTestCases.admin_token_assert_in(
+            self,
+            available_rooms_query,
+            "No available rooms at the moment"
+        )
+
+    def available_rooms_query_with_empty_input(self):
+        CommonTestCases.admin_token_assert_in(
+            self,
+            available_rooms_query_with_empty_input,
+            "startDate argument missing"
+        )
+
+    def available_rooms_query_when_startDate_is_bigger_than_endDate(self):
+        CommonTestCases.admin_token_assert_in(
+            self,
+            available_rooms_query_when_startDate_is_bigger_than_endDate,
+            "Start date must be lower than end date"
+        )
+
+    def available_rooms_query_when_startTime_is_bigger_than_endTime(self):
+        CommonTestCases.admin_token_assert_in(
+            self,
+            available_rooms_query_when_startTime_is_bigger_than_endTime,
+            "Start time must be lower than end time"
+        )