def _authorize(self, username, password): errors = {'SUCCESS': '', 'ERROR': ''} # status return username = str(username).strip() password = str(password).strip() # Is username SJSUID or email ??? isSJSUID = username.replace(' ', '').isdigit() try: # Check if the user is present if isSJSUID: Validate({'SJSUID': username}) self.session.execute( """ SELECT * FROM Student WHERE Student.`SJSUID` = %s; """, username) exist = self.session.fetchone() if exist and 'Email' in exist: username = exist['Email'] else: # username is an email Validate({'Email': username}) self.session.execute( """ SELECT * FROM Student WHERE Student.`Email` = %s; """, username) exist = self.session.fetchone() # user is in database # Confirm stormpath account if exist: try: # Stormpath raises error on failure a = stormApp.authenticate_account(username, password).account if a.email: errors['SUCCESS'] = '1' return errors except Exception as e: raise TypeError('Invalid username or password') except (TypeError, ValidatorException) as e: self._printWarning("%s", e) errors['SUCCESS'] = '0' errors['ERROR'] = str(e) return dict(errors) except Exception as e: self._printError("%s", e) return False
def removeInterest(self, studentID, *interests): try: # Validate method arguments Validate({ 'SJSUID': studentID }) uidStudent = self._getStudentUID(studentID) values = [] # Build list of (studentID, InterestID) for interest in interests: # Get interest unique id self.session.execute(""" SELECT i.`InterestID` FROM Interest as i WHERE i.`Title` = %s; """, interest) interestID = self.session.fetchone() if not interestID: # No interestID found == Unknown interestName raise TypeError("Unknown interest") else: interestID = interestID['InterestID'] values.append((uidStudent, interestID)) # Return false if no values to enter into DB if values: # Delete rows with (studentID, interestID) # NOTE: DELETE will have no action if not found self.session.executemany(""" DELETE FROM StudentInterest WHERE StudentInterest.`Student_fk` = %s AND StudentInterest.`Interest_fk` = %s; """, values) self.conn.commit() return True return False except (TypeError, ValidatorException) as e: self.conn.rollback() # Unknown interest name. No InterestID returned self._printWarning("%s", e) # # TODO: # return message to frontend of unknown interestName not foun # return to frontend high priority validation errors # return e except (ValidatorException, Exception) as e: self.conn.rollback() self._printError("%s", e)
def addAdvisor(self, FirstName, LastName, Email, Department, MiddleName=None): try: # Validate arguments Validate({ 'FirstName': FirstName, 'LastName': LastName, 'Department': Department, 'MiddleName': MiddleName, 'Email': Email }) # Check if this advisor (professor) already exists in DB self.session.execute( """ SELECT * FROM Advisor as ad WHERE ad.`FirstName` = %s AND ad.`LastName` = %s AND ad.`Email` = %s AND ad.`Department` = %s; """, (FirstName, LastName, Email, Department)) exist = self.session.fetchone() if not exist: # Insert advisor if not exists self.session.execute( """ INSERT INTO `Advisor` (`FirstName`, `MiddleName`, `LastName`, `Email`, `Department`) VALUES (%s, %s, %s, %s, %s); """, (FirstName, MiddleName, LastName, Email, Department)) self.conn.commit() return True else: # Advisor entity already exists raise TypeError("Advisor already registered") except (TypeError, ValidatorException) as e: self.conn.rollback() # Unknown studentID or organizationName was encountered self._printWarning("%s", e) # # TODO: # return message to frontend of error # return to frontend high priority validation errors # return e except Exception as e: self.conn.rollback() # A non-existing organization was specified!!! self._printError("%s", e)
def authorArticle(self, studentID, organizationName, articleTitle, articleContent): try: # Validate method arguments Validate({ 'SJSUID': studentID, 'ArticleTitle': articleTitle, 'ArticleContent': articleContent }) # Get organization unique id uidOrganization = super(Officer, self)._getOrganizationUID(organizationName) # Get student unique id uidStudent = super(Officer, self)._getStudentUID(studentID) # Check active status of this officer active = self._isOfficerActive(uidStudent, uidOrganization) if not active: raise TypeError( "Given studentID not allowed to author articles") else: # Insert newsfeed article into DB self.session.execute( """ INSERT INTO NewsfeedArticle (`ArticleTitle`, `OrganizationID`, `ArticleContent`) VALUES (%s, %s, %s); """, (articleTitle.strip(), uidOrganization, articleContent.strip())) self.conn.commit() return True return False except (TypeError, ValidatorException) as e: self.conn.rollback() # Unknown studentID or organizationName was encountered self._printWarning("%s", e) # # TODO: # return message to frontend of error # return to frontend high priority validation errors # return e except Exception as e: self.conn.rollback() # A non-existing organization was specified!!! self._printError("%s", e)
def commentArticle(self, studentID, studentComment, articleID): try: # Validate method arguments Validate({ 'SJSUID': studentID, 'StudentComment': studentComment, }) uidStudent = self._getStudentUID(studentID) # Get organization unique id indirectly from article self.session.execute(""" SELECT nfa.`OrganizationID` FROM NewsfeedArticle as nfa WHERE nfa.`ArticleID` = %s; """, articleID) orgID = self.session.fetchone() if not orgID: raise TypeError("Unknown articleID") else: orgID = orgID['OrganizationID'] # Verify that student is active member active = self._isStudentActiveMember(uidStudent, orgID) if active: # Only active members can comment self.session.execute(""" INSERT INTO Comment (`Article_fk`, `Author_fk`, `Content`) VALUES (%s, %s, %s); """, (articleID, uidStudent, studentComment)) self.conn.commit() return True return False except (TypeError, ValidatorException) as e: self.conn.rollback() # Unknown studentID or articleID returned self._printWarning("%s", e) # # TODO: # return message to frontend of unknown studentID and articleID # return to frontend high priority validation errors # return e except (ValidatorException, Exception) as e: self.conn.rollback() self._printError("%s", e)
def quitOrganization(self, studentID, organizationName): try: # Validate method arguments Validate({ 'SJSUID': studentID, 'OrganizationName': organizationName }) uidStudent = self._getStudentUID(studentID) # Get organization unique ID uidOrganization = self._getOrganizationUID(organizationName) self.conn.commit() # Being new transaction # Check if student active(1) member of organization activeMember = self._isStudentActiveMember(uidStudent, uidOrganization) if activeMember: # Set organization member to inactive self.session.execute(""" UPDATE MemberOf SET MemberOf.`Active` = '0' WHERE MemberOf.`Student_fk` = %s AND MemberOf.`Organization_fk` = %s; """, (uidStudent, uidOrganization)) self.conn.commit() return True else: # Empty SQL return means either non-member or inactive self._printWarning("%s either inactive or not part of %s", studentID, organizationName) return True return False # 99.99% chance you will not hit this !!! except (TypeError, ValidatorException) as e: self.conn.rollback() # Unknown interest name. No InterestID returned self._printWarning("%s", e) # # TODO: # return message to frontend of unknown interestName not foun # return to frontend high priority validation errors # return e except Exception as e: self.conn.rollback() # A non-existing organization was specified!!! self._printError("%s", e)
def leaveOffice(self, studentID, organizationName): # Leaving officer position does not mean quitting organization try: # Validate method arguments Validate({ 'SJSUID': studentID, 'OrganizationName': organizationName }) # Get student unique id uidStudent = super(Officer, self)._getStudentUID(studentID) # Get organization unique id uidOrganization = super(Officer, self)._getOrganizationUID(organizationName) self.conn.commit() # Being new transaction # Change officer status to inactive(0) self.session.execute( """ UPDATE OfficerOf SET `Active` = '0' WHERE OfficerOf.`Student_fk` = %s AND OfficerOf.`Organization_fk` = %s; """, (uidStudent, uidOrganization)) self.conn.commit() return True except (TypeError, ValidatorException) as e: self.conn.rollback() # Unknown studentID or organizationName was encountered self._printWarning("%s", e) # # TODO: # return message to frontend of error # return to frontend high priority validation errors # return e except Exception as e: self.conn.rollback() # A non-existing organization was specified!!! self._printError("%s", e)
def editStudentInfo(self, studentID, **kwargs): try: # Validate arguments Validate({ 'SJSUID': studentID }) # Loop kwargs and do queries for key, value in kwargs.iteritems(): if key == 'Email': self.__updateStudentEmail(studentID, value) # # INSERT HERE IF ADDITIONAL STUDENT ATTRIBUTE EDIT FUNC # else: # Unknown key was passed to method raise TypeError("Student attribute not found") self.conn.commit() # Commit transaction only after all changes applied return True except (TypeError, ValidatorException) as e: self.conn.rollback() # Unknown studentID or organizationName was encountered self._printWarning("%s", e) # # TODO: # return message to frontend of error # return to frontend high priority validation errors # return e except Exception as e: self.conn.rollback() # A non-existing organization was specified!!! self._printError("%s", e)
def _addStudent(self, studentID, studentEmail, FirstName, LastName, Password, MiddleName=None): errors = {'SUCCESS': '', 'ERROR': ''} # status return try: # Validate method arguments Validate({ 'SJSUID': studentID, 'FirstName': FirstName, 'LastName': LastName, 'MiddleName': MiddleName, 'Email': studentEmail }) # Check stormpath for existance of account stormAccount = stormApp.accounts.search({'email': studentEmail}) if len(stormAccount) >= 1: # Account exists raise TypeError('Please verify inputs') exist = self.__existingUser(studentEmail) # Check if existing user if not exist: # Insert student entity self.session.execute( """ INSERT INTO `Student` (`SJSUID`, `Email`, `FirstName`, `LastName`, `MiddleName`) VALUES (%s, %s, %s, %s, %s); """, (studentID, studentEmail, FirstName, LastName, MiddleName)) try: # Create a new Stormpath Account. account = stormApp.accounts.create({ 'given_name': FirstName, 'middle_name': MiddleName, 'surname': LastName, 'email': studentEmail, 'password': Password }) self.conn.commit() # Everything is OK errors['SUCCESS'] = '1' return errors except Exception as e: # Stormpath.accounts.create raises error on failure self.conn.rollback() raise TypeError(str(e)) else: # Student entity already exists raise TypeError('Please verify inputs') except (TypeError, ValidatorException) as e: self.conn.rollback() self._printWarning("%s", e) errors['SUCCESS'] = '0' errors['ERROR'] = str(e) return dict(errors) except Exception as e: self.conn.rollback() self._printError("%s", e) return False
def addInterest(self, studentID, *interests): try: # Validate method arguments Validate({ 'SJSUID': studentID }) uidStudent = self._getStudentUID(studentID) values = [] # Build list of (studentID, InterestID) for interest in interests: # Get interest unique id self.session.execute(""" SELECT i.`InterestID` FROM Interest as i WHERE i.`Title` = %s; """, interest) interestID = self.session.fetchone() if not interestID: # No interestID found == Unknown interestName raise TypeError("Unknown interest") else: interestID = interestID['InterestID'] # If duplicate entry exists, do not insert again else SQL IntegrityError self.session.execute(""" SELECT * FROM StudentInterest as si WHERE si.`Student_fk` = %s AND si.`Interest_fk` = %s; """, (uidStudent, interestID)) duplicate = self.session.fetchall() if not duplicate: values.append((uidStudent, interestID)) else: # Go on to next loop iteration continue self.conn.commit() # Start a new transaction # Return false if no values to insert into DB if values: # Add all student's interest at once self.session.executemany(""" INSERT INTO StudentInterest (`Student_fk`, `Interest_fk`) VALUES (%s, %s) """, values) self.conn.commit() return True return False except (TypeError, ValidatorException) as e: self.conn.rollback() # Unknown interest name. No InterestID returned self._printWarning("%s", e) # # TODO: # return message to frontend of unknown interestName not foun # return to frontend high priority validation errors # return e except (ValidatorException, Exception) as e: self.conn.rollback() self._printError("%s", e)
def joinOrganization(self, studentID, organizationName): try: # Validate method arguments Validate({ 'SJSUID': studentID, 'OrganizationName': organizationName }) # Get student unique ID uidStudent = self._getStudentUID(studentID) # Get organization unique ID uidOrganization = self._getOrganizationUID(organizationName) self.conn.commit() # Being new transaction # Check if student already organization member self.session.execute(""" SELECT * FROM MemberOf as mem WHERE mem.`Student_fk` = %s AND mem.`Organization_fk` = %s; """, (uidStudent, uidOrganization)) data = self.session.fetchone() self.conn.commit() # Being new transaction if not data: # Add student to organization self.session.execute(""" INSERT INTO MemberOf (`Student_fk`, `Organization_fk`) VALUES (%s, %s); """, (uidStudent, uidOrganization)) self.conn.commit() return True else: # Check if student active(1) member of organization activeMember = self._isStudentActiveMember(uidStudent, uidOrganization) if not activeMember : # Update organization member active status to active(1) # Inactive status may be a result of being blacklisted blacklisted = self._isStudentBlacklisted(uidStudent, uidOrganization) if blacklisted: return False self.session.execute(""" UPDATE MemberOf SET MemberOf.`Active` = '1' WHERE MemberOf.`Student_fk` = %s AND MemberOf.`Organization_fk` = %s; """, (uidStudent, uidOrganization)) self.conn.commit() return True else: # Organization member already active self._printWarning("%s in %s already active", studentID, organizationName) return True return False # 99.99% chance you will not hit this !!! except (TypeError, ValidatorException) as e: self.conn.rollback() # Unknown studentID or organizationName was encountered self._printWarning("%s", e) # # TODO: # return message to frontend of error # return to frontend high priority validation errors # return e except Exception as e: self.conn.rollback() # A non-existing organization was specified!!! self._printError("%s", e)