def mutate(
args: Dict,
info: graphql.execution.base.ResolveInfo,
user_study: InputUserStudy,
):
""" Upserts a `ModelUserStudy` record based on the `user_study` input.
Returns
MutationUserStudyUpsert: The result of the mutation.
"""
# Cleanup the Auth0 user ID.
auth0_user_id = clean_auth0_user_id(auth0_user_id=str(
user_study.auth0_user_id), )
# Retrieve the NCT ID of the defined study.
nct_id = str(user_study.nct_id)
# Check that the requesting user is authorized to upsert the user with
# the given Auth0 ID.
check_auth(info=info, auth0_user_id=auth0_user_id)
# Retrieve the session out of the context as the `get_query` method
# automatically selects the model.
session = info.context.get("session") # type: sqlalchemy.orm.Session
# Retrieve the `ModelUser` record object.
user = get_user(session=session, auth0_user_id=auth0_user_id)
# Raise an exception if the requested user could not be found.
if not user:
msg = "User with Auth0 ID '{}' could not be found."
msg_fmt = msg.format(auth0_user_id)
raise graphql.GraphQLError(message=msg_fmt)
# Retrieve the `ModelStudy` record object.
study = get_study(session=session, nct_id=nct_id)
# Raise an exception if the requested study could not be found.
if not study:
msg = "Study with NCT ID '{}' could not be found."
msg_fmt = msg.format(nct_id)
raise graphql.GraphQLError(message=msg_fmt)
# Upsert the `ModelUserStudy` record.
statement = insert(ModelUserStudy,
values={
"user_id": user.user_id,
"study_id": study.study_id,
}).on_conflict_do_nothing() # type: Insert
# Execute the upsert.
result = session.execute(statement) # type: ResultProxy
# Retrieve the newly upserted `ModelUser` record object.
obj = get_user(session=session, auth0_user_id=auth0_user_id)
session.commit()
return MutationUserStudyUpsert(user=obj)
def mutate_and_get_payload(cls, root, info, **input):
house_query = HouseNode.get_query(info)
house = house_query.filter(HouseModel.name == input['house_name']).first()
if not house:
raise gq.GraphQLError(f'Could not find house with name {input["house_name"]}')
student = StudentModel(
name=input['name'],
house=house,
wand_wood=input.get('wand_wood'),
wand_core=input.get('wand_core'),
wand_length=input.get('wand_length', 0),
wand_length_unit=input.get('wand_length_unit'),
)
student_query = StudentNode.get_query(info)
# trying to follow PEP8
# https://www.python.org/dev/peps/pep-0008/#should-a-line-break-before-or-after-a-binary-operator
found_students = student_query.filter(
(StudentModel.name == student.name)
and (StudentModel.house_id == student.house_id)
and (StudentModel.wand_wood == student.wand_wood)
and (StudentModel.wand_core == student.wand_core)
and (StudentModel.wand_length == student.wand_length)
and (StudentModel.wand_length_unit == student.wand_length_unit)).all() # yapf: disable
if len(found_students):
for s in found_students:
print(s.id)
raise gq.GraphQLError(f'Student with attributes {input} already exists')
db.db_session.add(student)
db.db_session.commit()
return CreateStudent(student=student, success=True)
def resolve_calculatePrice(self, info, arg):
# get input data
type = arg.get('type')
margin = arg.get('margin')
exchangeRate = arg.get('exchangeRate')
# make api call
url = 'https://api.coindesk.com/v1/bpi/currentprice/USD.json'
try:
request = requests.get(url)
except:
raise graphql.GraphQLError('request failed')
if request.status_code is not 200:
raise graphql.GraphQLError('request failed')
result = request.json()
currentPrice = result['bpi']['USD']['rate_float']
if type is 'sell':
val = currentPrice - (margin / 100)
else:
val = currentPrice + (margin / 100)
return exchangeRate * val
def mutate(root, info, **kwargs):
threshold = Threshold()
thresholdInput = kwargs.get("thresholdInput")
thresholdId = kwargs.get("thresholdId")
if thresholdId is None:
raise graphql.GraphQLError("Missing argument: thresholdId")
threshold = Threshold.objects.filter(id=thresholdId).first()
if threshold is None:
raise graphql.GraphQLError(
f"threshold with id {thresholdId} not found")
args = ["name", "default", "min", "max", "current", "moduleId"]
for arg in args:
valueFromInput = getattr(thresholdInput, arg)
if valueFromInput is not None:
setattr(threshold, arg, valueFromInput)
moduleIdOfThreshold = thresholdInput.get("moduleId")
if moduleIdOfThreshold is not None:
moduleOfThreshold = Module.objects.filter(
id=moduleIdOfThreshold).first()
if moduleOfThreshold is None:
raise graphql.GraphQLError(
"module #{} does not exist !".format(moduleIdOfThreshold))
threshold.module = moduleOfThreshold
threshold.save(force_update=True)
return UpdateThreshold(threshold=threshold)
def mutate(root, info, **kwargs):
requiredArgs = ["moduleId", "boxId", "boxAuthCode", "moduleAuthCode"]
for requiredArg in requiredArgs:
if kwargs.get(requiredArg) is None:
raise GraphQLError(f"missing argument: {requiredArg}")
affectedModule = Module.objects.filter(pk=kwargs["moduleId"]).first()
if affectedModule is None:
raise graphql.GraphQLError("Module #{} does not exist".format(
kwargs["moduleId"]))
if affectedModule.authCode != kwargs["moduleAuthCode"]:
raise GraphQLError(
f"Invalid auth code provided for module #{kwargs['moduleId']}")
box = Box.objects.filter(pk=kwargs["boxId"]).first()
if box is None:
raise graphql.GraphQLError(
f"Box #{kwargs['boxId']} does not exist")
if box.authCode != kwargs["boxAuthCode"]:
raise graphql.GraphQLError(
f"Invalid auth code provided for box {kwargs['boxId']}")
affectedModule.box = box
affectedModule.save(force_update=True)
return AssignModuleToBox(module=affectedModule)
def mutate(root,
info,
create_input: TaskInputCreate = None,
update_input: TaskInputUpdate = None):
if create_input is None and update_input is None:
raise graphql.GraphQLError(
'Either create_input or update_input need '
'to be set')
if create_input is not None and update_input is not None:
raise graphql.GraphQLError(
'Only one of create_input or update_input '
'may be set')
if create_input is not None:
if create_input.credits_calc == CreditsCalc.FIXED and \
create_input.fixed_credits is None:
raise graphql.GraphQLError(
'If CreditsCalc is FIXED, fixed_credits needs to be set, '
'but is None')
if create_input.credits_calc == CreditsCalc.BY_FACTOR and \
create_input.factor is None:
raise graphql.GraphQLError(
'If CreditsCalc is BY_FACTOR, factor needs to be set, '
'but is None')
new_task_props: dict = create_input or update_input or dict()
new_task_props = remove_none_values(new_task_props)
task = save_task(info.context.user, **new_task_props)
return SaveTask(task=task)
def resolve_getBoxById(self, _, **kwargs):
boxId = kwargs.get("boxId")
authCode = kwargs.get("boxAuthCode")
box = None
try:
box = Box.objects.get(pk=boxId)
except Box.DoesNotExist:
raise graphql.GraphQLError("box #{} does not exist".format(boxId))
if authCode != box.authCode:
raise graphql.GraphQLError(
"invalid authcode for box #".format(boxId))
return box
def mutate_and_get_payload(cls, root, info, house_name, id, client_mutation_id=None):
student_id = gq_relay.from_global_id(id)[1]
student_query = StudentNode.get_query(info)
student = student_query.filter(StudentModel.id == student_id).first()
if not student:
raise gq.GraphQLError(f'Could not find student with id {id}')
house_query = HouseNode.get_query(info)
house = house_query.filter(HouseModel.name == house_name).first()
if not house:
raise gq.GraphQLError(f'Could not find house {house_name}')
student.house = house
db.db_session.commit()
return ChangeStudentHouse(student=student, success=True)
def resolve_getUser(self, info, **kwargs):
userName = kwargs.get("userName")
password = kwargs.get("password")
user = None
try:
user = User.objects.get(name=userName)
except User.DoesNotExist:
raise graphql.GraphQLError("User '{}' not found".format(userName))
if not bcrypt.checkpw(password.encode('utf8'),
user.password.encode('utf8')):
raise graphql.GraphQLError(
"invalid password for User '{}'".format(userName))
return user
def mutate(
args: Dict,
info: graphql.execution.base.ResolveInfo,
auth0_user_id: str,
search_uuid: uuid.UUID,
):
""" Deletes a `ModelSearch` record and all its `ModelSearchDescriptor`
records.
Returns
MutationSearchUpsert: The result of the mutation.
"""
# Cleanup the Auth0 user ID.
auth0_user_id = clean_auth0_user_id(auth0_user_id=str(auth0_user_id))
# Check that the requesting user is authorized to make changes to the
# user with the given Auth0 ID.
check_auth(info=info, auth0_user_id=auth0_user_id)
# Retrieve the session out of the context as the `get_query` method
# automatically selects the model.
session = info.context.get("session") # type: sqlalchemy.orm.Session
# Retrieve the `ModelUser` record object.
user = get_user(session=session, auth0_user_id=auth0_user_id)
# Raise an exception if the requested user could not be found.
if not user:
raise graphql.GraphQLError(
message=f"User with Auth0 ID '{auth0_user_id}' could not be "
f"found.")
# Retrieve the `ModelSearch` record object.
search = get_search(session=session, search_uuid=search_uuid)
# Raise an exception if the requested search could not be found.
if not search:
raise graphql.GraphQLError(
message=f"Search with UUID '{search_uuid}' under user with "
f"Auth0 ID '{auth0_user_id}' could not be found.")
# Delete the `ModelSearch` record and all its related `ModelUserSearch`
# and `ModelSearchDescriptor` records.
delete_search(session=session, search_id=search.search_id)
session.commit()
return MutationSearchDelete(search=search)
async def test_send_execution_result(self, server, conn_context):
data = {"test": "data"}
error = graphql.GraphQLError(
"test message",
graphql.language.Node(),
source=graphql.Source("query { something }"),
positions=[14, 40],
path=["one", 2],
original_error=ValueError("original"),
extensions={"ext": None},
)
exec_result = graphql.ExecutionResult(data=data, errors=[error])
await server.send_execution_result(conn_context, OP_ID, exec_result)
assert conn_context.send_queue.qsize() == 1
msg = conn_context.send_queue.get_nowait()
assert json.loads(msg) == {
"type": GQLMsgType.DATA.value,
"id": OP_ID,
"payload": {
"data":
data,
"errors": [{
"message": "test message",
"locations": [[1, 15], [1, 20]],
"path": ERROR.path,
"extensions": ERROR.extensions,
}],
},
}
def mutate(self, root, info, **args):
todo = Todo.objects.filter(user_id__exact=args.get('user_id', 1),
id__exact=args.get('todo_id'))
if not todo:
raise graphql.GraphQLError('Todo not found')
todo = todo[0].update_item(item_name=args.get('item_name'))
return UpdateTodo(todo=todo)
def resolve_project(parent, info, name):
try:
project = REPOSITORY.get_project(name=name)
except EntityDoesNotExist:
raise graphql.GraphQLError("Project does not exist!")
return project
def resolve_staff_by_position(self, info, position):
query = StaffNode.get_query(info)
# for demonstration purposes
pprint(str(query))
if not position:
raise gq.GraphQLError('Please provide staff position')
return query.filter(StaffModel.position == position).all()
def mutate(self, root, info, **args):
todo = Todo.objects.filter(user_id__exact=args.get('user_id', 1),
id__exact=args.get('todo_id'))
if not todo:
raise graphql.GraphQLError('Todo not found')
todo[0].delete()
return DeleteTodo(todo='Todo was deleted successfully')
def resolveReport(root, info, token, brokerId, accountNumber):
try:
auth.decodeToken(token)
report = makeReport(brokerId, accountNumber, "Current Report")
return serializeReport(report)
except AssertionError as e:
raise graphql.GraphQLError(e)
def mutate(self, info, name, description, is_internal, is_global):
try:
project = REPOSITORY.create_project(
name, description, is_internal, is_global
)
except EntityCreationException:
raise graphql.GraphQLError("Could not create a project")
return CreateProjectMutation(project=project)
def mutate_and_get_payload(cls, root, info, id, client_mutation_id=None):
student_id = gq_relay.from_global_id(id)[1]
student_query = StudentNode.get_query(info)
student = student_query.filter(StudentModel.id == student_id).first()
if not student:
raise gq.GraphQLError(f'Could not find student with id {id}')
db.db_session.delete(student)
db.db_session.commit()
return DeleteStudent(student=student, success=True)
def mutate(self, info, token, _id):
try:
auth.decodeToken(token)
response = requests.delete(
"{}/brokers/{}".format(config.HARAMBE_DATA_SERVICE_ENDPOINT, _id))
assert (response.status_code == 200), "Error removing broker"
return RemoveBrokerAccount(True)
except AssertionError as e:
raise graphql.GraphQLError(e)
def mutate(
args: Dict,
info: graphql.execution.base.ResolveInfo,
auth0_user_id: str,
):
""" Deletes a `ModelUser` record based on the `user` input.
Returns
MutationUserDelete: The result of the mutation.
"""
# Cleanup the Auth0 user ID.
auth0_user_id = clean_auth0_user_id(auth0_user_id=str(auth0_user_id))
# Check that the requesting user is authorized to upsert the user with
# the given Auth0 ID.
check_auth(info=info, auth0_user_id=auth0_user_id)
# Retrieve the session out of the context as the `get_query` method
# automatically selects the model.
session = info.context.get("session") # type: sqlalchemy.orm.Session
# Retrieve the `ModelUser` record object.
query = session.query(ModelUser)
query = query.filter(ModelUser.auth0_user_id == auth0_user_id)
obj = query.one_or_none() # type: ModelUser
# Raise an exception if the requested user could not be found.
if not obj:
msg = "User with Auth0 ID '{}' could not be found."
msg_fmt = msg.format(auth0_user_id)
raise graphql.GraphQLError(message=msg_fmt)
# Delete the `ModelSearch` records related to this user as well as all
# `ModelUserSearch` and `ModelSearchDescriptor` records related to
# those searches.
delete_user_searches(session=session, user_id=obj.user_id)
# Delete all `ModelUserStudy` records related to this user.
query = session.query(ModelUserStudy)
query = query.filter(ModelUserStudy.user_id == obj.user_id)
query.delete()
# Delete all `ModelUserCitation` records related to this user.
query = session.query(ModelUserCitation)
query = query.filter(ModelUserCitation.user_id == obj.user_id)
query.delete()
# Delete the `ModelUser` record.
session.delete(obj)
session.commit()
return MutationUserDelete(user=obj)
def resolve_by_search_uuid(
args: dict,
info: graphene.ResolveInfo,
auth0_user_id: str,
search_uuid: str,
) -> ModelSearch:
""" Retrieves a `ModelUser` record object through its Auth0 IDs.
Args:
args (dict): The resolver arguments.
info (graphene.ResolveInfo): The resolver info.
auth0_user_id (str): The Auth0 ID of the user to which the search
belongs.
search_uuid (uuid.UUID): The search UUID for which the
`ModelSearch` record object will be retrieved.
Returns:
ModelSearch: The retrieved `ModelSearch` record object or `None`
if no matches were found.
"""
# Cleanup the Auth0 user ID.
auth0_user_id = clean_auth0_user_id(auth0_user_id=str(auth0_user_id))
# Check that the requesting user is authorized to retrieve the user with
# the given Auth0 ID.
check_auth(info=info, auth0_user_id=auth0_user_id)
# Retrieve the query on `ModelSearch`.
query = TypeSearch.get_query(
info=info,
) # type: sqlalchemy.orm.query.Query
# Filter to the `ModelSearch` record matching the `search_uuid`.
query = query.filter(ModelSearch.search_uuid == search_uuid)
# Limit query to fields requested in the GraphQL query adding
# `load_only` and `joinedload` options as required.
query = apply_requested_fields(
info=info,
query=query,
orm_class=ModelSearch,
)
obj = query.one_or_none()
# Raise an exception if the requested search could not be found.
if not obj:
msg = "Search with UUID '{}' could not be found."
msg_fmt = msg.format(search_uuid)
raise graphql.GraphQLError(message=msg_fmt)
return obj
def resolve_search_by_house(self, info, house_name):
staff_query = StaffNode.get_query(info)
student_query = StudentNode.get_query(info)
house_query = HouseNode.get_query(info)
if not house_name:
raise gq.GraphQLError('Please provide house name')
house = house_query.filter(HouseModel.name == house_name).first()
staff_results = staff_query.filter(StaffModel.house == house).all()
student_results = student_query.filter(StudentModel.house == house).all()
return staff_results + student_results
def resolveUser(root, info, token):
try:
decoded = auth.decodeToken(token)
response = requests.get("{}/users/{}".format(config.HARAMBE_DATA_SERVICE_ENDPOINT, decoded.get("user_id")))
assert(response.status_code == 200), "Could not retrieve user"
data = response.json()
return serializeUser(data)
except AssertionError as e:
raise graphql.GraphQLError(e)
def getBrokerAccounts(user_id, user_token):
try:
accountResponse = requests.post(
"{}/getAccounts".format(config.HARAMBE_TRADING_SERVICE_ENDPOINT),
json={"user_id": user_id, "user_token": user_token}
)
assert (accountResponse.status_code == 200), "Could not retrieve list of broker accounts"
accountData = accountResponse.json()
return accountData.get("accounts")
except AssertionError as e:
raise graphql.GraphQLError(e)
def mutate_and_get_payload(cls, root, info, **input):
course_id = input.get('id')
object_type, object_id = from_global_id(course_id)
if object_type != 'Course':
raise graphql.GraphQLError('Bad course id')
index, course = [(i, c) for i, c in enumerate(COURSES)
if c.id == object_id][0]
course.description = input.get('description')
COURSES[index] = course
return UpdateCourseDescription(course=course)
def mutate(root, info, **kwargs):
boxId = kwargs.get("boxId")
boxAuthCode = kwargs.get("boxAuthCode")
sampleInputs = kwargs.get("samples")
box = None
try:
box = Box.objects.get(pk=boxId)
except Box.DoesNotExist:
raise graphql.GraphQLError("Box #{} does not exist".format(boxId))
if box.authCode != boxAuthCode:
raise graphql.GraphQLError("Invalid box authentication code")
nbSentSamples = 0
for sampleInput in sampleInputs:
dbSample = Sample()
sampleModule = None
try:
sampleModule = Module.objects.get(pk=sampleInput.moduleId)
except:
raise graphql.GraphQLError("module #{} does not exist".format(sampleInput.moduleId))
[setattr(dbSample, key, value) for key, value in sampleInput.items()]
dbSample.module = sampleModule
dbSample.save(force_insert=True)
nbSentSamples += 1
# Send the new samples to the analyzer.
# If an environmental anomaly is detected,
# it will notify the user owning the box
DataMonitor.analyzeNewSamples(
user=box.user
, box=box
, sampleList=sampleInputs
)
return SendSamples(nbSentSamples=nbSentSamples)
def resolveReports(root, info, token, accountNumber):
try:
response = requests.get(
"{}/reports?broker_account_number__$eq={}".format(
config.HARAMBE_DATA_SERVICE_ENDPOINT, accountNumber))
assert (
response.status_code == 200), "Could not retrieve list of reports"
data = response.json()
reports = [serializeReport(r) for r in data]
return reports
except AssertionError as e:
raise graphql.GraphQLError(e)
def mutate(self, info, token, brokerId, accountNumber, description):
try:
auth.decodeToken(token)
report = makeReport(brokerId, accountNumber, description)
response = requests.post("{}/reports".format(
config.HARAMBE_DATA_SERVICE_ENDPOINT),
json=report)
assert (response.status_code == 200), "Could not create report"
return serializeReport(report)
except AssertionError as e:
raise graphql.GraphQLError(e)
def mutate(root, info, **kwargs):
threshold = Threshold()
thresholdInput = kwargs.get("thresholdInput")
requiredArgs = ["name", "default", "min", "max", "current"]
for requiredArgKey in requiredArgs:
valueFromInput = getattr(thresholdInput, requiredArgKey)
if valueFromInput is None:
raise graphql.GraphQLError(
f"Missing argument: {requiredArgKey}")
setattr(threshold, requiredArgKey, valueFromInput)
moduleIdOfThreshold = thresholdInput.get("moduleId")
if moduleIdOfThreshold is None:
raise graphql.GraphQLError(f"Missing argument: moduleId")
moduleOfThreshold = Module.objects.filter(
id=moduleIdOfThreshold).first()
if moduleOfThreshold is None:
raise graphql.GraphQLError(
"module #{} does not exist !".format(moduleIdOfThreshold))
threshold.module = moduleOfThreshold
threshold.save(force_insert=True)
return CreateThreshold(threshold=threshold)
def resolveBroker(root, info, _id, token):
try:
# decode token
auth.decodeToken(token)
response = requests.get(
"{}/brokers/{}".format(config.HARAMBE_DATA_SERVICE_ENDPOINT, _id))
assert (response.status_code == 200), "Could not retrieve broker"
data = response.json()
broker = serializeBroker(data)
return broker
except AssertionError as e:
raise graphql.GraphQLError(e)
