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