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 __init__(self, **kwargs):
validate_empty_fields(**kwargs)
self.name = kwargs['name']
self.device_type = kwargs['device_type']
self.date_added = kwargs['date_added']
self.last_seen = kwargs['last_seen']
self.location = kwargs['location']
self.room_id = kwargs.get('room_id')
def mutate(self, info, **kwargs):
validate_empty_fields(**kwargs)
tag = TagModel(**kwargs)
payload = {
'model': TagModel, 'field': 'name', 'value': kwargs['name']
}
with SaveContextManager(
tag, 'Tag', payload
):
return CreateTag(tag=tag)
def mutate(self, info, tag_id, **kwargs):
validate_empty_fields(**kwargs)
query_tag = Tag.get_query(info)
tag = query_tag.filter(TagModel.id == tag_id,
TagModel.state == "active").first()
if not tag:
raise GraphQLError("Tag not found")
update_entity_fields(tag, **kwargs)
tag.save()
return UpdateTag(tag=tag)
def mutate(self, info, resource_id, **kwargs):
validate_empty_fields(**kwargs)
query = Resource.get_query(info)
active_resources = query.filter(ResourceModel.state == "active")
exact_resource = active_resources.filter(
ResourceModel.id == resource_id).first()
if not exact_resource:
raise GraphQLError("Resource not found")
update_entity_fields(exact_resource, **kwargs)
exact_resource.save()
return UpdateRoomResource(resource=exact_resource)
def mutate(self, info, structure_id, **kwargs):
validate_empty_fields(**kwargs)
query = Structure.get_query(info)
active_structure = query.filter(
StructureModel.structure_id == structure_id,
StructureModel.state == "active").first()
if not active_structure:
raise GraphQLError('Structure not found')
update_entity_fields(active_structure, **kwargs)
active_structure.save()
return UpdateOfficeStructure(structure=active_structure)
def mutate(self, info, room_id, **kwargs):
validate_empty_fields(**kwargs)
query_room = Room.get_query(info)
active_rooms = query_room.filter(RoomModel.state == "active")
room = active_rooms.filter(RoomModel.id == room_id).first()
if not room:
raise GraphQLError("Room not found")
update_entity_fields(room, **kwargs)
room.save()
requests.get(url=Config.MRM_PUSH_URL, params="hello")
return UpdateFirebaseToken(room=room)
def mutate(self, info, **kwargs):
validate_empty_fields(**kwargs)
validate_question_type(**kwargs)
validate_date_time_range(**kwargs)
question = QuestionModel(**kwargs)
payload = {
'model': QuestionModel,
'field': 'question',
'value': kwargs['question']
}
with SaveContextManager(question, 'Question', payload):
return CreateQuestion(question=question)
def mutate(self, info, node_list):
validate_structure_nodes(node_list)
admin_location_id = admin_roles.user_location_for_analytics_view()
nodes = []
for node in node_list:
validate_empty_fields(**node)
node['name'] = node.name.strip()
node['tag'] = node.tag.strip()
nodes.append(StructureModel(**node, location_id=admin_location_id))
db_session.add_all(nodes)
db_session.commit()
return CreateStructure(structure=nodes)
def mutate(self, info, room_id, **kwargs):
validate_empty_fields(**kwargs)
query_room = Room.get_query(info)
active_rooms = query_room.filter(RoomModel.state == "active")
room = active_rooms.filter(RoomModel.id == room_id).first()
if not room:
raise GraphQLError("Room not found")
update_entity_fields(room, **kwargs)
room.save()
subscriber.update_room_token.delay(room.calendar_id,
room.firebase_token)
return UpdateFirebaseToken(room=room)
def mutate(self, info, device_id, **kwargs):
validate_empty_fields(**kwargs)
query_device = Devices.get_query(info)
exact_device = query_device.filter(
DevicesModel.id == device_id
).first()
if not exact_device:
raise GraphQLError("Device ID not found")
update_entity_fields(exact_device, **kwargs)
exact_device.save()
return UpdateDevice(device=exact_device)
def mutate(self, info, question_id, **kwargs):
validate_empty_fields(**kwargs)
validate_question_type(**kwargs)
query_question = Question.get_query(info)
active_questions = query_question.filter(
QuestionModel.state == "active")
exact_question = active_questions.filter(
QuestionModel.id == question_id).first()
if not exact_question:
raise GraphQLError("Question not found")
validate_date_time_range(**kwargs)
update_entity_fields(exact_question, **kwargs)
exact_question.save()
return UpdateQuestion(question=exact_question)
def mutate(self, info, office_id, **kwargs):
validate_empty_fields(**kwargs)
get_office = Office.get_query(info)
result = get_office.filter(OfficeModel.state == "active")
exact_office = result.filter(OfficeModel.id == office_id).first()
if not exact_office:
raise GraphQLError("Office not found")
admin_roles.create_rooms_update_delete_office(office_id)
try:
update_entity_fields(exact_office, **kwargs)
exact_office.save()
except exc.SQLAlchemyError:
raise GraphQLError("Action Failed")
return UpdateOffice(office=exact_office)
def mutate(self, info, room_id, **kwargs):
validate_empty_fields(**kwargs)
query_room = Room.get_query(info)
active_rooms = query_room.filter(RoomModel.state == "active")
room = active_rooms.filter(RoomModel.id == room_id).first()
if not room:
raise GraphQLError("Room not found")
admin_roles.update_delete_rooms_create_resource(room_id)
room_tags = []
if kwargs.get('room_tags'):
room_tags = kwargs.pop('room_tags')
update_entity_fields(room, **kwargs)
previous_tags = room.room_tags
previous_tags.clear()
save_room_tags(room, room_tags)
return UpdateRoom(room=room)
def mutate(self, info, **kwargs):
validate_empty_fields(**kwargs)
if 'parent_id' in kwargs:
validate_parent_node_id(parent_id=kwargs['parent_id'])
if 'tag_id' in kwargs:
verify_tag_id(tag_id=kwargs['tag_id'])
node = OfficeStructureModel(**kwargs)
payload = {
'model': OfficeStructureModel,
'field': 'name',
'value': kwargs['name']
}
with SaveContextManager(
node, 'node level', payload
):
return CreateNode(node=node)
def mutate(self, info, **kwargs):
# Validate if the country given is a valid country
validate_country_field(**kwargs)
validate_timezone_field(**kwargs)
validate_url(**kwargs)
validate_empty_fields(**kwargs)
location = LocationModel(**kwargs)
admin = get_user_from_db()
email = admin.email
username = email.split("@")[0]
admin_name = username.split(".")[0]
payload = {
'model': LocationModel, 'field': 'name', 'value': kwargs['name']
}
with SaveContextManager(location, 'Location', payload):
if not send_email_notification(email, location.name, admin_name):
raise GraphQLError("Location created but email not sent")
return CreateLocation(location=location)
def mutate(self, info, **kwargs):
validate_empty_fields(**kwargs)
validate_question_type(**kwargs)
validate_date_time_range(**kwargs)
question_type = kwargs['question_type']
fields = kwargs
if question_type == "check" and not kwargs.get('check_options'):
return GraphQLError(
"No check options supplied for question type check")
if question_type != "check":
fields['check_options'] = None
payload = {
'model': QuestionModel,
'field': 'question',
'value': kwargs['question']
}
question = QuestionModel(**fields)
with SaveContextManager(question, 'Question', payload):
return CreateQuestion(question=question)
def mutate(self, info, **kwargs):
query = StructureNode.get_query(info)
node = query.filter(StructureModel.id == kwargs['node_id']).first()
if not node:
raise GraphQLError("node not found")
validate_empty_fields(**kwargs)
if kwargs.get('name'):
kwargs['name'] = kwargs['name'].strip()
else:
kwargs['name'] = node.name
if kwargs.get('tag'):
kwargs['tag'] = kwargs['tag'].strip()
else:
kwargs['tag'] = node.tag
update_entity_fields(node, **kwargs)
node.save()
return UpdateNode(node=node)
def mutate(self, info, location_id, **kwargs):
location = Location.get_query(info)
result = location.filter(LocationModel.state == "active")
location_object = result.filter(
LocationModel.id == location_id).first()
if not location_object:
raise GraphQLError("Location not found")
admin_roles.verify_admin_location(location_id)
if "time_zone" in kwargs:
validate_timezone_field(**kwargs)
if "country" in kwargs:
validate_country_field(**kwargs)
if "image_url" in kwargs:
validate_url(**kwargs)
validate_empty_fields(**kwargs)
active_locations = result.filter(
LocationModel.name == kwargs.get('name'))
if active_locations:
pass
else:
raise AttributeError("Not a valid location")
update_entity_fields(location_object, **kwargs)
location_object.save()
return UpdateLocation(location=location_object)
def __init__(self, **kwargs):
validate_empty_fields(**kwargs)
self.name = kwargs.get('name')
self.quantity = kwargs.get('quantity')
def __init__(self, **kwargs):
validate_empty_fields(**kwargs)
self.email = kwargs['email']
self.name = kwargs['name']
self.picture = kwargs['picture']
def __init__(self, **kwargs):
validate_empty_fields(**kwargs)
self.role = kwargs['role']
def __init__(self, **kwargs):
validate_empty_fields(**kwargs)
self.color = kwargs.get('color')
self.description = kwargs.get('description')
self.name = kwargs.get('name')
