def test_removeStudent(self):
print('Running removeStudent test case')
userRole = 'admin'
email = '*****@*****.**'
classCode = 'f24613dc-f09d-4fd6-81f1-026784d6cc9b'
#Put user and class data into DB
usersTable = db.getTable('users', dynamodb)
classesTable = db.getTable('classes', dynamodb)
userJsonData = {'email': email, 'classCodes': [classCode]}
classJsonData = {'code': classCode, 'students': [email]}
db.putItem(userJsonData, usersTable)
db.putItem(classJsonData, classesTable)
#Check test data was successfully placed into DB
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('email'), email)
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('code'), classCode)
#Test removal
jsonData = {'email': email, 'classCode': classCode}
res = class_ctrl.removeStudent(dynamodb, jsonData, userRole=userRole)
self.assertFalse(res.hasErrors())
def createClass(dynamoDBInstance, classData, email=None, userRole=None):
response = ControllerResponse()
#g will be not be available during testing
#and email and userRole will need to be passed to the function
if g: # pragma: no cover
email = g.authenticatedUser['email']
userRole = g.authenticatedUser['userRole']
#role is confirmed here incase createClass is called from somewhere other
#than app.py create_class()
if userRole != 'teacher' and userRole != 'admin':
response.addError('Role error', 'Only teachers can create classes')
elif classData is None or not checkClassDataValid(classData):
response.addError('createClass call Failed.',
'Invalid class data given.')
else:
classTable = dbUtils.getTable('classes', dynamoDBInstance)
userTable = dbUtils.getTable('users', dynamoDBInstance)
if classTable is None or userTable is None:
response.addError('createClass call Failed.',
'Unable to locate necessary table(s).')
else:
classCode = str(uuid.uuid4())
newClass = {
'code': classCode,
'title': classData['title'],
'description': classData['description']
}
if 'department' in classData.keys() and classData['department']:
newClass['department'] = classData['department']
if 'section' in classData.keys() and classData['section']:
newClass['classSection'] = classData['section']
result = dbUtils.putItem(newClass, classTable)
if result is None:
response.addError('createClass call Failed.',
'Unable to create class in classes table.')
else:
# Note: if teaching attribute does not previously exist, a set of class codes will be created
# otherwise, the class code will be added to the set of class codes
codeSet = set([classCode])
jsonData = {
'Key': {
'email': email
},
'UpdateExpression': 'ADD teaching :classCode',
'ExpressionAttributeValues': {
':classCode': codeSet
},
'ReturnValues': 'UPDATED_NEW'
}
res = dbUtils.updateItem(jsonData, userTable)
if res is None:
response.addError('createClass call failed',
'Unable to update user data')
else:
response.addToPayload('Success', 'Class Created')
return response
def test_createMultipleClasses(self):
print('Running createMultipleClasses test case')
classData = {
'title': 'ENG',
'department': 'arts',
'section': '12',
'description': 'english'
}
classData2 = {
'title': 'PE',
'department': 'science',
'section': '1',
'description': 'physical education'
}
email = '*****@*****.**'
userRole = 'teacher'
class_ctrl.createClass(dynamodb, classData, email, userRole)
class_ctrl.createClass(dynamodb, classData2, email, userRole)
# check that teaching list was added to user
classesTable = db.getTable('classes', dynamodb)
usersTable = db.getTable('users', dynamodb)
data = {'Key': {'email': email}}
teacher = db.getItem(data, usersTable)
self.assertTrue('Item' in teacher.keys())
self.assertTrue('teaching' in teacher['Item'])
teachingSet = teacher['Item']['teaching']
self.assertEqual(len(teachingSet), 2)
# check that classes were created in classes table
class1Found = False
class2Found = False
for classCode in teachingSet:
data = {'Key': {'code': classCode}}
classItem = db.getItem(data, classesTable)
self.assertTrue('Item' in classItem.keys())
if (classItem['Item']['title'] == 'ENG'
and classItem['Item']['department'] == 'arts'
and classItem['Item']['classSection'] == '12'
and classItem['Item']['description'] == 'english'):
class1Found = True
elif (classItem['Item']['title'] == 'PE'
and classItem['Item']['department'] == 'science'
and classItem['Item']['classSection'] == '1' and
classItem['Item']['description'] == 'physical education'):
class2Found = True
self.assertTrue(class1Found)
self.assertTrue(class2Found)
def test_updateClassDetails(self):
print('Running updateClassDetails test')
classesTable = db.getTable('classes', dynamodb)
usersTable = db.getTable('users', dynamodb)
email = '*****@*****.**'
userRole = 'teacher'
# put data into db first
beforeUserData = {'email': email, 'teaching': ['before update code']}
beforeClassData = {
'title': 'before update title',
'department': 'before update department',
'description': 'before update description',
'classSection': 'before update section',
'code': 'before update code'
}
db.putItem(beforeClassData, classesTable)
db.putItem(beforeUserData, usersTable)
# check item was placed successfully
code = {'Key': {'code': 'before update code'}}
c = db.getItem(code, classesTable)
self.assertTrue('Item' in c.keys())
e = {'Key': {'email': email}}
user = db.getItem(e, usersTable)
self.assertTrue('Item' in user.keys())
# update class details
afterData = {
'title': 'after update title',
'department': 'after update department',
'description': 'after update description',
'section': 'after update section',
'code': 'before update code'
}
response = class_ctrl.updateClassDetails(afterData, dynamodb, email,
userRole)
self.assertEqual(response.payload,
{'Success': 'Class Details Updated'})
c = db.getItem(code, classesTable)
self.assertTrue('Item' in c.keys())
self.assertEqual(c['Item']['title'], 'after update title')
self.assertEqual(c['Item']['department'], 'after update department')
self.assertEqual(c['Item']['classSection'], 'after update section')
self.assertEqual(c['Item']['description'], 'after update description')
def addActivity(classCode, jsonData, dynamodb, email=None, userRole=None):
response = ControllerResponse()
classTable = dbUtils.getTable('classes', dynamodb)
if classTable is None:
MentiiLogging.getLogger().error(
'Unable to get classes table in getPublicClassList')
response.addError('Failed to add activity', 'A database error occured')
else:
if g: # pragma: no cover
email = g.authenticatedUser['email']
userRole = g.authenticatedUser['userRole']
if isTeacherOfClass(email, userRole, classCode, dynamodb):
classData = getClassByCode(classCode, dynamodb)
if not classData:
response.addError('Failed to add activity',
'A database error occured')
else:
activities = classData.get('activities', [])
activities.append(jsonData)
classData['activities'] = activities
result = dbUtils.putItem(classData, classTable)
if result is None:
response.addError('Failed to add activity',
'A database error occured')
else:
response.addToPayload('Success', 'Activity Added')
else:
MentiiLogging.getLogger().error(
email + ' is not the teacher of ' + classCode +
', but attempted to add an activity.')
response.addError('Unable to add activity',
'A permissions error occured')
return response
def removeClassFromStudent(dynamoDBInstance, response, email, classCode):
usersTable = dbUtils.getTable('users', dynamoDBInstance)
if usersTable is None:
MentiiLogging.getLogger().error(
'Unable to get users table in removeStudentFromClass')
response.addError('Remove Student From Class Failed.',
'Unable to locate necessary table(s).')
else:
# check that user exists and user has that class
user = user_ctrl.getUserByEmail(email, dynamoDBInstance)
if user is None:
MentiiLogging.getLogger().error(
'Unable to get user by email in removeStudentFromClass')
response.addError('Failed to remove student from class',
'Unable to find user')
else:
classCodes = user['classCodes'] #set
if classCode not in classCodes:
response.addError('Failed to remove class from student',
'Class not found')
else:
classCodes.remove(classCode)
jsonData = buildUpdateJsonData('email', email, 'classCodes',
classCodes)
res = dbUtils.updateItem(jsonData, usersTable)
if res is None:
MentiiLogging.getLogger().error(
'Unable to update classes in removeStudentFromClass')
response.addError('Failed to remove student from class',
'Unable to update user data')
else:
MentiiLogging.getLogger().info(
'Class removal success. Removed class from student')
return response
def getClassCodesFromUser(dynamoDBInstance, email=None):
classCodes = set()
if email is None: # pragma: no cover
email = g.authenticatedUser['email']
usersTable = dbUtils.getTable('users', dynamoDBInstance)
if usersTable is None:
MentiiLogging.getLogger().error(
'Unable to get users table in getClassCodesFromUser')
else:
#An active class list is the list of class codes that
# a user has in the user table.
request = {
"Key": {
"email": email
},
"ProjectionExpression": "classCodes"
}
res = dbUtils.getItem(request, usersTable)
#Get the class codes for the user.
if res is None or 'Item' not in res or 'classCodes' not in res['Item']:
MentiiLogging.getLogger().error(
'Unable to get user data in getClassCodesFromUser')
else:
classCodes = res['Item']['classCodes']
return classCodes
def test_changeUserRole_fail(self):
print('Running test_changeUserRole_fail test')
usersTable = db.getTable('users', dynamodb)
request = {
'Key': {
'email': '*****@*****.**'
},
'ProjectExpression': 'userRole'
}
response = db.getItem(request, usersTable)
self.assertEqual(response['Item']['userRole'], 'student')
badJsonData = {'email': '*****@*****.**', 'userRole': 'boss'}
# change user role to not defined role
usr.changeUserRole(badJsonData, dynamodb, adminRole='admin')
#role remains same as it was before failed attempt
response = db.getItem(request, usersTable)
self.assertEqual(response['Item']['userRole'], 'student')
badJsonData = {'email': '*****@*****.**', 'userRole': 'student'}
# try to change a user role of a non-existent user
response = usr.changeUserRole(badJsonData, dynamodb, adminRole='admin')
self.assertIsNone(response.payload.get('success'))
def test_removeClassFromStudent(self):
print('Running removeClassFromStudent test case')
userRole = 'admin'
email = '*****@*****.**'
classCode = 'f77668db-fb9d-4fd6-81f1-026784d6cc9b'
classCode2 = 'e00045db-fb9d-4fd6-81f1-026784d6cc9b'
res = ResponseCreation.ControllerResponse()
# Put user and class data into DB
usersTable = db.getTable('users', dynamodb)
userJsonData = {'email': email, 'classCodes': [classCode, classCode2]}
db.putItem(userJsonData, usersTable)
# Check test data was successfully placed into DB
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('email'), email)
class_ctrl.removeClassFromStudent(dynamodb, res, email, classCode2)
# Check that the classCode was removed from the student
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
cc = response.get('Item').get('classCodes')
self.assertFalse(classCode2 in cc)
self.assertTrue(classCode in cc)
def test_getTable(self):
print("Running getTable test")
tableName = "users"
returnedTable = db.getTable(tableName, self.dynamodb)
self.assertIsNotNone(returnedTable)
self.assertEqual(returnedTable.table_name, tableName)
self.assertEqual(returnedTable.table_status, "ACTIVE")
def addUserAndSendEmail(httpOrigin, email, password, mailer, dbInstance):
activationId = str(uuid.uuid4())
table = dbUtils.getTable('users', dbInstance)
jsonData = {
'email': email,
'password': password,
'activationId': activationId,
'active': 'F',
'userRole' : "student"
}
if table is None:
MentiiLogging.getLogger().error('Unable to get table users in addUserAndSendEmail')
activationId = None
#This will change an existing user with the same email.
response = dbUtils.putItem(jsonData,table)
if response is None:
MentiiLogging.getLogger().error('Unable to add user to table users in addUserAndSendEmail')
activationId = None
try:
sendEmail(httpOrigin, email, activationId, mailer)
except Exception as e:
MentiiLogging.getLogger().exception(e)
return activationId
def test_removeStudentFromClasss(self):
print('Running removeStudentFromClass test case')
userRole = 'admin'
email1 = '[email protected]'
email2 = '[email protected]'
classCode = 'f77668db-fb9d-4fd6-81f1-026784d6cc9b'
res = ResponseCreation.ControllerResponse()
#Put user and class data into DB
classesTable = db.getTable('classes', dynamodb)
classJsonData = {'code': classCode, 'students': [email1, email2]}
db.putItem(classJsonData, classesTable)
#Check test data was successfully placed into DB
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('code'), classCode)
class_ctrl.removeStudentFromClass(dynamodb, res, email1, classCode)
#check that the student was removed from the class
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
stu = response.get('Item').get('students')
self.assertFalse(email1 in stu)
self.assertTrue(email2 in stu)
def test_removeClassFromStudent_len_zero(self):
print(
'Running removeClassFromStudent students length is zero test case')
userRole = 'admin'
email = '*****@*****.**'
classCode = 'f84138db-fb9d-4fd6-81f1-026784d6cc9b'
res = ResponseCreation.ControllerResponse()
#Put user and class data into DB
usersTable = db.getTable('users', dynamodb)
userJsonData = {'email': email, 'classCodes': [classCode]}
db.putItem(userJsonData, usersTable)
# Check test data was successfully placed into DB
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('email'), email)
class_ctrl.removeClassFromStudent(dynamodb, res, email, classCode)
# Check that the attribute was removed from the student
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertIsNone(response.get('Item').get('classCodes'))
def test_removeStudentFromClass_len_zero(self):
print(
'Running removeStudentFromClass students length is zero test case')
userRole = 'admin'
email = '*****@*****.**'
classCode = 'f77998db-fb9d-4fd6-81f1-026784d6cc9b'
res = ResponseCreation.ControllerResponse()
#Put user and class data into DB
classesTable = db.getTable('classes', dynamodb)
classJsonData = {'code': classCode, 'students': [email]}
db.putItem(classJsonData, classesTable)
#Check test data was successfully placed into DB
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('code'), classCode)
class_ctrl.removeStudentFromClass(dynamodb, res, email, classCode)
#check that the attribute was removed from the class
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
self.assertIsNone(response.get('Item').get('students'))
def activate(activationId, dbInstance):
response = ControllerResponse()
table = dbUtils.getTable('users', dbInstance)
items = []
if table is None:
MentiiLogging.getLogger().error('Unable to get table users in activate')
response.addError('Could not access table. Error', 'The DB did not give us the table')
return response
#Scan for the email associated with this activationId
scanResponse = dbUtils.scanFilter('activationId', activationId, table)
if scanResponse is not None:
#scanResponse is a dictionary that has a list of 'Items'
items = scanResponse['Items']
if not items or 'email' not in items[0].keys():
response.addError('No user with activationid', 'The DB did not return a user with the passed in activationId')
else:
email = items[0]['email']
jsonData = {
'Key': {'email': email},
'UpdateExpression': 'SET active = :a',
'ExpressionAttributeValues': { ':a': 'T' },
'ReturnValues' : 'UPDATED_NEW'
}
#Update using the email we have
res = dbUtils.updateItem(jsonData, table)
response.addToPayload('status', 'Success')
return response
def test_isCodeInTaughtList(self):
print('Running isCodeInTaughtList test case')
email = '*****@*****.**'
# put user with taught list into db
usersTable = db.getTable('users', dynamodb)
userJsonData = {
'email': email,
'userRole': 'teacher',
'teaching': ['d26713cc-f02d-4fd6-80f0-026784d1ab9b'
] #algebra 1 from mock classes data
}
db.putItem(userJsonData, usersTable)
# code is in teaching list
jsonData = {'code': 'd26713cc-f02d-4fd6-80f0-026784d1ab9b'}
response = class_ctrl.isCodeInTaughtList(jsonData, dynamodb, email)
self.assertTrue(response)
# code is not in teaching list
jsonData = {'code': '000000-f02d-4fd6-80f0-026784d1ab9b'}
response = class_ctrl.isCodeInTaughtList(jsonData, dynamodb, email)
self.assertFalse(response)
# no code given
jsonData = {}
response = class_ctrl.isCodeInTaughtList(jsonData, dynamodb, email)
self.assertFalse(response)
def getTaughtClassList(dynamoDBInstance, email=None):
response = ControllerResponse()
if email is None: # pragma: no cover
email = g.authenticatedUser['email']
usersTable = dbUtils.getTable('users', dynamoDBInstance)
classTable = dbUtils.getTable('classes', dynamoDBInstance)
if usersTable is None or classTable is None:
response.addError('Get Taught Class List Failed',
'Unable to access users and/or classes')
else:
classes = []
classCodes = getTaughtClassCodesFromUser(dynamoDBInstance, email)
if classCodes is not None:
for code in classCodes:
request = {'Key': {'code': code}}
res = dbUtils.getItem(request, classTable)
if res is not None and 'Item' in res:
classes.append(res['Item'])
response.addToPayload('classes', classes)
return response
def test_undoClassCodeRemoval(self):
print('Running undoClassCodeRemoval test case')
email = '*****@*****.**'
classCode = 'f99998db-fb9d-4fd6-81f1-026784d6cc9b'
classCode2 = 'f00000db-fb9d-4fd6-81f1-026784d6cc9b'
#Put user and class data into DB
usersTable = db.getTable('users', dynamodb)
### to simulate class already removed from student ###
userJsonData = {'email': email}
db.putItem(userJsonData, usersTable)
#Check test data was successfully placed into DB
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('email'), email)
#Test simulated error in undoClassCodeRemoval email
class_ctrl.undoClassCodeRemoval(dynamodb, email, classCode)
#check class was place back into student's classCodes
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
classCodes = response.get('Item').get('classCodes')
self.assertTrue(classCode in classCodes)
#### add classCode back to a list that when removed will still have elements ###
userJsonData = {
'email': email,
'classCodes': set([classCode, classCode2])
}
db.putItem(userJsonData, usersTable)
#Check test data was successfully placed into DB
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('email'), email)
#Test simulated error in undoClassCodeRemoval email
class_ctrl.undoClassCodeRemoval(dynamodb, email, classCode2)
#check class was place back into student's classCodes
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
classCodes = response.get('Item').get('classCodes')
self.assertTrue(classCode in classCodes)
self.assertTrue(classCode2 in classCodes)
def test_addDataToClassAndUser(self):
userRole = 'student'
email = '*****@*****.**'
classCode = 'abcef12345'
title = 'some class'
response = ControllerResponse()
# add student to user table
usersTable = db.getTable('users', dynamodb)
jsonData = {'email': email}
db.putItem(jsonData, usersTable)
# add class to class table
classesTable = db.getTable('classes', dynamodb)
jsonData = {'code': classCode, 'title': title}
db.putItem(jsonData, classesTable)
usr.addDataToClassAndUser(classCode, email, response, dynamodb)
self.assertFalse(response.hasErrors())
self.assertEqual(response.payload['title'], title)
self.assertEqual(response.payload['code'], classCode)
def getBook(bookId, dynamoDBInstance):
book = None
booksTable = dbUtils.getTable('books', dynamoDBInstance)
if booksTable is None:
MentiiLogging.getLogger().error('Could not get book table')
else:
bookQuery = {'Key': {'bookId': bookId}}
res = dbUtils.getItem(bookQuery, booksTable)
if res is not None and 'Item' in res.keys():
book = res['Item']
else:
MentiiLogging.getLogger().warning(
'Could not get an item from the books table')
return book
def getClassByCode(classCode, dynamoDBInstance):
classData = None
classTable = dbUtils.getTable('classes', dynamoDBInstance)
if not classTable:
MentiiLogging.getLogger().error(
'Unable to access class table in getClassByCode')
else:
request = {'Key': {'code': classCode}}
res = dbUtils.getItem(request, classTable)
if not res or 'Item' not in res:
MentiiLogging.getLogger().error(
'Unable to load class data in getClassByCode')
else:
classData = res['Item']
return classData
def test_createClass(self):
print('Running creatClass test case')
classData = {
'title': 'PSY',
'department': 'science',
'section': '25',
'description': 'How our brain works'
}
email = '*****@*****.**'
userRole = 'teacher'
response = class_ctrl.createClass(dynamodb, classData, email, userRole)
# check response message
self.assertEqual(response.payload, {'Success': 'Class Created'})
# check that teaching set was added to user
classesTable = db.getTable('classes', dynamodb)
usersTable = db.getTable('users', dynamodb)
data = {'Key': {'email': email}}
teacher = db.getItem(data, usersTable)
self.assertTrue('Item' in teacher.keys())
self.assertTrue('teaching' in teacher['Item'])
teachingList = list(teacher['Item']['teaching'])
# check that class was created in classes table
classCode = str(teachingList[0])
data = {'Key': {'code': classCode}}
classItem = db.getItem(data, classesTable)
self.assertTrue('Item' in classItem.keys())
self.assertEqual(classItem['Item']['title'], 'PSY')
self.assertEqual(classItem['Item']['department'], 'science')
self.assertEqual(classItem['Item']['classSection'], '25')
self.assertEqual(classItem['Item']['description'],
'How our brain works')
def addResetPasswordIdToUser(email, resetPasswordId, dbInstance):
success = False;
table = dbUtils.getTable('users', dbInstance)
if table is not None:
user = getUserByEmail(email,dbInstance)
if user is not None:
jsonData = {
'Key': {'email': email},
'UpdateExpression': 'SET resetPasswordId = :a',
'ExpressionAttributeValues': { ':a': resetPasswordId },
'ReturnValues' : 'UPDATED_NEW'
}
dbUtils.updateItem(jsonData, table)
success = True
return success
def getUserByEmail(email, dbInstance):
user = None
table = dbUtils.getTable('users', dbInstance)
if table is None:
MentiiLogging.getLogger().error('Unable to get table users in getUserByEmail')
else:
key = {'Key' : {'email': email}}
result = dbUtils.getItem(key, table)
if result is None:
MentiiLogging.getLogger().error('Unable to get the user with email: ' + email + ' in getUserByEmail ')
elif 'Item' in result.keys():
user = result['Item']
return user
def updatePasswordForEmailAndResetId(email, password, resetPasswordId, dbInstance):
res = None
user = getUserByEmail(email, dbInstance)
if user is not None:
storedResetPasswordId = user.get('resetPasswordId', None)
if storedResetPasswordId == resetPasswordId:
table = dbUtils.getTable('users', dbInstance)
if table is not None:
hashedPassword = hashPassword(password)
jsonData = {
'Key': {'email': email},
'UpdateExpression': 'SET password = :a REMOVE resetPasswordId',
'ExpressionAttributeValues': { ':a': hashedPassword },
'ReturnValues' : 'UPDATED_NEW'
}
res = dbUtils.updateItem(jsonData, table)
return res
def getTaughtClassCodesFromUser(dynamoDBInstance, email=None):
classCodes = None
if email is None: # pragma: no cover
email = g.authenticatedUser['email']
usersTable = dbUtils.getTable('users', dynamoDBInstance)
if usersTable is None:
MentiiLogging.getLogger().error(
'Unable to get users table in getTaughtClassCodesFromUser')
else:
#An active class list is the list of class codes that
# a user has in the user table.
request = {'Key': {'email': email}, 'ProjectionExpression': 'teaching'}
res = dbUtils.getItem(request, usersTable)
#Get the class codes for the user.
if res is not None and 'Item' in res:
classCodes = res['Item'].get('teaching', [])
return classCodes
def addClassCodeToStudent(email, classCode, dynamoDBInstance):
userTable = dbUtils.getTable('users', dynamoDBInstance)
if userTable:
codeSet = set([classCode])
addClassToUser = {
'Key': {'email': email},
'UpdateExpression': 'ADD classCodes :i',
'ExpressionAttributeValues': { ':i': codeSet },
'ReturnValues' : 'UPDATED_NEW'
}
res = dbUtils.updateItem(addClassToUser, userTable)
if ( res and
'Attributes' in res and
'classCodes' in res['Attributes'] and
classCode in res['Attributes']['classCodes']
):
return res['Attributes']['classCodes']
return None
def changeUserRole(jsonData, dbInstance, adminRole=None):
response = ControllerResponse()
#g will be not be available during testing
#and adminRole will need to be passed to the function
if g: # pragma: no cover
adminRole = g.authenticatedUser['userRole']
#adminRole is confirmed here incase changeUserRole is called from somewhere
#other than app.py changeUserRole()
if adminRole != 'admin':
response.addError('Role Error', 'Only admins can change user roles')
elif 'email' not in jsonData.keys() or 'userRole' not in jsonData.keys():
response.addError('Key Missing Error', 'Email or role missing from json data')
else:
email = jsonData['email']
userRole = jsonData['userRole']
userTable = dbUtils.getTable('users', dbInstance)
if userTable is None:
MentiiLogging.getLogger().error('Unable to get table "users" in changeUserRole')
response.addError('No Access to Data', 'Unable to get data from database')
else:
if userRole != 'student' and userRole != 'teacher' and userRole != 'admin':
MentiiLogging.getLogger().error('Invalid role: ' + userRole + ' specified. Unable to change user role')
response.addError('Invalid Role Type', 'Invaid role specified')
else:
data = {
'Key': {'email': email},
'UpdateExpression': 'SET userRole = :ur',
'ExpressionAttributeValues': { ':ur': userRole },
'ReturnValues' : 'UPDATED_NEW'
}
result = dbUtils.updateItem(data, userTable)
if result is None:
MentiiLogging.getLogger().error('Unable to update the user with email: ' + email + ' in changeUserRole')
response.addError('Result Update Error', 'Could not update the user role in database')
else:
response.addToPayload('Result:', result)
response.addToPayload('success', 'true')
return response
def addStudentToClass(classCode, email, dynamoDBInstance):
classTable = dbUtils.getTable('classes', dynamoDBInstance)
if classTable:
emailSet = set([email])
addUserToClass = {
'Key': {'code': classCode},
'UpdateExpression': 'ADD students :i',
'ExpressionAttributeValues': { ':i': emailSet },
'ReturnValues' : 'ALL_NEW'
}
res = dbUtils.updateItem(addUserToClass, classTable)
if ( res and
'Attributes' in res and
'students' in res['Attributes'] and
email in res['Attributes']['students'] and
'title' in res['Attributes']
):
return res['Attributes']
return None
def getPublicClassList(dynamodb, email=None):
response = ControllerResponse()
classCodes = getClassCodesFromUser(dynamodb, email)
classes = []
classesTable = dbUtils.getTable('classes', dynamodb)
if classesTable is None:
MentiiLogging.getLogger().error(
'Unable to get classes table in getPublicClassList')
response.addError('Failed to get class list',
'A database error occured')
else:
res = classesTable.scan()
for pclass in res.get('Items', []):
if pclass[
'code'] not in classCodes and 'private' not in pclass and pclass.get(
'private') != True:
classes.append(pclass)
response.addToPayload('classes', classes)
return response
