def mutate(self, info, **kwargs):
query = User.get_query(info)
user = query.filter_by(id=kwargs['user_id']).first()
if not user:
return GraphQLError("User not found")
update_entity_fields(user, **kwargs)
user.save()
return UpdateProfile(user=user)
def mutate(self, info, product_id, **kwargs):
product = Product.get_query(info)
product_obj = product.filter(ProductModel.id == product_id).first()
if not product:
raise GraphQLError("ProductModel not found")
update_entity_fields(product_obj, **kwargs)
product_obj.save()
return UpdateProduct(product=product_obj)
def mutate(self, info, tag_id, **kwargs):
query = Tag.get_query(info)
result = query.filter(TagModel.state == "active")
tag = result.filter(TagModel.id == tag_id).first()
if not tag:
raise GraphQLError("Tag not found")
update_entity_fields(tag, state="archived", **kwargs)
tag.save()
return DeleteTag(tag=tag)
def mutate(self, info, wing_id, **kwargs):
validate_empty_fields(**kwargs)
get_wing = Wing.get_query(info)
exact_wing = get_wing.filter(WingModel.id == wing_id).first()
if not exact_wing:
raise GraphQLError("Wing not found")
admin_roles.create_update_delete_wing()
update_entity_fields(exact_wing, **kwargs)
with SaveContextManager(exact_wing, kwargs['name'], 'Wing'):
return UpdateWing(wing=exact_wing)
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, 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, device_id, **kwargs):
query_device = Devices.get_query(info)
result = query_device.filter(DevicesModel.state == "active")
exact_device = result.filter(
DevicesModel.id == device_id
).first()
if not exact_device:
raise GraphQLError("Device not found")
update_entity_fields(exact_device, state="archived", **kwargs)
exact_device.save()
return DeleteDevice(device=exact_device)
def mutate(self, info, resource_id, **kwargs):
query_room_resource = Resource.get_query(info)
active_resources = query_room_resource.filter(
ResourceModel.state == "active")
exact_room_resource = active_resources.filter(
ResourceModel.id == resource_id).first()
if not exact_room_resource:
raise GraphQLError("Resource not found")
update_entity_fields(exact_room_resource, state="archived", **kwargs)
exact_room_resource.save()
return DeleteResource(resource=exact_room_resource)
def mutate(self, info, location_id, **kwargs):
query = Location.get_query(info)
result = query.filter(LocationModel.state == "active")
location = result.filter(
LocationModel.id == location_id).first() # noqa: E501
if not location:
raise GraphQLError("location not found")
admin_roles.verify_admin_location(location_id)
update_entity_fields(location, state="archived", **kwargs)
location.save()
return DeleteLocation(location=location)
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, question_id):
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")
update_entity_fields(exact_question, state="archived")
exact_question.save()
return DeleteQuestion(question=exact_question)
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, office_id, **kwargs):
query_office = Office.get_query(info)
result = query_office.filter(OfficeModel.state == "active")
exact_office = result.filter(
OfficeModel.id == office_id).first() # noqa: E501
if not exact_office:
raise GraphQLError("Office not found")
admin_roles.create_rooms_update_delete_office(office_id)
update_entity_fields(exact_office, state="archived", **kwargs)
exact_office.save()
return DeleteOffice(office=exact_office)
def mutate(self, info, block_id, **kwargs):
validate_empty_fields(**kwargs)
query = Block.get_query(info)
exact_block = query.filter(BlockModel.id == block_id).first()
if not exact_block:
raise GraphQLError("Block not found")
admin_roles.update_delete_block(block_id)
update_entity_fields(exact_block, **kwargs)
exact_block.save()
return UpdateBlock(block=exact_block)
def mutate(self, info, room_id, **kwargs):
validate_empty_fields(**kwargs)
query_room = Room.get_query(info)
exact_room = query_room.filter(RoomModel.id == room_id).first()
if not exact_room:
raise GraphQLError("Room not found")
admin_roles.update_delete_rooms_create_resource(room_id)
update_entity_fields(exact_room, **kwargs)
exact_room.save()
return UpdateRoom(room=exact_room)
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, room_id, **kwargs):
query_room = Room.get_query(info)
active_rooms = query_room.filter(RoomModel.state == "active")
exact_room = active_rooms.filter(RoomModel.id == room_id).first()
if not exact_room:
raise GraphQLError("Room not found")
exact_room.room_tags.clear()
admin_roles.update_delete_rooms_create_resource(room_id)
update_entity_fields(exact_room, state="archived", **kwargs)
exact_room.save()
subscriber.remove_room.delay(exact_room.calendar_id)
return DeleteRoom(room=exact_room)
def mutate(self, info, resource_id, **kwargs):
validate_empty_fields(**kwargs)
query = Resource.get_query(info)
exact_resource = query.filter(ResourceModel.id == resource_id).first()
if not exact_resource:
raise GraphQLError("Resource not found")
admin_roles.update_resource(resource_id, room_id=kwargs['room_id'])
update_entity_fields(exact_resource, **kwargs)
exact_resource.save()
return UpdateRoomResource(resource=exact_resource)
def mutate(self, info, **kwargs):
query = Question.get_query(info)
questions = query.all()
new_total_views = 0
for question in questions:
if kwargs['increment_total_views'] and not question.total_views:
new_total_views = 1
if kwargs['increment_total_views'] and question.total_views:
new_total_views = question.total_views + 1
update_entity_fields(question, total_views=new_total_views)
question.save()
return UpdateQuestionViews(questions=questions)
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, office_id, **kwargs):
validate_empty_fields(**kwargs)
get_office = Office.get_query(info)
exact_office = get_office.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, email, **kwargs):
query_user = User.get_query(info)
active_user = query_user.filter(UserModel.state == "active")
exact_query_user = active_user.filter(UserModel.email == email).first()
user_from_db = get_user_from_db()
if not verify_email(email):
raise GraphQLError("Invalid email format")
if not exact_query_user:
raise GraphQLError("User not found")
if user_from_db.email == email:
raise GraphQLError("You cannot delete yourself")
update_entity_fields(exact_query_user, state="archived", **kwargs)
exact_query_user.save()
return DeleteUser(user=exact_query_user)
def mutate(self, info, room_id, **kwargs):
query_room = Room.get_query(info)
active_rooms = query_room.filter(RoomModel.state == "active")
exact_room = active_rooms.filter(
RoomModel.id == room_id).first()
if not exact_room:
raise GraphQLError("Room not found")
exact_room.room_tags.clear()
admin_roles.update_delete_rooms_create_resource(room_id)
update_entity_fields(exact_room, state="archived", **kwargs)
exact_room.save()
requests.delete(url=Config.MRM_PUSH_URL + "/delete_room",
params={"calendar_id": exact_room.calendar_id})
return DeleteRoom(room=exact_room)
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, resource_id):
query_resources = Resource.get_query(info)
exact_resource = query_resources.filter(and_(
ResourceModel.state == "active",
ResourceModel.id == resource_id)).first()
if not exact_resource:
raise GraphQLError("Resource not found")
update_entity_fields(exact_resource, state="archived")
query_room_resource = RoomResource.get_query(info)
room_resources = query_room_resource.filter(
RoomResourceModel.resource_id == resource_id).all()
for room_resource in room_resources:
room_resource.delete()
exact_resource.save()
return DeleteResource(resource=exact_resource)
def mutate(self, info, location_id, **kwargs):
location = Location.get_query(info)
location_object = location.filter(
LocationModel.id == location_id).first()
if not location_object:
raise GraphQLError("Location not found")
if "time_zone" in kwargs:
validate_timezone_field(**kwargs)
if "country" in kwargs:
validate_country_field(**kwargs)
if "name" in kwargs or "abbreviation" in kwargs or "imageUrl" in kwargs: # noqa
validate_empty_fields(**kwargs)
update_entity_fields(location_object, **kwargs)
location_object.save()
return UpdateLocation(location=location_object)
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, floor_id, **kwargs):
validate_empty_fields(**kwargs)
query_floor = Floor.get_query(info)
exact_floor = query_floor.filter(FloorModel.id == floor_id).first()
if not exact_floor:
raise GraphQLError("Floor not found")
admin_roles.update_delete_floor(floor_id)
result = query_floor.filter(
FloorModel.block_id == exact_floor.block_id,
FloorModel.name == kwargs.get('name').capitalize())
if result.count() > 0:
ErrorHandler.check_conflict(self, kwargs['name'], 'Floor')
update_entity_fields(exact_floor, **kwargs)
exact_floor.save()
return UpdateFloor(floor=exact_floor)
def mutate(self, info, resource_id, room_id, **kwargs):
room_resource_query = RoomResource.get_query(info)
rooms_with_resource = room_resource_query.filter(
RoomResourceModel.room_id == room_id).all()
if not rooms_with_resource:
raise GraphQLError('Room has no assigned resource')
current_resource = None
for room_resource in rooms_with_resource:
if room_resource.resource_id == resource_id:
current_resource = room_resource.quantity
break
if current_resource is None:
raise GraphQLError('Resource does not exist in the room')
if kwargs['quantity'] < 0:
raise GraphQLError('Assigned quantity cannot be less than zero')
update_entity_fields(room_resource, **kwargs)
room_resource.save()
return UpdateAssignedResource(room_resource=room_resource)
def mutate(self, info, response_id):
responses_query = Response.get_query(info)
exact_response = responses_query.filter(
ResponseModel.id == response_id, ResponseModel.state == "active",
ResponseModel.resolved).first()
if not exact_response:
raise GraphQLError("The specified response does not exist\
or hasn't been resolved yet.")
update_entity_fields(exact_response, state="archived")
exact_response.save()
response = map_response_type(exact_response.question_type.name)(
exact_response.response)
return ArchiveResponse(room_response=ResponseDetail(
id=exact_response.id,
response=response,
room_id=exact_response.room_id,
question_type=exact_response.question_type.name,
resolved=exact_response.resolved,
state=exact_response.state.value))
