def main():
MongoDBConnection.initialize_connection('db', 27017)
app = connexion.App(__name__, specification_dir='./swagger/')
CORS(app.app)
app.app.json_encoder = encoder.JSONEncoder
app.add_api('swagger.yaml',
arguments={'title': 'YoungRes data comsuption API'},
pythonic_params=True)
app.run(port=8080)
def main():
#initilize connection with MongoDB
MongoDBConnection.initialize_connection('db', 27017)
# start the api server
app = connexion.App(__name__, specification_dir='./swagger/')
CORS(app.app)
app.app.json_encoder = encoder.JSONEncoder
app.add_api('swagger.yaml',
arguments={'title': 'YoungRes gameplay API'},
pythonic_params=True)
app.run(port=8080)
def get_filter_values(table, column):
if table == 'groups':
values = MongoDBConnection.get_groups_collection().distinct(column)
elif table == 'students':
values = MongoDBConnection.get_students_collection().distinct(column)
elif table == 'test':
values = MongoDBConnection.get_tests_collection().distinct(column)
elif table == 'saved_state':
values = MongoDBConnection.get_saved_state_collection().distinct(
column)
elif table == 'games':
values = MongoDBConnection.get_games_collection().distinct(column)
elif table == 'chapters':
values = MongoDBConnection.get_chapters_collection().distinct(column)
elif table == 'events':
values = MongoDBConnection.get_events_collection().distinct(column)
elif table == 'decisions':
values = MongoDBConnection.get_decisions_collection().distinct(column)
try:
values = list(map(int, values))
return [min(values), max(values)]
except:
return values
def get_events(game_code, version, chapter_code) -> pymongo.cursor.Cursor:
db = MongoDBConnection.get_events_collection()
return db.find({
'chapterCode': chapter_code,
'gameCode': game_code,
'version': version
})
def get_student_and_group(student_code: str) -> dict:
db = MongoDBConnection.get_students_collection()
cursor = db.aggregate([{
"$match": {
"studentCode": student_code
}
}, {
"$lookup": {
"from": "groups",
"localField": "groupCode",
"foreignField": "groupCode",
"as": "group"
}
}, {
"$unwind": "$group"
}, {
"$project": {
"_id": 0,
"studentCode": 1,
"sex": 1,
"age": 1,
"country": "$group.country",
"city": "$group.city",
"groupCode": "$group.groupCode"
}
}])
return list(cursor)[0] if cursor is not None else None
def get_group_filter_type(field):
return MongoDBConnection.get_filters_collection().find_one(
{
'table': 'groups',
'field': field
}, {'_id': 0})
def get_game_students(game_code: str, version: str) -> List[str]:
db = MongoDBConnection.get_events_collection()
events = [
r['eventCode']
for r in db.find({
'gameCode': game_code,
'version': version
}, {'eventCode': 1})
]
db = MongoDBConnection.get_decisions_collection()
return db.find({
'eventCode': {
'$in': events
}
}, {
'studentCode': 1
}).distinct('studentCode')
def get_group_filter_values(group_ids: List[str], column: str) -> List[str]:
db = MongoDBConnection.get_groups_collection()
return db.find({
'groupCode': {
'$in': group_ids
}
}, {
'_id': 0,
column: 1
}).distinct(column)
def post_saved_state_scene(student_code: str, game_code: str, version: str, variable_name: str, value: str):
#docs = MongoDBConnection.get_saved_states_collection().find({'studentCode':str(student_code), 'gameCode':str(game_code), 'version':str(version)})
savedStateVariables = MongoDBConnection.get_saved_states_collection().find_one({'studentCode':student_code, 'gameCode':game_code, 'version':version})
if savedStateVariables is not None:
savedStateVariables['variables'][variable_name] = value
MongoDBConnection.get_saved_states_collection().find_one_and_replace({'studentCode':student_code, 'gameCode':game_code, 'version':version}, savedStateVariables)
else:
# make default saved state
savedStateVariables = {
'stateCode': student_code,
'studentCode': student_code,
'gameCode': game_code,
'version': version,
'variables': {
variable_name: value
}
}
MongoDBConnection.get_saved_states_collection().insert_one(savedStateVariables)
def get_student_filter_values(student_ids: List[str],
column: str) -> List[str]:
db = MongoDBConnection.get_students_collection()
return db.find({
'studentCode': {
'$in': student_ids
}
}, {
'_id': 0,
column: 1
}).distinct(column)
def get_decisions(student_ids: List[str],
event_ids: List[str]) -> pymongo.cursor.Cursor:
db = MongoDBConnection.get_decisions_collection()
decisions = db.find({
'studentCode': {
'$in': student_ids
},
'eventCode': {
'$in': event_ids
}
})
return decisions
def get_chapter(game_code, version, chapter_code):
gameChapter = MongoDBConnection.get_chapters_collection().find_one({
'chapterCode':
chapter_code,
'gameCode':
game_code,
'version':
version
})
return gameChapter
def get_filter_type_dict(table: str) -> Dict[str, str]:
"""
Returns a dictionary where the keys are the different 'field' in the table
and the values are the types of those fields
"""
db = MongoDBConnection.get_filters_collection()
f_dict = {}
with db.find({'table': table}, {'field': 1, 'type': 1}) as cursor:
for row in cursor:
f_dict[row['field']] = row['type']
return f_dict
def post_decision(student_code: str, event_code: str, decision: Decision):
ids = MongoDBConnection.get_decisions_collection().find().distinct('decisionCode')
finalDecision = {}
for dec in decision._decision:
finalDecision[dec._key] = dec._value
_existing = MongoDBConnection.get_decisions_collection().find_one({'eventCode':event_code, 'studentCode':student_code})
if _existing is not None:
MongoDBConnection.get_decisions_collection().update_one({'eventCode':event_code, 'studentCode':student_code},{'$set': {'fields':finalDecision}})
else:
MongoDBConnection.get_decisions_collection().insert_one({'eventCode':event_code, 'studentCode':student_code,'fields':finalDecision})
def get_event_by_id(_id):
event = MongoDBConnection.get_events_collection().find_one(
{'eventCode': _id})
return event
def get_saved_state(student_code: str, game_code: str, version: str, variable_name: str):
savedStateVariables = MongoDBConnection.get_saved_states_collection().find_one({'studentCode':student_code, 'gameCode':game_code, 'version':version})
if savedStateVariables is not None and variable_name in savedStateVariables['variables']:
return savedStateVariables['variables'][variable_name]
else:
return None
def get_students_in_groups(group_ids: List[str]) -> pymongo.cursor.Cursor:
db = MongoDBConnection.get_students_collection()
return db.find({'groupCode': {'$in': group_ids}})
def student_exists(studentCode: str) -> bool:
db = MongoDBConnection.get_students_collection()
return db.find_one({'studentCode': studentCode}) is not None
def get_start_scene(game_code: str, version: str, chapter_code: str) -> Dict[str, str]:
gameChapters = MongoDBConnection.get_chapters_collection().find_one({'chapterCode':chapter_code, 'gameCode':game_code,'version':version})
if gameChapters is not None:
return {'startScene': gameChapters['startScene'], 'startX': gameChapters['startX'], 'startY': gameChapters['startY']}
else:
return None
def get_games():
games = MongoDBConnection.get_games_collection().find({})
return games
def get_game_countries(game_code, version, students):
db = MongoDBConnection.get_students_collection()
groups = db.find({"studentCode": {"$in": students}}).distinct('groupCode')
db = MongoDBConnection.get_groups_collection()
return db.find({"groupCode": {"$in": groups}}).distinct('country')
def get_filter(id):
return MongoDBConnection.get_filters_collection().find_one(
{'filterCode': id})
def get_user_credentials(username):
return MongoDBConnection.get_credentials_collection().find_one(
{"username": username})
def get_filters(ids: List[str], table: str = None) -> pymongo.cursor.Cursor:
query = {'filterCode': {'$in': ids}}
if table is not None:
query['table'] = table
return MongoDBConnection.get_filters_collection().find(query, {'_id': 0})
def get_group(id):
return MongoDBConnection.get_groups_collection().find_one(
{'groupCode': id})
def get_groups(ids: List[str]) -> pymongo.cursor.Cursor:
return MongoDBConnection.get_groups_collection().find(
{'groupCode': {
'$in': ids
}})
def get_groups_pass_filter(query: dict) -> List[str]:
db = MongoDBConnection.get_groups_collection()
return db.find(query, {'groupCode': 1}).distinct('groupCode')
def get_student(student_code):
student = MongoDBConnection.get_students_collection().find_one(
{'studentCode': student_code})
return student
