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

1from app.models import * 

2 

3class User(baseModel): 

4 username = CharField(primary_key=True) 

5 bnumber = CharField(unique=True) 

6 email = CharField() 

7 phoneNumber = CharField(null=True) 

8 firstName = CharField() 

9 lastName = CharField() 

10 cpoNumber = CharField(null=False) 

11 isStudent = BooleanField(default=False) 

12 major = CharField(null=True) 

13 rawClassLevel = CharField(null=True) 

14 isFaculty = BooleanField(default=False) 

15 isStaff = BooleanField(default=False) 

16 isCeltsAdmin = BooleanField(default=False) 

17 isCeltsStudentStaff = BooleanField(default=False) 

18 dietRestriction = TextField(null=True) 

19 minorInterest = BooleanField(null=True) 

20 hasGraduated = BooleanField(default=False) 

21 declaredMinor = BooleanField(default=False) 

22 

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

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

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

26 

27 self._pmCache = {} 

28 self._bsCache = None 

29 self._laborCache = None 

30 self._isProgramManagerCache = None 

31 

32 @property 

33 def processedClassLevel(self): 

34 if self.hasGraduated or self.rawClassLevel == "Graduating": 

35 return "Alumni" 

36 return self.rawClassLevel or "Not Enrolled" 

37 

38 @property 

39 def isAlumni(self): 

40 return self.hasGraduated or self.rawClassLevel == "Graduating" 

41 

42 @property 

43 def isCurrentlyEnrolled(self): 

44 return self.isStudent and not self.isAlumni 

45 

46 @property 

47 def isAdmin(self): 

48 return (self.isCeltsAdmin or self.isCeltsStudentStaff) 

49 

50 @property 

51 def isBonnerScholar(self): 

52 from app.models.bonnerCohort import BonnerCohort 

53 if self._bsCache is None: 

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

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

56 

57 return self._bsCache 

58 

59 @property 

60 def hasCurrentCeltsLabor(self): 

61 if self._laborCache is None: 

62 from app.models.celtsLabor import CeltsLabor 

63 from app.models.term import Term 

64 self._laborCache = (CeltsLabor.select() 

65 .join(Term) 

66 .where(CeltsLabor.user == self, 

67 CeltsLabor.term.isCurrentTerm == True) 

68 .exists()) 

69 return self._laborCache 

70 

71 @property 

72 def fullName(self): 

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

74 

75 def addProgramManager(self, program): 

76 # Makes a user a Program Manager 

77 from app.models.programManager import ProgramManager 

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

79 

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

81 

82 def removeProgramManager(self, program): 

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

84 from app.models.programManager import ProgramManager 

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

86 

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

88 

89 def isProgramManagerFor(self, program): 

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

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

92 if not program: 

93 return False 

94 

95 if program not in self._pmCache: 

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

97 

98 return self._pmCache[program] 

99 

100 def isProgramManagerForEvent(self, event): 

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

102 return self.isProgramManagerFor(event.program) 

103 

104 @property 

105 def isProgramManager(self): 

106 from app.models.programManager import ProgramManager 

107 

108 if self._isProgramManagerCache is None: 

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

110 

111 return self._isProgramManagerCache 

112 

113