def mutate(self, info, **kwargs):
validate_empty_fields(**kwargs)
query = Room.get_query(info)
errors = []
responses = []
present_date = datetime.now().strftime('%Y/%m/%d %H:%M:%S')
room = query.filter_by(id=kwargs['room_id']).first()
if not room:
raise GraphQLError("Non-existent room id")
for each_response in kwargs['responses']:
question = QuestionModel.query.filter_by(
id=each_response.question_id).first()
if not question:
errors.append(
"Response to question {} was not saved because it does not exist"
.format(each_response.question_id)) # noqa
continue
if present_date < question.start_date:
errors.append(
"The start date for the response to this question is yet to commence. Try on {}"
.format(question.start_date)) # noqa
question_type = question.question_type
each_response['room_id'] = kwargs['room_id']
responses, errors = create_response(info, question_type, errors,
responses, **each_response)
if errors:
raise GraphQLError(('The following errors occured: {}').format(
str(errors).strip('[]')))
return CreateResponse(response=responses)
def resolve_filter_rooms_by_tag(self, info, tagId):
rooms = Room.get_query(info).join(tags).join(Tag).filter(
tags.c.tag_id == tagId).all()
if not rooms:
raise GraphQLError('No rooms found with this tag')
return rooms
def resolve_get_room_by_id(self, info, room_id):
query = Room.get_query(info)
check_room = query.filter(RoomModel.id == room_id,
RoomModel.state == "active").first()
if not check_room:
raise GraphQLError("Room not found")
return check_room
def resolve_analytics_for_least_used_room_per_month(self, info, month, year): # noqa: E501
query = Room.get_query(info)
room_analytics = RoomAnalytics.get_least_used_room_per_month(
self, query, month, year)
return Analytics(
analytics=room_analytics
)
def mutate(self, info, **kwargs):
validate_empty_fields(**kwargs)
rating_values = ["Excellent", "Very Good", "Good", "Average", "Poor"]
ratings = ["comments", "overall_rating", "cleanliness_rating"]
query = Room.get_query(info)
room = query.filter_by(id=kwargs['room_id']).first()
if not room:
raise GraphQLError("Non-existent room id")
if not set(ratings).intersection(kwargs):
raise GraphQLError("Ensure to give at least one feedback input")
ratings.pop(0)
for feedback in kwargs:
if feedback in ratings:
if kwargs[feedback] not in rating_values:
raise GraphQLError("Invalid rating, only " +
', '.join(rating_values) +
" ratings allowed") # noqa
user = get_user_from_db()
feedback = FeedbackModel(**kwargs, user_id=user.id)
feedback.save()
return CreateFeedback(feedback=feedback)
def mutate(self, info, **kwargs):
validate_empty_fields(**kwargs)
query = RoomSQLAlchemyObject.get_query(info)
active_rooms = query.filter(RoomModel.state == "active")
exact_room = active_rooms.filter(
RoomModel.id == kwargs['room_id']).first()
if not exact_room:
raise GraphQLError("Room not found")
exact_resource = ResourceModel.query.filter_by(
id=kwargs['resource_id'], state="active").first()
if not exact_resource:
raise GraphQLError('Resource with such id does not exist.')
resource_name = exact_resource.name
assigned_quantity = kwargs['quantity']
if assigned_quantity < 1:
raise GraphQLError(
"Assigned quantity cannot be less than 1."
)
resource_query = RoomResource.get_query(info)
exact_resource_id = resource_query.filter(
RoomResourceModel.resource_id == kwargs['resource_id'],
RoomResourceModel.room_id == kwargs['room_id']).first()
if exact_resource_id:
raise GraphQLError(
'Resource already exists in the room.'
)
room_resources = RoomResourceModel(**kwargs, name=resource_name)
room_resources.save()
return AssignResource(room_resource=room_resources)
def mutate(self, info, **kwargs):
validate_empty_fields(**kwargs)
query = Room.get_query(info)
responses = []
errors = []
room = query.filter_by(id=kwargs['room_id']).first()
if not room:
raise GraphQLError("Non-existent room id")
for each_response in kwargs['responses']:
question = QuestionModel.query.filter_by(
id=each_response.question_id).first()
if not question:
errors.append(
"Response to question {} was not saved because it does not exist".format(each_response.question_id)) # noqa
continue
question_type = question.question_type
each_response['room_id'] = kwargs['room_id']
responses, errors = create_response(question_type,
errors,
responses,
**each_response)
if errors:
raise GraphQLError(
('The following errors occured: {}').format(
str(errors).strip('[]'))
)
return CreateResponse(response=responses)
def resolve_bookings_analytics_count(self, info, **kwargs):
start_date, end_date, room_id = (kwargs.get('start_date'),
kwargs.get('end_date'),
kwargs.get('room_id'))
query = Room.get_query(info)
analytics = RoomAnalyticsRatios.get_bookings_analytics_count(
self, query, start_date, end_date, room_id=room_id)
return analytics
def resolve_analytics_for_meetings_per_room(self, info, day_start, day_end): # noqa: E501
query = Room.get_query(info)
meeting_summary = RoomAnalytics.get_meetings_per_room(
self, query, day_start, day_end
)
return Analytics(
analytics=meeting_summary
)
def resolve_analytics_for_room_least_used_per_week(self, info, week_start, week_end): # noqa: E501
query = Room.get_query(info)
room_analytics = RoomAnalytics.get_least_used_room_week(
self, query, week_start, week_end
)
return Analytics(
analytics=room_analytics
)
def resolve_analytics_for_least_used_rooms(self,
info,
start_date,
end_date=None): # noqa: E501
query = Room.get_query(info)
room_analytics = RoomAnalytics.get_least_used_rooms_analytics(
self, query, start_date, end_date)
return Analytics(analytics=room_analytics)
def resolve_analytics_for_meetings_per_room(self,
info,
start_date,
end_date=None): # noqa: E501
query = Room.get_query(info)
meeting_summary = RoomAnalytics.get_meetings_per_room_analytics(
self, query, start_date, end_date)
return Analytics(analytics=meeting_summary)
def resolve_analytics_ratios_per_room(self,
info,
start_date,
end_date=None): # noqa: E501
query = Room.get_query(info)
ratio = RoomAnalyticsRatios.get_analytics_ratios_per_room(
self, query, start_date, end_date)
return RatiosPerRoom(ratio)
def resolve_analytics_for_least_used_room_per_day(self, info, day): # noqa: E501
query = Room.get_query(info)
room_analytics = RoomAnalytics.get_least_used_room_day(
self, query, day
)
return Analytics(
analytics=room_analytics
)
def resolve_get_room_by_name(self, info, name):
query = Room.get_query(info)
if name == "":
raise GraphQLError("Please input Room Name")
check_room_name = list(query.filter(RoomModel.name.ilike("%" + name + "%")).all()) # noqa: E501
if not check_room_name:
raise GraphQLError("Room not found")
return check_room_name
def resolve_room_schedule(self, info, calendar_id, days):
query = Room.get_query(info)
Query.check_valid_calendar_id(self, query, calendar_id)
room_schedule = RoomSchedules.get_room_schedules(
self,
calendar_id,
days)
return Calendar(
events=room_schedule[1]
)
def resolve_all_analytics(self, info, **kwargs):
start_date = kwargs.get('start_date')
end_date = kwargs.get('end_date')
location_id = admin_roles.user_location_for_analytics_view()
admin_details = get_user_from_db()
query = Role.get_query(info)
admin_role = query.filter_by(id=admin_details.roles[0].id).first()
# check that id is valid
verify_location_id(kwargs)
if admin_role.role == 'Super Admin' and kwargs.get(
'location_id', None):
location_id = kwargs.get('location_id')
unconverted_dates = {
'start': start_date,
'end': end_date,
}
start_date, end_date = CommonAnalytics.all_analytics_date_validation(
self, start_date, end_date)
query = Room.get_query(info)
room_analytics, bookings, percentages_dict, bookings_count = AllAnalyticsHelper.get_all_analytics( # noqa
self, query, start_date, end_date, location_id, unconverted_dates)
analytics = []
for analytic in room_analytics:
current_analytic = ConsolidatedAnalytics(
room_name=analytic['room_name'],
cancellations=analytic['cancellations'],
cancellations_percentage=analytic['cancellations_percentage'],
auto_cancellations=analytic['auto_cancellations'],
number_of_bookings=analytic['number_of_meetings'],
checkins=analytic['checkins'],
checkins_percentage=analytic['checkins_percentage'],
bookings_percentage_share=percentage_formater(
analytic['num_of_events'], bookings),
app_bookings=analytic['app_bookings'],
app_bookings_percentage=analytic['app_bookings_percentage'],
events=analytic['room_events'],
)
analytics.append(current_analytic)
return AllAnalytics(bookings=bookings,
checkins_percentage=percentage_formater(
percentages_dict['total_checkins'], bookings),
auto_cancellations_percentage=percentage_formater(
percentages_dict['total_auto_cancellations'],
bookings),
cancellations_percentage=percentage_formater(
percentages_dict['total_cancellations'],
bookings),
app_bookings_percentage=percentage_formater(
percentages_dict['total_app_bookings'],
bookings),
bookings_count=bookings_count,
analytics=analytics)
def resolve_booked_rooms_analytics(*args):
instance, info, start_date, end_date, criteria, limit = args
query = Room.get_query(info)
location_id = admin_roles.user_location_for_analytics_view()
active_rooms = query.filter(RoomModel.state == "active",
RoomModel.location_id == location_id)
booked_rooms = get_most_and_least_booked_rooms(instance, active_rooms,
start_date, end_date, limit,
criteria)
booked_rooms_statistics = Analytics(analytics=booked_rooms)
return booked_rooms_statistics
def resolve_all_channels(self, info):
all_rooms = Room.get_query(info).filter(RoomModel.state == "active")
all_channels = []
for room in all_rooms:
channel = Channel(calendar_id=room.calendar_id,
firebase_token=room.firebase_token)
all_channels.append(channel)
return Channels(channels=all_channels)
def resolve_analytics_ratios_per_room(self, info, **kwargs):
room_id = kwargs.get('room_id')
query = Room.get_query(info)
ratio = RoomAnalyticsRatios.get_analytics_ratios_per_room(
self, query, kwargs.get('start_date'), kwargs.get('end_date'),
**kwargs)
if room_id:
exact_room = query.filter(RoomModel.id == room_id).first()
if not exact_room:
raise GraphQLError("Room not found")
return RatiosPerRoom(ratios=[], ratio=ratio)
return RatiosPerRoom(ratios=ratio, ratio={})
def resolve_room_response(self, info, room_id):
query = Room.get_query(info)
query_response = Response.get_query(info)
room = query.filter_by(id=room_id).first()
if not room:
raise GraphQLError("Non-existent room id")
room_response = query_response.filter_by(room_id=room_id)
responses = Query.get_room_response(self, room_response, room_id)
total_response = room_response.count()
room_name = room.name
return RoomResponse(room_name=room_name,
total_responses=total_response,
response=responses)
def resolve_analytics_for_daily_room_events(self, info, **kwargs):
start_date = kwargs.get('start_date')
end_date = kwargs.get('end_date')
location_id = admin_roles.user_location_for_analytics_view()
start_date, end_date = CommonAnalytics().convert_dates(
start_date, end_date)
query = Room.get_query(info)
all_events, all_dates = RoomSchedules().get_all_room_schedules(
query, start_date, end_date, location_id)
all_days_events = []
for date in set(all_dates):
daily_events = []
for event in all_events:
if date == event["date_of_event"]:
current_event = CalendarEvent(
no_of_participants=event["no_of_participants"],
event_summary=event["event_summary"],
start_time=event["start_time"],
end_time=event["end_time"],
room_name=event["room_name"],
event_id=event["event_id"],
cancelled=event["cancelled"],
state=event["state"],
checked_in=event["checked_in"],
check_in_time=event["check_in_time"],
meeting_end_time=event["meeting_end_time"])
daily_events.append(current_event)
all_days_events.append(DailyEvents(day=date, events=daily_events))
page = kwargs.get('page')
per_page = kwargs.get('per_page')
if page and per_page:
paginated_results = ListPaginate(iterable=all_days_events,
per_page=per_page,
page=page)
current_page = paginated_results.current_page
has_previous = paginated_results.has_previous
has_next = paginated_results.has_next
pages = paginated_results.pages
return PaginatedEvents(DailyRoomEvents=current_page,
has_next=has_next,
has_previous=has_previous,
pages=pages)
return PaginatedEvents(DailyRoomEvents=all_days_events)
def resolve_get_resources_by_room_id(self, info, room_id):
# Get resources of a specific room
exact_room = RoomSQLAlchemyObject.get_query(info).filter(
RoomModel.id == room_id, RoomModel.state == "active").first()
if not exact_room:
raise GraphQLError("Room not found")
resource_query = Resource.get_query(info)
room_resources = RoomResource.get_query(info).filter(
RoomResourceModel.room_id == room_id)
if not room_resources.first():
raise GraphQLError("Room has no resource yet")
resources = []
for resource in room_resources:
room_resource = resource_query.filter(
ResourceModel.state == "active",
ResourceModel.id == resource.resource_id).first()
room_resource.quantity = resource.quantity
resources.append(room_resource)
return RoomResources(roomResources=resources)
def resolve_all_analytics(self, info, **kwargs):
start_date = kwargs.get('start_date')
end_date = kwargs.get('end_date')
unconverted_dates = {'start': start_date, 'end': end_date}
location_id = admin_roles.user_location_for_analytics_view()
start_date, end_date = CommonAnalytics.all_analytics_date_validation(
self, start_date, end_date)
query = Room.get_query(info)
room_analytics, bookings, percentages_dict, bookings_count = AllAnalyticsHelper.get_all_analytics( # noqa
self, query, start_date, end_date, location_id, unconverted_dates)
analytics = []
for analytic in room_analytics:
current_analytic = ConsolidatedAnalytics(
room_name=analytic['room_name'],
cancellations=analytic['cancellations'],
cancellations_percentage=analytic['cancellations_percentage'],
auto_cancellations=analytic['auto_cancellations'],
number_of_bookings=analytic['number_of_meetings'],
checkins=analytic['checkins'],
checkins_percentage=analytic['checkins_percentage'],
bookings_percentage_share=percentage_formater(
analytic['num_of_events'], bookings),
app_bookings=analytic['app_bookings'],
app_bookings_percentage=analytic['app_bookings_percentage'],
events=analytic['room_events'],
)
analytics.append(current_analytic)
return AllAnalytics(bookings=bookings,
checkins_percentage=percentage_formater(
percentages_dict['total_checkins'], bookings),
auto_cancellations_percentage=percentage_formater(
percentages_dict['total_auto_cancellations'],
bookings),
cancellations_percentage=percentage_formater(
percentages_dict['total_cancellations'],
bookings),
app_bookings_percentage=percentage_formater(
percentages_dict['total_app_bookings'],
bookings),
bookings_count=bookings_count,
analytics=analytics)
def resolve_analytics_for_meetings_durations(self,
info,
start_date,
end_date=None,
per_page=None,
page=None): # noqa: E501
query = Room.get_query(info)
results = RoomAnalytics.get_meetings_duration_analytics(
self, query, start_date, end_date) # noqa: E501
if page and per_page:
paginated_results = ListPaginate(iterable=results,
per_page=per_page,
page=page) # noqa: E501
current_page = paginated_results.current_page
has_previous = paginated_results.has_previous
has_next = paginated_results.has_next
pages = paginated_results.pages
return Analytics(MeetingsDurationaAnalytics=current_page,
has_previous=has_previous,
has_next=has_next,
pages=pages) # noqa: E501
return Analytics(MeetingsDurationaAnalytics=results)
def mutate(self, info, structure_ids):
office_structure_query = Structure.get_query(info)
room_query = Room.get_query(info)
active_structures = office_structure_query.filter(
StructureModel.state == "active")
active_rooms = room_query.filter(
RoomModel.state == "active")
structures = []
for structure_id in structure_ids:
office_structure = active_structures.filter(
StructureModel.structure_id == structure_id).first()
if not office_structure:
message = 'The structure {} does not exist'.format(structure_id)
raise GraphQLError(message)
rooms = active_rooms.filter(
RoomModel.structure_id == structure_id).all()
if len(rooms) > 0:
for room in rooms:
update_entity_fields(room, state="archived")
room.save()
update_entity_fields(office_structure, state="archived")
office_structure.save()
structures.append(office_structure)
return DeleteOfficeStructure(structure=structures)
def resolve_bookings_analytics_count(self, info, start_date,
end_date): # noqa: E501
query = Room.get_query(info)
analytics = RoomAnalyticsRatios.get_bookings_analytics_count(
self, query, start_date, end_date)
return analytics
def resolve_get_rooms_in_a_location(self, info, location_id):
query = Room.get_query(info)
exact_query = room_join_location(query)
result = exact_query.filter(LocationModel.id == location_id)
return result.all()
def resolve_analytics_for_meetings_durations(self, info, start_date, end_date=None): # noqa: E501
query = Room.get_query(info)
results = RoomAnalytics.get_meetings_duration_analytics(self, query, start_date, end_date) # noqa: E501
return Analytics(MeetingsDurationaAnalytics=results)
def resolve_get_rooms_in_a_floor(self, info, floor_id):
query = Room.get_query(info)
rooms = query.filter(RoomModel.floor_id == floor_id)
return rooms
