source: main/waeup.aaue/trunk/src/waeup/aaue/students/studylevel.py @ 16749

Last change on this file since 16749 was 16749, checked in by Henrik Bettermann, 3 years ago

Add text book and registration fees.

  • Property svn:keywords set to Id
File size: 18.4 KB
Line 
1## $Id: studylevel.py 16749 2022-01-14 17:46:51Z henrik $
2##
3## Copyright (C) 2012 Uli Fouquet & Henrik Bettermann
4## This program is free software; you can redistribute it and/or modify
5## it under the terms of the GNU General Public License as published by
6## the Free Software Foundation; either version 2 of the License, or
7## (at your option) any later version.
8##
9## This program is distributed in the hope that it will be useful,
10## but WITHOUT ANY WARRANTY; without even the implied warranty of
11## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12## GNU General Public License for more details.
13##
14## You should have received a copy of the GNU General Public License
15## along with this program; if not, write to the Free Software
16## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17##
18"""
19Container which holds the data of a student study level
20and contains the course tickets.
21"""
22import grok
23import pytz
24from datetime import datetime
25from zope.component.interfaces import IFactory
26from zope.component import createObject
27from zope.interface import implementedBy
28from waeup.kofa.utils.helpers import attrs_to_fields
29from waeup.kofa.interfaces import RETURNING, VALIDATED, REGISTERED, PAID
30from waeup.kofa.students.browser import TicketError
31from waeup.kofa.students.studylevel import (
32    StudentStudyLevel, CourseTicket,
33    CourseTicketFactory, StudentStudyLevelFactory)
34from waeup.kofa.students.interfaces import IStudentNavigation, ICourseTicket
35from waeup.aaue.students.interfaces import (
36    ICustomStudentStudyLevel, ICustomCourseTicket)
37from waeup.aaue.students.utils import MINIMUM_UNITS_THRESHOLD
38from waeup.aaue.interfaces import MessageFactory as _
39
40
41class CustomStudentStudyLevel(StudentStudyLevel):
42    """This is a container for course tickets.
43    """
44    grok.implements(ICustomStudentStudyLevel, IStudentNavigation)
45    grok.provides(ICustomStudentStudyLevel)
46
47    @property
48    def total_credits_s1(self):
49        total = 0
50        for ticket in self.values():
51            if ticket.semester == 1 and not ticket.outstanding:
52                total += ticket.credits
53        return total
54
55    @property
56    def total_credits_s2(self):
57        total = 0
58        for ticket in self.values():
59            if ticket.semester == 2 and not ticket.outstanding:
60                total += ticket.credits
61        return total
62
63    @property
64    def gpa_params(self):
65        """Calculate gpa parameters for this level.
66        """
67        credits_weighted = 0.0
68        credits_counted = 0
69        level_gpa = 0.0
70        for ticket in self.values():
71            if ticket.total_score is not None:
72                credits_counted += ticket.credits
73                credits_weighted += ticket.credits * ticket.weight
74        if credits_counted:
75            level_gpa = credits_weighted/credits_counted
76        # Override level_gpa if value has been imported
77        imported_gpa = getattr(self, 'imported_gpa', None)
78        if imported_gpa:
79            level_gpa = imported_gpa
80        return level_gpa, credits_counted, credits_weighted
81
82    @property
83    def gpa_params_rectified(self):
84        return self.gpa_params
85
86    @property
87    def passed_params(self):
88        """Determine the number and credits of passed and failed courses.
89        This method is used for level reports.
90        """
91        passed = failed = 0
92        courses_failed = ''
93        credits_failed = 0
94        credits_passed = 0
95        courses_not_taken = ''
96        courses_passed = ''
97        for ticket in self.values():
98            if ticket.total_score is not None:
99                if ticket.total_score < ticket.passmark:
100                    failed += 1
101                    credits_failed += ticket.credits
102                    if ticket.mandatory or ticket.course_category == 'C':
103                        courses_failed += 'm_%s_m ' % ticket.code
104                    else:
105                        courses_failed += '%s ' % ticket.code
106                else:
107                    passed += 1
108                    credits_passed += ticket.credits
109                    courses_passed += '%s ' % ticket.code
110            else:
111                courses_not_taken += '%s ' % ticket.code
112        if not len(courses_failed):
113            courses_failed = 'Nil'
114        if not len(courses_not_taken):
115            courses_not_taken = 'Nil'
116        return (passed, failed, credits_passed,
117                credits_failed, courses_failed,
118                courses_not_taken, courses_passed)
119
120    @property
121    def course_registration_forbidden(self):
122        #fac_dep_paid = True
123        #if self.student.entry_session >= 2016:
124        #    fac_dep_paid = False
125        #    for ticket in self.student['payments'].values():
126        #        if ticket.p_category == 'fac_dep' and \
127        #            ticket.p_session == self.level_session and \
128        #            ticket.p_state == 'paid':
129        #                fac_dep_paid = True
130        #                continue
131        #if not fac_dep_paid:
132        #    return _("Please pay faculty and departmental dues first.")
133
134
135        ######################################################
136        # Temporarily disable ug_ft course registration
137        #if self.student.current_mode == 'ug_ft':
138        #    return _("Course registration has been disabled.")
139        ######################################################
140
141
142        restitution_paid = True
143        if self.student.current_session == 2016 \
144            and self.student.current_mode in ('ug_ft', 'dp_ft') \
145            and not self.student.is_fresh:
146            restitution_paid = False
147            for ticket in self.student['payments'].values():
148                if ticket.p_category == 'restitution' and \
149                    ticket.p_session == self.level_session and \
150                    ticket.p_state == 'paid':
151                        restitution_paid = True
152                        continue
153        if not restitution_paid:
154            return _("Please pay restitution fee first.")
155        #if self.student.is_fresh:
156        #    return
157        try:
158            academic_session = grok.getSite()['configuration'][
159                str(self.level_session)]
160            if self.student.is_postgrad:
161                deadline = academic_session.coursereg_deadline_pg
162            elif self.student.current_mode.startswith('dp'):
163                deadline = academic_session.coursereg_deadline_dp
164            elif self.student.current_mode in (
165                'ug_pt', 'de_pt', 'de_dsh', 'ug_dsh'):
166                deadline = academic_session.coursereg_deadline_pt
167            elif self.student.current_mode == 'found':
168                deadline = academic_session.coursereg_deadline_found
169            elif self.student.current_mode == 'bridge':
170                deadline = academic_session.coursereg_deadline_bridge
171            else:
172                deadline = academic_session.coursereg_deadline
173        except (TypeError, KeyError):
174            return
175        if not deadline or deadline > datetime.now(pytz.utc):
176            return
177        if self.student.is_postgrad:
178            lcrfee = academic_session.late_pg_registration_fee
179        else:
180            lcrfee = academic_session.late_registration_fee
181        if not lcrfee:
182            return _("Course registration has been disabled.")
183        if len(self.student['payments']):
184            for ticket in self.student['payments'].values():
185                if ticket.p_category == 'late_registration' and \
186                    ticket.p_session == self.level_session and \
187                    ticket.p_state == 'paid':
188                        return
189        return _("Course registration has ended. "
190                 "Please pay the late registration fee.")
191
192    # only AAUE
193    @property
194    def remark(self):
195        certificate = getattr(self.__parent__,'certificate',None)
196        end_level = getattr(certificate, 'end_level', None)
197        study_mode = getattr(certificate, 'study_mode', None)
198        is_dp = False
199        if study_mode and study_mode.startswith('dp'):
200            is_dp = True
201        failed_limit = 1.5
202        if self.student.entry_session < 2013:
203            failed_limit = 1.0
204        # final level student remark
205        if end_level and self.level >= end_level:
206            if self.level > end_level:
207                # spill-over level
208                if self.gpa_params[1] == 0:
209                    # no credits taken
210                    return 'NER'
211            elif self.gpa_params[1] < MINIMUM_UNITS_THRESHOLD:
212                # credits taken below limit
213                return 'NER'
214            if self.level_verdict in ('FRNS', 'NER', 'NYV'):
215                return self.level_verdict
216            if '_m' in self.passed_params[4]:
217                return 'FRNS'
218            if not self.cumulative_params[0]:
219                return 'FRNS'
220            if len(self.passed_params[5]) \
221                and not self.passed_params[5] == 'Nil':
222                return 'FRNS'
223            if self.cumulative_params[1] < 60:
224                return 'FRNS'
225            if self.cumulative_params[0] < failed_limit:
226                return 'Fail'
227            dummy, repeat = divmod(self.level, 100)
228            if self.cumulative_params[0] < 5.1 and repeat == 20:
229                # Irrespective of the CGPA of a student, if the He/She has
230                # 3rd Extension, such student will be graduated with a "Pass".
231                return 'Pass'
232            if self.cumulative_params[0] < 1.5:
233                if is_dp:
234                    return 'Fail'
235                return 'Pass'
236            if self.cumulative_params[0] < 2.4:
237                if is_dp:
238                    return 'Pass'
239                return '3s_rd_s'
240            if self.cumulative_params[0] < 3.5:
241                if is_dp:
242                    return 'Merit'
243                return '2s_2_s'
244            if self.cumulative_params[0] < 4.5:
245                if is_dp:
246                    return 'Credit'
247                return '2s_1_s'
248            if self.cumulative_params[0] < 5.1:
249                if is_dp:
250                    return 'Distinction'
251                return '1s_st_s'
252            return 'N/A'
253        # returning student remark
254        if self.level_verdict in ('FRNS', 'NER', 'NYV'):
255            return 'Probation'
256        if self.level_verdict == 'D':
257            return 'Withdrawn'
258        if self.gpa_params[1] == 0:
259            # no credits taken
260            return 'NER'
261        if self.gpa_params[1] < MINIMUM_UNITS_THRESHOLD:
262            # credits taken below limit
263            return 'Probation'
264        if self.cumulative_params[0] < failed_limit:
265            return 'Probation'
266        if self.cumulative_params[0] < 5.1:
267            return 'Proceed'
268        return 'N/A'
269
270    def _schoolfeePaymentMade(self):
271        if len(self.student['payments']):
272            for ticket in self.student['payments'].values():
273                if ticket.p_state == 'paid' and \
274                    ticket.p_category in (
275                        'schoolfee', 'schoolfee_incl', 'schoolfee_2',)  and \
276                    ticket.p_session == self.student[
277                        'studycourse'].current_session:
278                    return True
279        return False
280
281    def _coursePaymentsMade(self, course):
282        if self.level_session < 2016:
283            return True
284        if not course.code[:3] in ('GST', 'ENT'):
285            return True
286        if len(self.student['payments']):
287            paid_cats = list()
288            for pticket in self.student['payments'].values():
289                if pticket.p_state == 'paid':
290                    paid_cats.append(pticket.p_category)
291            if course.code in ('GST101', 'GST102', 'GST111', 'GST112') and \
292                not 'gst_registration_1' in paid_cats:
293                return False
294            if course.code in ('GST222',) and \
295                not 'gst_registration_2' in paid_cats:
296                return False
297            if course.code in ('ENT211',) and \
298                not 'ent_registration_2' in paid_cats:
299                return False
300            if course.code in ('GST101', 'GST102') and \
301                not 'gst_text_book_1' in paid_cats and \
302                not 'gst_text_book_0' in paid_cats:
303                return False
304            if course.code in ('GST111', 'GST112') and \
305                not 'gst_text_book_2' in paid_cats and \
306                not 'gst_text_book_0' in paid_cats:
307                return False
308            if course.code in ('GST222',) and \
309                not 'gst_text_book_3' in paid_cats:
310                return False
311            if course.code in ('ENT211',) and \
312                not 'ent_text_book_2' in paid_cats:
313                return False
314            return True
315        return False
316
317    def addCourseTicket(self, ticket, course):
318        """Add a course ticket object.
319        """
320        if not ICourseTicket.providedBy(ticket):
321            raise TypeError(
322                'StudentStudyLeves contain only ICourseTicket instances')
323        # Raise TicketError if course is in 2nd semester but
324        # schoolfee has not yet been fully paid.
325        if course.semester == 2 and not self._schoolfeePaymentMade():
326            raise TicketError(
327                _('%s is a 2nd semester course which can only be added '
328                  'if school fees have been fully paid.' % course.code))
329        # Raise TicketError if registration fee or text
330        # book fee haven't been paid.
331        if not self._coursePaymentsMade(course):
332            raise TicketError(
333                _('%s can only be added if both registration fee and text '
334                  'book fee have been paid.'
335                  % course.code))
336        # We check if there exists a certificate course in the certificate
337        # container which refers to the course. If such an object does
338        # not exist, students and managers will be prevented from registering
339        # the corresponding course.
340        cert = self.__parent__.certificate
341        ticket_allowed = False
342        for val in cert.values():
343            if val.course == course:
344                ticket_allowed = True
345                break
346        if not ticket_allowed:
347            raise TicketError(
348                _('%s is not part of the %s curriculum.'
349                  % (course.code, cert.code)))
350        ticket.code = course.code
351        ticket.title = course.title
352        ticket.fcode = course.__parent__.__parent__.__parent__.code
353        ticket.dcode = course.__parent__.__parent__.code
354        ticket.credits = course.credits
355        if self.student.entry_session < 2013:
356            ticket.passmark = course.passmark - 5
357        else:
358            ticket.passmark = course.passmark
359        ticket.semester = course.semester
360        self[ticket.code] = ticket
361        return
362
363    def addCertCourseTickets(self, cert):
364        """Collect all certificate courses and create course
365        tickets automatically.
366        """
367        if cert is not None:
368            for key, val in cert.items():
369                if val.level != self.level:
370                    continue
371                ticket = createObject(u'waeup.CourseTicket')
372                ticket.automatic = True
373                ticket.mandatory = val.mandatory
374                ticket.carry_over = False
375                ticket.course_category = val.course_category
376                try:
377                    self.addCourseTicket(ticket, val.course)
378                except TicketError:
379                    pass
380        return
381
382CustomStudentStudyLevel = attrs_to_fields(
383    CustomStudentStudyLevel, omit=[
384    'total_credits', 'total_credits_s1', 'total_credits_s2', 'gpa'])
385
386class CustomStudentStudyLevelFactory(StudentStudyLevelFactory):
387    """A factory for student study levels.
388    """
389
390    def __call__(self, *args, **kw):
391        return CustomStudentStudyLevel()
392
393    def getInterfaces(self):
394        return implementedBy(CustomStudentStudyLevel)
395
396class CustomCourseTicket(CourseTicket):
397    """This is a course ticket which allows the
398    student to attend the course. Lecturers will enter scores and more at
399    the end of the term.
400
401    A course ticket contains a copy of the original course and
402    course referrer data. If the courses and/or their referrers are removed, the
403    corresponding tickets remain unchanged. So we do not need any event
404    triggered actions on course tickets.
405    """
406    grok.implements(ICustomCourseTicket, IStudentNavigation)
407    grok.provides(ICustomCourseTicket)
408
409    @property
410    def _getGradeWeightFromScore(self):
411        """AAUE Course Grading System
412        """
413        if self.score == -1:
414            return ('-',0) # core course and result not yet available (used by AAUE)
415        if self.total_score is None:
416            return (None, None)
417        if self.total_score >= 70:
418            return ('A',5)
419        if self.total_score >= 60:
420            return ('B',4)
421        if self.total_score >= 50:
422            return ('C',3)
423        if self.total_score >= 45:
424            return ('D',2)
425        if self.total_score >= self.passmark: # passmark changed in 2013 from 40 to 45
426            return ('E',1)
427        return ('F',0)
428
429    @property
430    def total_score(self):
431        """Returns ca + score or imported total score.
432        """
433        # Override total_score if value has been imported
434        if getattr(self, 'imported_ts', None):
435            return self.imported_ts
436        if self.score == -1:
437            return 0
438        if not None in (self.score, self.ca):
439            return self.score + self.ca
440        return None
441
442    @property
443    def removable_by_student(self):
444        """True if student is allowed to remove the ticket.
445        """
446        if self.mandatory:
447            return False
448        if self.score:
449            return False
450        #if self.course_category == 'C':
451        #    return False
452        return True
453
454    @property
455    def editable_by_lecturer(self):
456        """True if lecturer is allowed to edit the ticket.
457        """
458        try:
459            cas = grok.getSite()[
460                'configuration'].current_academic_session
461            # Temporarily we allow students to pay for next session, so their
462            # current_session might have increased
463            if self.student.state in (
464                VALIDATED, REGISTERED, PAID, RETURNING) and \
465                self.student.current_session in (cas, cas+1):
466                return True
467        except (AttributeError, TypeError): # in unit tests
468            pass
469        return False
470
471CustomCourseTicket = attrs_to_fields(CustomCourseTicket)
472
473class CustomCourseTicketFactory(CourseTicketFactory):
474    """A factory for student study levels.
475    """
476
477    def __call__(self, *args, **kw):
478        return CustomCourseTicket()
479
480    def getInterfaces(self):
481        return implementedBy(CustomCourseTicket)
Note: See TracBrowser for help on using the repository browser.