Coverage for app/models/user.py: 93%

1from app.models import * 

2from app.models.term import Term 

3 

4class User(baseModel): 

5 username = CharField(primary_key=True) 

6 bnumber = CharField(unique=True) 

7 email = CharField() 

8 phoneNumber = CharField(null=True) 

9 firstName = CharField() 

10 lastName = CharField() 

11 cpoNumber = CharField(null=False) 

12 isStudent = BooleanField(default=False) 

13 major = CharField(null=True) 

14 rawClassLevel = CharField(null=True) 

15 isActive = BooleanField(default=False) 

16 isFaculty = BooleanField(default=False) 

17 isStaff = BooleanField(default=False) 

18 isCeltsAdmin = BooleanField(default=False) 

19 isCeltsStudentStaff = BooleanField(default=False) 

20 isCeltsOperationsTeam = BooleanField(default=False) # A user MUST be a CELTS Student Staff member to be a CELTS Operations Team member. 

21 dietRestriction = TextField(null=True) 

22 minorInterest = BooleanField(null=True) 

23 hasGraduated = BooleanField(default=False) 

24 declaredMinor = BooleanField(default=False) 

25 lastHandbookSignature = DateTimeField(null=True) 

26 signatureTerm = ForeignKeyField(Term, null = True) 

27 

28 # override BaseModel's __init__ so that we can set up an instance attribute for cache 

29 def __init__(self,*args, **kwargs): 

30 super().__init__(*args,**kwargs) 

31 

32 self._pmCache = {} 

33 self._bsCache = None 

34 self._laborCache = None 

35 self._isProgramManagerCache = None 

36 

37 @property 

38 def processedClassLevel(self): 

39 if self.hasGraduated: 

40 return "Alumni" 

41 

42 return self.rawClassLevel or "Not Enrolled" 

43 

44 @property 

45 def isCurrentlyEnrolled(self): 

46 return self.isStudent and self.isActive 

47 

48 @property 

49 def isAdmin(self): 

50 return (self.isCeltsAdmin or self.isCeltsStudentStaff) 

51 

52 @property 

53 def isBonnerScholar(self): 

54 from app.models.bonnerCohort import BonnerCohort 

55 if self._bsCache is None: 

56 # TODO should we exclude users who are banned from Bonner here? 

57 self._bsCache = BonnerCohort.select().where(BonnerCohort.user == self).exists() 

58 

59 return self._bsCache 

60 

61 @property 

62 def hasCurrentCeltsLabor(self): 

63 if self._laborCache is None: 

64 from app.models.celtsLabor import CeltsLabor 

65 from app.models.term import Term 

66 self._laborCache = (CeltsLabor.select() 

67 .join(Term) 

68 .where(CeltsLabor.user == self, 

69 CeltsLabor.term.isCurrentTerm == True) 

70 .exists()) 

71 return self._laborCache 

72 

73 @property 

74 def fullName(self): 

75 return f"{self.firstName} {self.lastName}" 

76 

77 def addProgramManager(self, program): 

78 # Makes a user a Program Manager 

79 from app.models.programManager import ProgramManager 

80 ProgramManager.create(user = self, program = program) 

81 

82 return (f' {self} added as Program Manager') 

83 

84 def removeProgramManager(self, program): 

85 # Removes an existing Program Manager from being a Program Manager 

86 from app.models.programManager import ProgramManager 

87 ProgramManager.delete().where(ProgramManager.user == self, ProgramManager.program == program).execute() 

88 

89 return (f'{self} removed from Program Manager') 

90 

91 def isProgramManagerFor(self, program): 

92 # Looks to see who is the Program Manager for a program 

93 from app.models.programManager import ProgramManager # Must defer import until now to avoid circular reference 

94 if not program: 

95 return False 

96 

97 if program not in self._pmCache: 

98 self._pmCache[program] = ProgramManager.select().where(ProgramManager.user == self, ProgramManager.program == program).exists() 

99 

100 return self._pmCache[program] 

101 

102 def isProgramManagerForEvent(self, event): 

103 # Looks to see who the Program Manager for a specific event is 

104 return self.isProgramManagerFor(event.program) 

105 

106 def canManageProgram(self, program): 

107 return self.isCeltsAdmin or self.isCeltsOperationsTeam or self.isProgramManagerFor(program) 

108 

109 @property 

110 def isProgramManager(self): 

111 from app.models.programManager import ProgramManager 

112 if self._isProgramManagerCache is None: 

113 self._isProgramManagerCache = ProgramManager.select().where(ProgramManager.user == self).exists() 

114 

115 return self._isProgramManagerCache 

116 

117