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))