Suggest meeting times when given a list of Calendar IDs

api/room/schema_query.py

@@ -16,13 +16,15 @@
     map_remote_room_location_to_filter
 )
 from helpers.calendar.credentials import (get_google_api_calendar_list,
+                                          get_google_calendar_events,
                                           credentials
                                           )
 from helpers.events_filter.events_filter import (convert_date,
                                                  validate_date_input,
                                                  format_range_dates,
                                                  format_range_time,
-                                                 empty_string_checker
+                                                 empty_string_checker,
+                                                 convert_date_into_user_time
                                                  )
 from api.room.schema import (RatioOfCheckinsAndCancellations,
                              BookingsAnalyticsCount)
@@ -126,6 +128,14 @@ class AllAvailableRooms(graphene.ObjectType):
     availableRoom = graphene.List(AvailableRooms)
 
 
+class suggestedTime(graphene.ObjectType):
+    time = graphene.String()
+
+
+class AllsuggestedTime(graphene.ObjectType):
+    suggestedTime = graphene.List(AvailableRooms)
+
+
 class Query(graphene.ObjectType):
     """
         Returns paginated rooms
@@ -273,6 +283,22 @@ class Query(graphene.ObjectType):
                 [required]"
     )
 
+    all_suggested_time = graphene.Field(
+        # suggest time for a meeting to a user
+        AllsuggestedTime,
+        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"
+    )
+
     def check_valid_calendar_id(self, query, calendar_id):
         check_calendar_id = query.filter(
             RoomModel.calendar_id == calendar_id
@@ -409,6 +435,62 @@ def raise_no_available_rooms():
             availableRoom=all_available_rooms
         ) if available_rooms else raise_no_available_rooms()
 
+    @Auth.user_roles('Admin', 'Super Admin')
+    def resolve_all_suggested_time(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
+                                )
+
+        remote_rooms = Query.resolve_all_remote_rooms(
+            self, info, return_all=True)
+        all_rooms = []
+        for room in remote_rooms.rooms:
+            all_rooms.append({
+                "id": room.calendar_id,
+            })
+
+        calendar = 'andela.com_3339323638393131363334@resource.calendar.google.com' # noqa
+        all_calendars = get_google_calendar_events(calendarId=calendar,
+                                                   timeMin=start_time,
+                                                   timeMax=end_time,
+                                                   singleEvents=None,
+                                                   orderBy=None,
+                                                   syncToken=None,
+                                                   pageToken=None
+                                                   )
+        items = all_calendars.get('items', [])
+        users = []
+        for item in items:
+            if item['status'] != 'cancelled':
+                users.append({
+                    "start": convert_date_into_user_time(item.get(
+                        'start')['dateTime'], time_zone),
+                    "end": convert_date_into_user_time(item.get(
+                        'end')['dateTime'], time_zone),
+                    "attendees": item.get('attendees')[0]['email']
+                })
+
+        def raise_no_suggested_time():
+            raise GraphQLError("No suggestion available"
+                               + str(users))
+
+        return AllsuggestedTime(
+            availableRoom=all_calendars
+        ) if not AllsuggestedTime else raise_no_suggested_time()
+
     @Auth.user_roles('Admin', 'Super Admin')
     def resolve_filter_rooms_by_tag(self, info, tagId):
         rooms = Room.get_query(info).join(tags).join(

helpers/events_filter/events_filter.py

@@ -144,3 +144,17 @@ def convert_date(provided_date, provided_time, time_zone):
     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')
+
+
+def convert_date_into_user_time(time, requester_time_zone):
+    events_time_in_utc = str(datetime.strptime(
+        time[:19], "%Y-%m-%dT%H:%M:%S"
+    ) + timedelta(hours=int(
+        time[-6:20] + time[-4:22]))
+    )
+
+    time_zone = pytz.timezone(requester_time_zone)
+    user_time = str(datetime.strptime(
+        events_time_in_utc, '%Y-%m-%d %H:%M:%S'
+    ).replace(tzinfo=pytz.utc).astimezone(time_zone))
+    return user_time.replace(" ", "T")