source: main/waeup.kofa/branches/uli-async-update/src/waeup/kofa/applicants/interfaces.py @ 9169

Last change on this file since 9169 was 9169, checked in by uli, 12 years ago

Merge changes from trunk, r8786-HEAD

  • Property svn:keywords set to Id
File size: 16.4 KB
Line 
1## $Id: interfaces.py 9169 2012-09-10 11:05:07Z uli $
2##
3## Copyright (C) 2011 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"""Interfaces of the university application package.
19"""
20from datetime import datetime
21from grokcore.content.interfaces import IContainer
22from zc.sourcefactory.contextual import BasicContextualSourceFactory
23from zope import schema
24from zope.component import queryUtility, getUtility
25from zope.catalog.interfaces import ICatalog
26from zope.interface import Interface, Attribute, implements, directlyProvides
27from zope.schema.interfaces import (
28    ValidationError, ISource, IContextSourceBinder)
29from waeup.kofa.browser.interfaces import IApplicantBase
30from waeup.kofa.schema import TextLineChoice, FormattedDate
31from waeup.kofa.interfaces import (
32    IKofaObject, validate_email,
33    SimpleKofaVocabulary)
34from waeup.kofa.interfaces import MessageFactory as _
35from waeup.kofa.payments.interfaces import IOnlinePayment
36from waeup.kofa.schema import PhoneNumber
37from waeup.kofa.students.vocabularies import GenderSource, RegNumberSource
38from waeup.kofa.university.vocabularies import AppCatSource, CertificateSource
39
40#: Maximum upload size for applicant passport photographs (in bytes)
41MAX_UPLOAD_SIZE = 1024 * 20
42
43_marker = object() # a marker different from None
44
45def year_range():
46    curr_year = datetime.now().year
47    return range(curr_year - 2, curr_year + 5)
48
49class RegNumInSource(ValidationError):
50    """Registration number exists already
51    """
52    # The docstring of ValidationErrors is used as error description
53    # by zope.formlib.
54    pass
55
56class ApplicantRegNumberSource(RegNumberSource):
57    """A source that accepts any reg number if not used already by a
58    different applicant.
59    """
60    cat_name = 'applicants_catalog'
61    field_name = 'reg_number'
62    validation_error = RegNumInSource
63    comp_field = 'applicant_id'
64
65def contextual_reg_num_source(context):
66    source = ApplicantRegNumberSource(context)
67    return source
68directlyProvides(contextual_reg_num_source, IContextSourceBinder)
69
70
71class AppCatCertificateSource(CertificateSource):
72    """An application certificate source delivers all certificates
73    which belong to a certain application_category.
74
75    This source is meant to be used with Applicants.
76
77    The application category must match the application category of
78    the context parent, normally an applicants container.
79    """
80    def contains(self, context, value):
81        context_appcat = getattr(getattr(
82            context, '__parent__', None), 'application_category', _marker)
83        if context_appcat is _marker:
84            # If the context (applicant) has no application category,
85            # then it might be not part of a container (yet), for
86            # instance during imports. We consider this correct.
87            return True
88        if value.application_category == context_appcat:
89            return True
90        return False
91
92    def getValues(self, context):
93        # appliction category not available when certificate was deleted.
94        # shouldn't that info be part of applicant info instead?
95        # when we cannot determine the appcat, we will display all courses.
96        appcat = getattr(getattr(context, '__parent__', None),
97                         'application_category', None)
98        catalog = getUtility(ICatalog, name='certificates_catalog')
99        result = catalog.searchResults(
100            application_category=(appcat,appcat))
101        result = sorted(result, key=lambda value: value.code)
102        # XXX: What does the following mean here?
103        curr_course = context.course1
104        if curr_course is not None and curr_course not in result:
105            # display also current course even if it is not catalogued
106            # (any more)
107            result = [curr_course,] + result
108        return result
109
110class ApplicationTypeSource(BasicContextualSourceFactory):
111    """An application type source delivers screening types defined in the
112    portal.
113    """
114    def getValues(self, context):
115        appcats_dict = getUtility(
116            IApplicantsUtils).APP_TYPES_DICT
117        return sorted(appcats_dict.keys())
118
119    def getToken(self, context, value):
120        return value
121
122    def getTitle(self, context, value):
123        appcats_dict = getUtility(
124            IApplicantsUtils).APP_TYPES_DICT
125        return appcats_dict[value][0]
126
127# Maybe FUTMinna still needs this ...
128#class ApplicationPinSource(BasicContextualSourceFactory):
129#    """An application pin source delivers PIN prefixes for application
130#    defined in the portal.
131#    """
132#    def getValues(self, context):
133#        apppins_dict = getUtility(
134#            IApplicantsUtils).APP_TYPES_DICT
135#        return sorted(appcats_dict.keys())
136#
137#    def getToken(self, context, value):
138#        return value
139#
140#    def getTitle(self, context, value):
141#        apppins_dict = getUtility(
142#            IApplicantsUtils).APP_TYPES_DICT
143#        return u"%s (%s)" % (
144#            apppins_dict[value][1],self.apppins_dict[value][0])
145
146application_modes_vocab = SimpleKofaVocabulary(
147    (_('Create Application Records'), 'create'),
148    (_('Update Application Records'), 'update'),
149    )
150
151class IApplicantsUtils(Interface):
152    """A collection of methods which are subject to customization.
153    """
154
155    APP_TYPES_DICT = Attribute(' dict of application types')
156
157class IApplicantsRoot(IKofaObject, IContainer):
158    """A container for university applicants containers.
159    """
160
161    description = schema.Text(
162        title = _(u'Human readable description in HTML format'),
163        required = False,
164        default = u'''This text can been seen by anonymous users.
165Here we put multi-lingual general information about the application procedure.
166>>de<<
167Dieser Text kann von anonymen Benutzern gelesen werden.
168Hier koennen mehrsprachige Informationen fuer Antragsteller hinterlegt werden.'''
169        )
170
171    description_dict = Attribute(
172        """Content as language dictionary with values in HTML format.""")
173
174class IApplicantsContainer(IKofaObject):
175    """An applicants container contains university applicants.
176
177    """
178
179    code = schema.TextLine(
180        title = _(u'Code'),
181        required = True,
182        readonly = True,
183        )
184
185    title = schema.TextLine(
186        title = _(u'Title'),
187        required = True,
188        readonly = False,
189        )
190
191    prefix = schema.Choice(
192        title = _(u'Application Target'),
193        required = True,
194        source = ApplicationTypeSource(),
195        readonly = True,
196        )
197
198    year = schema.Choice(
199        title = _(u'Year of Entrance'),
200        required = True,
201        values = year_range(),
202        readonly = True,
203        )
204
205    mode = schema.Choice(
206        title = _(u'Application Mode'),
207        vocabulary = application_modes_vocab,
208        required = True,
209        )
210
211    # Maybe FUTMinna still needs this ...
212    #ac_prefix = schema.Choice(
213    #    title = u'Activation code prefix',
214    #    required = True,
215    #    default = None,
216    #    source = ApplicationPinSource(),
217    #    )
218
219    application_category = schema.Choice(
220        title = _(u'Category for the grouping of certificates'),
221        required = True,
222        source = AppCatSource(),
223        )
224
225    description = schema.Text(
226        title = _(u'Human readable description in HTML format'),
227        required = False,
228        default = u'''This text can been seen by anonymous users.
229Here we put multi-lingual information about the study courses provided, the application procedure and deadlines.
230>>de<<
231Dieser Text kann von anonymen Benutzern gelesen werden.
232Hier koennen mehrsprachige Informationen fuer Antragsteller hinterlegt werden.'''
233        )
234
235    description_dict = Attribute(
236        """Content as language dictionary with values in HTML format.""")
237
238    startdate = schema.Datetime(
239        title = _(u'Application Start Date'),
240        required = False,
241        description = _('Example:') + u'2011-12-01 18:30:00+01:00',
242        )
243
244    enddate = schema.Datetime(
245        title = _(u'Application Closing Date'),
246        required = False,
247        description = _('Example:') + u'2011-12-31 23:59:59+01:00',
248        )
249
250    strict_deadline = schema.Bool(
251        title = _(u'Forbid additions after deadline (enddate)'),
252        required = False,
253        default = True,
254        )
255
256    application_fee = schema.Float(
257        title = _(u'Application Fee'),
258        default = 0.0,
259        required = False,
260        )
261
262    def archive(id=None):
263        """Create on-dist archive of applicants stored in this term.
264
265        If id is `None`, all applicants are archived.
266
267        If id contains a single id string, only the respective
268        applicants are archived.
269
270        If id contains a list of id strings all of the respective
271        applicants types are saved to disk.
272        """
273
274    def clear(id=None, archive=True):
275        """Remove applicants of type given by 'id'.
276
277        Optionally archive the applicants.
278
279        If id is `None`, all applicants are archived.
280
281        If id contains a single id string, only the respective
282        applicants are archived.
283
284        If id contains a list of id strings all of the respective
285        applicant types are saved to disk.
286
287        If `archive` is ``False`` none of the archive-handling is done
288        and respective applicants are simply removed from the
289        database.
290        """
291
292class IApplicantsContainerAdd(IApplicantsContainer):
293    """An applicants container contains university applicants.
294    """
295    prefix = schema.Choice(
296        title = _(u'Application Target'),
297        required = True,
298        source = ApplicationTypeSource(),
299        readonly = False,
300        )
301
302    year = schema.Choice(
303        title = _(u'Year of Entrance'),
304        required = True,
305        values = year_range(),
306        readonly = False,
307        )
308
309IApplicantsContainerAdd[
310    'prefix'].order =  IApplicantsContainer['prefix'].order
311IApplicantsContainerAdd[
312    'year'].order =  IApplicantsContainer['year'].order
313
314class IApplicantBaseData(IApplicantBase):
315    """The data for an applicant.
316
317    This is a base interface with no field
318    required. For use with processors, forms, etc., please use one of
319    the derived interfaces below, which set more fields to required
320    state, depending on use-case.
321    """
322
323    history = Attribute('Object history, a list of messages')
324    state = Attribute('The application state of an applicant')
325    display_fullname = Attribute('The fullname of an applicant')
326    application_date = Attribute('UTC datetime of submission, used for export only')
327    password = Attribute('Encrypted password of a applicant')
328    application_number = Attribute('The key under which the record is stored')
329
330    suspended = schema.Bool(
331        title = _(u'Account suspended'),
332        default = False,
333        required = False,
334        )
335
336    applicant_id = schema.TextLine(
337        title = _(u'Applicant Id'),
338        required = False,
339        readonly = False,
340        )
341    reg_number = TextLineChoice(
342        title = _(u'Registration Number'),
343        readonly = False,
344        required = True,
345        source = contextual_reg_num_source,
346        )
347    #access_code = schema.TextLine(
348    #    title = u'Activation Code',
349    #    required = False,
350    #    readonly = True,
351    #    )
352    firstname = schema.TextLine(
353        title = _(u'First Name'),
354        required = True,
355        )
356    middlename = schema.TextLine(
357        title = _(u'Middle Name'),
358        required = False,
359        )
360    lastname = schema.TextLine(
361        title = _(u'Last Name (Surname)'),
362        required = True,
363        )
364    date_of_birth = FormattedDate(
365        title = _(u'Date of Birth'),
366        required = False,
367        #date_format = u'%d/%m/%Y', # Use grok-instance-wide default
368        show_year = True,
369        )
370    sex = schema.Choice(
371        title = _(u'Sex'),
372        source = GenderSource(),
373        required = True,
374        )
375    email = schema.ASCIILine(
376        title = _(u'Email Address'),
377        required = False,
378        constraint=validate_email,
379        )
380    phone = PhoneNumber(
381        title = _(u'Phone'),
382        description = u'',
383        required = False,
384        )
385    course1 = schema.Choice(
386        title = _(u'1st Choice Course of Study'),
387        source = AppCatCertificateSource(),
388        required = True,
389        )
390    course2 = schema.Choice(
391        title = _(u'2nd Choice Course of Study'),
392        source = AppCatCertificateSource(),
393        required = False,
394        )
395    #school_grades = schema.List(
396    #    title = _(u'School Grades'),
397    #    value_type = ResultEntryField(),
398    #    required = False,
399    #    default = [],
400    #    )
401
402    notice = schema.Text(
403        title = _(u'Notice'),
404        required = False,
405        )
406    student_id = schema.TextLine(
407        title = _(u'Student Id'),
408        required = False,
409        readonly = False,
410        )
411    course_admitted = schema.Choice(
412        title = _(u'Admitted Course of Study'),
413        source = CertificateSource(),
414        required = False,
415        )
416    locked = schema.Bool(
417        title = _(u'Form locked'),
418        default = False,
419        )
420
421class IApplicant(IApplicantBaseData):
422    """An applicant.
423
424    This is basically the applicant base data. Here we repeat the
425    fields from base data if we have to set the `required` attribute
426    to True (which is the default).
427    """
428
429    def writeLogMessage(view, comment):
430        """Adds an INFO message to the log file
431        """
432
433    def createStudent():
434        """Create a student object from applicatnt data
435        and copy applicant object.
436        """
437
438class IApplicantEdit(IApplicant):
439    """An applicant interface for editing.
440
441    Here we can repeat the fields from base data and set the
442    `required` and `readonly` attributes to True to further restrict
443    the data access. Or we can allow only certain certificates to be
444    selected by choosing the appropriate source.
445
446    We cannot omit fields here. This has to be done in the
447    respective form page.
448    """
449
450    email = schema.ASCIILine(
451        title = _(u'Email Address'),
452        required = True,
453        constraint=validate_email,
454        )
455    course1 = schema.Choice(
456        title = _(u'1st Choice Course of Study'),
457        source = AppCatCertificateSource(),
458        required = True,
459        )
460    course2 = schema.Choice(
461        title = _(u'2nd Choice Course of Study'),
462        source = AppCatCertificateSource(),
463        required = False,
464        )
465    course_admitted = schema.Choice(
466        title = _(u'Admitted Course of Study'),
467        source = CertificateSource(),
468        required = False,
469        readonly = True,
470        )
471    notice = schema.Text(
472        title = _(u'Notice'),
473        required = False,
474        readonly = True,
475        )
476
477IApplicantEdit['email'].order = IApplicantEdit[
478    'sex'].order
479
480class IApplicantUpdateByRegNo(IApplicant):
481    """Representation of an applicant.
482
483    Skip regular reg_number validation if reg_number is used for finding
484    the applicant object.
485    """
486    reg_number = schema.TextLine(
487        title = u'Registration Number',
488        required = False,
489        )
490
491class IApplicantRegisterUpdate(IApplicant):
492    """Representation of an applicant for first-time registration.
493
494    This interface is used when applicants use the registration page to
495    update their records.
496    """
497    reg_number = schema.TextLine(
498        title = u'Registration Number',
499        required = True,
500        )
501
502    firstname = schema.TextLine(
503        title = _(u'First Name'),
504        required = True,
505        )
506
507    email = schema.ASCIILine(
508        title = _(u'Email Address'),
509        required = True,
510        constraint=validate_email,
511        )
512
513class IApplicantOnlinePayment(IOnlinePayment):
514    """An applicant payment via payment gateways.
515
516    """
517
518    def doAfterApplicantPayment():
519        """Process applicant after payment was made.
520
521        """
522
523    def doAfterApplicantPaymentApproval():
524        """Process applicant after payment was approved.
525
526        """
527
528    def approveApplicantPayment():
529        """Approve payment and process applicant.
530
531        """
Note: See TracBrowser for help on using the repository browser.