Changeset 310

Show
Ignore:
Timestamp:
03/17/08 17:12:05 (9 months ago)
Author:
johnbywater
Message:

Changed date format from YYYY-MM-DD to DD-MM-YYYY.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/src/dm/datetimeconvertor.py

    r248 r310  
    5757        ) 
    5858 
     59class RDateConvertor(object):   
     60    "Converts between HTML (string) and python (mx.DateTime.Date)." 
     61         
     62    def fromHTML(self, dateHtml): 
     63        day, month, year = None, None, None 
     64        if dateHtml in ['', None]: 
     65            return None 
     66        elif dateHtml.__class__ == "".__class__: 
     67            day, month, year = [int(i) for i in dateHtml.split('-')] 
     68        elif dateHtml.__class__ == datetime.date: 
     69            day, month, year = dateHtml.day, dateHtml.month, dateHtml.year 
     70        elif dateHtml.__class__ == datetime.datetime: 
     71            day, month, year = dateHtml.day, dateHtml.month, dateHtml.year 
     72        else: 
     73            msg = "Unsupported date input type: %s" % dateHtml.__class__ 
     74            raise Exception(msg) 
     75        return mx.DateTime.Date(year, month, day) 
     76 
     77    def toHTML(self, dateObject): 
     78        if dateObject in ['', None]: 
     79            return '' 
     80        return "%s-%s-%s" % ( 
     81            str(dateObject.day).zfill(2), 
     82            str(dateObject.month).zfill(2), 
     83            str(dateObject.year).zfill(4), 
     84        ) 
     85 
  • trunk/src/dm/dom/base.py

    r307 r310  
    174174        "Supports: len(registry)" 
    175175        return self.count() 
    176         #return self.database.countRecords(self.typeName) 
    177176 
    178177    def __iter__(self, **kwds): 
  • trunk/src/dm/dom/meta.py

    r308 r310  
    88from dm.datetimeconvertor import DateTimeConvertor 
    99from dm.datetimeconvertor import DateConvertor 
     10from dm.datetimeconvertor import RDateConvertor 
    1011import Image 
    1112from dm.dictionarywords import IMAGES_DIR_PATH 
     
    394395 
    395396 
     397class RDate(DateTime): 
     398    "Models a domain object date attribute, but with 'reverse' ANSI format." 
     399     
     400    convertor = RDateConvertor() 
     401 
     402 
    396403class Boolean(ValueObjectAttr): 
    397404    "Models a domain object boolean attribute." 
  • trunk/src/dm/dom/metatest.py

    r247 r310  
    1616        unittest.makeSuite(TestDateTime), 
    1717        unittest.makeSuite(TestDate), 
     18        unittest.makeSuite(TestRDate), 
    1819        unittest.makeSuite(TestBoolean_True), 
    1920        unittest.makeSuite(TestBoolean_False), 
     
    152153 
    153154 
     155class TestRDate(MetaAttrTestCase): 
     156     
     157    fieldClass = dm.dom.meta.RDate 
     158    typeName = 'RDate' 
     159    isValueObject = True 
     160    htmlValue = '03-06-2007' 
     161    htmlRepr = '03-06-2007' 
     162    domValue = mx.DateTime.Date(2007, 6, 3) 
     163    dbValue = mx.DateTime.Date(2007, 6, 3) 
     164     
     165    def test_convertor(self): 
     166        self.failUnless(self.field.convertor) 
     167 
     168 
    154169class TestBoolean_True(MetaAttrTestCase): 
    155170     
  • trunk/src/dm/view/manipulator.py

    r308 r310  
    11from dm.ioc import * 
    22from dm.exceptions import KforgeCommandError 
    3 from dm.webkit import * 
    43from dm.dictionarywords import WEBKIT_NAME 
     4from dm.webkit import Manipulator 
     5from dm.webkit import htmlescape 
    56import re 
     7import dm.webkit 
    68 
    79class BaseManipulator(Manipulator): 
     
    1214    commands   = RequiredFeature('CommandSet') 
    1315    logger     = RequiredFeature('Logger') 
     16    webkit     = dm.webkit 
    1417 
    1518    def getValidationErrors(self, data): 
     
    117120            choices = metaAttr.getAllChoices(self.domainObject) 
    118121            if webkitName == 'django': 
    119                 field = SelectMultipleField( 
     122                field = self.webkit.SelectMultipleField( 
    120123                    field_name=metaAttr.name, 
    121124                    is_required=isFieldRequired, 
     
    124127                ) 
    125128            elif webkitName == 'pylons': 
    126                 field = SelectField( 
     129                field = self.webkit.SelectField( 
    127130                    metaAttr.name, 
    128131                    multiple=True, 
     
    134137                choices = [('', '-- select option --')] + choices 
    135138                if webkitName == 'django': 
    136                     field = SelectField( 
     139                    field = self.webkit.SelectField( 
    137140                        field_name=metaAttr.name, 
    138141                        is_required=isFieldRequired, 
     
    140143                    ) 
    141144                elif webkitName == 'pylons': 
    142                     field = SelectField( 
     145                    field = self.webkit.SelectField( 
    143146                        metaAttr.name, 
    144147                    ) 
    145148            else:  # need to find a way to only do this for string keys 
    146149                if webkitName == 'django': 
    147                     field = TextField( 
    148                         field_name=metaAttr.name, 
    149                         is_required=isFieldRequired, 
    150                     ) 
    151                 elif webkitName == 'pylons': 
    152                     field = TextField( 
     150                    field = self.webkit.TextField( 
     151                        field_name=metaAttr.name, 
     152                        is_required=isFieldRequired, 
     153                    ) 
     154                elif webkitName == 'pylons': 
     155                    field = self.webkit.TextField( 
    153156                        metaAttr.name, 
    154157                        size=40 
     
    158161                if metaAttr.name[0:5] == 'email': 
    159162                    if webkitName == 'django': 
    160                         field = EmailField( 
     163                        field = self.webkit.EmailField( 
    161164                            field_name=metaAttr.name, 
    162165                            is_required=isFieldRequired, 
     
    164167                        ) 
    165168                    elif webkitName == 'pylons': 
    166                         field = TextField( 
     169                        field = self.webkit.TextField( 
    167170                            metaAttr.name, 
    168171                            size=36 
     
    170173                else: 
    171174                    if webkitName == 'django': 
    172                         field = TextField( 
     175                        field = self.webkit.TextField( 
    173176                            field_name=metaAttr.name, 
    174177                            is_required=isFieldRequired, 
    175178                        ) 
    176179                    elif webkitName == 'pylons': 
    177                         field = TextField( 
     180                        field = self.webkit.TextField( 
    178181                            metaAttr.name, 
    179182                            size=40 
     
    182185            elif metaAttr.typeName == 'Text': 
    183186                if webkitName == 'django': 
    184                     field = LargeTextField( 
     187                    field = self.webkit.LargeTextField( 
    185188                        field_name=metaAttr.name, 
    186189                        is_required=isFieldRequired, 
     
    189192                    ) 
    190193                elif webkitName == 'pylons': 
    191                     field = TextField( 
     194                    field = self.webkit.TextField( 
    192195                        metaAttr.name, 
    193196                        size=40 
     
    195198            elif metaAttr.typeName == 'Password': 
    196199                if webkitName == 'django': 
    197                     field = PasswordField( 
    198                         field_name=metaAttr.name, 
    199                         is_required=isFieldRequired, 
    200                     ) 
    201                 elif webkitName == 'pylons': 
    202                     field = TextField( 
     200                    field = self.webkit.PasswordField( 
     201                        field_name=metaAttr.name, 
     202                        is_required=isFieldRequired, 
     203                    ) 
     204                elif webkitName == 'pylons': 
     205                    field = self.webkit.TextField( 
    203206                        metaAttr.name, 
    204207                        size=40 
     
    206209            elif metaAttr.typeName == 'Integer': 
    207210                if webkitName == 'django': 
    208                     field = IntegerField( 
    209                         field_name=metaAttr.name, 
    210                         is_required=isFieldRequired, 
    211                     ) 
    212                 elif webkitName == 'pylons': 
    213                     field = TextField( 
     211                    field = self.webkit.IntegerField( 
     212                        field_name=metaAttr.name, 
     213                        is_required=isFieldRequired, 
     214                    ) 
     215                elif webkitName == 'pylons': 
     216                    field = self.webkit.TextField( 
    214217                        metaAttr.name, 
    215218                        size=40 
     
    217220            elif metaAttr.typeName == 'Boolean': 
    218221                if webkitName == 'django': 
    219                     field = CheckboxField( 
     222                    field = self.webkit.CheckboxField( 
    220223                        field_name=metaAttr.name 
    221224                        # doesn't accept 'is_required' parameter 
    222225                    ) 
    223226                elif webkitName == 'pylons': 
    224                     field = TextField( 
     227                    field = self.webkit.TextField( 
    225228                        metaAttr.name, 
    226229                        size=40 
     
    228231            elif metaAttr.typeName == 'Url': 
    229232                if webkitName == 'django': 
    230                     field = URLField( 
    231                         field_name=metaAttr.name, 
    232                         is_required=isFieldRequired, 
    233                     ) 
    234                 elif webkitName == 'pylons': 
    235                     field = TextField( 
     233                    field = self.webkit.URLField( 
     234                        field_name=metaAttr.name, 
     235                        is_required=isFieldRequired, 
     236                    ) 
     237                elif webkitName == 'pylons': 
     238                    field = self.webkit.TextField( 
    236239                        metaAttr.name, 
    237240                        size=40 
     
    239242            elif metaAttr.typeName == 'DateTime': 
    240243                if webkitName == 'django': 
    241                     field = DatetimeField( 
    242                         field_name=metaAttr.name, 
    243                         is_required=isFieldRequired, 
    244                     ) 
    245                 elif webkitName == 'pylons': 
    246                     field = TextField( 
     244                    field = self.webkit.DatetimeField( 
     245                        field_name=metaAttr.name, 
     246                        is_required=isFieldRequired, 
     247                    ) 
     248                elif webkitName == 'pylons': 
     249                    field = self.webkit.TextField( 
    247250                        metaAttr.name, 
    248251                        size=40 
     
    250253            elif metaAttr.typeName == 'Date': 
    251254                if webkitName == 'django': 
    252                     field = DateField( 
    253                         field_name=metaAttr.name, 
    254                         is_required=isFieldRequired, 
    255                     ) 
    256                 elif webkitName == 'pylons': 
    257                     field = TextField( 
     255                    field = self.webkit.DateField( 
     256                        field_name=metaAttr.name, 
     257                        is_required=isFieldRequired, 
     258                    ) 
     259                elif webkitName == 'pylons': 
     260                    field = self.webkit.TextField( 
     261                        metaAttr.name, 
     262                        size=40 
     263                    ) 
     264            elif metaAttr.typeName == 'RDate': 
     265                if webkitName == 'django': 
     266                    field = self.webkit.RDateField( 
     267                        field_name=metaAttr.name, 
     268                        is_required=isFieldRequired, 
     269                    ) 
     270                elif webkitName == 'pylons': 
     271                    field = self.webkit.TextField( 
    258272                        metaAttr.name, 
    259273                        size=40 
     
    261275            else: 
    262276                if webkitName == 'django': 
    263                     field = TextField( 
    264                         field_name=metaAttr.name, 
    265                         is_required=isFieldRequired, 
    266                     ) 
    267                 elif webkitName == 'pylons': 
    268                     field = TextField( 
     277                    field = self.webkit.TextField( 
     278                        field_name=metaAttr.name, 
     279                        is_required=isFieldRequired, 
     280                    ) 
     281                elif webkitName == 'pylons': 
     282                    field = self.webkit.TextField( 
    269283                        metaAttr.name, 
    270284                        size=40 
     
    272286        elif metaAttr.typeName == 'ImageFile': 
    273287            if webkitName == 'django': 
    274                 field = FileUploadField( 
     288                field = self.webkit.FileUploadField( 
    275289                    field_name=metaAttr.name, 
    276290                    is_required=isFieldRequired, 
    277291                ) 
    278292            elif webkitName == 'pylons': 
    279                     field = TextField( 
     293                    field = self.webkit.TextField( 
    280294                        metaAttr.name, 
    281295                        size=40 
  • trunk/src/dm/webkit/__init__.py

    r308 r310  
    1212    import django 
    1313    from django.utils.html import escape as htmlescape 
     14    from django.forms import validators 
    1415    from django.forms import Manipulator 
    1516    from django.forms import SelectField, SelectMultipleField, TextField 
     
    5253 
    5354 
     55 
     56 
     57# Django extensions, without a home. 
     58if webkitName == 'django': 
     59 
     60    import sre 
     61    _rdatere = r'((?:0?[1-9])|(?:[12][0-9])|(?:3[0-1]))-((?:0?[1-9])|(?:1[0-2]))-(19|2\d)\d{2}' 
     62    ransi_date_re = sre.compile('^%s$' % _rdatere) 
     63 
     64    class RDateField(TextField): 
     65        """A FormField that automatically converts its data to a datetime.date objec 
     66    t. 
     67        The data should be in the format DD-MM-YYYY""" 
     68        def __init__(self, field_name, is_required=False, validator_list=None): 
     69            if validator_list is None: validator_list = [] 
     70            validator_list = [self.isValidDate] + validator_list 
     71            TextField.__init__(self, field_name, length=10, maxlength=10, 
     72                is_required=is_required, validator_list=validator_list) 
     73     
     74        def isValidDate(self, field_data, all_data): 
     75            try: 
     76                if not ransi_date_re.search(field_data): 
     77                    raise ValidationError( 
     78                        'Enter a valid date in DD-MM-YYYY format.' 
     79                    ) 
     80            except validators.ValidationError, e: 
     81                raise validators.CriticalValidationError, e.messages 
     82     
     83        def html2python(data): 
     84            "Converts the field into a datetime.date object" 
     85            import time, datetime 
     86            try: 
     87                time_tuple = time.strptime(data, '%d-%m-%Y') 
     88                return datetime.date(*time_tuple[0:3]) 
     89            except (ValueError, TypeError): 
     90                return None 
     91        html2python = staticmethod(html2python) 
     92     
     93        def render(self, data): 
     94            return super(RDateField, self).render(data) 
     95     
     96