def principalLoggedinHandler(event):
    prefs = IPersonalProfile(event.principal, None)
    if prefs is not None:
        lastLoginTime = prefs.lastLoginTime

        if lastLoginTime is not None:
            dt = parseDatetimetz(str(datetime.datetime.now()))
            td = dt - prefs.lastLoginTime
            if td.days or td.seconds > 60:
                prefs.lastLoginTime = dt
        else:
            prefs.lastLoginTime = parseDatetimetz(str(datetime.datetime.now()))

    def add_newsitem(self, entry):
        """ Add news item
        """
        title = entry.get('title', '')
        title = title.replace(' ', ' ').strip()

        description = BeautifulSoup(entry.get('summary', ''))
        description = ''.join([e for e in description.recursiveChildGenerator()
                        if isinstance(e, unicode)]).strip()

        ptool = getToolByName(self.context, 'portal_properties')
        sanitize = getattr(ptool, 'sanitize', None)
        if sanitize:
            title_sanitize = sanitize.getProperty('subject', [])
            for expr in title_sanitize:
                title = title.replace(expr, '')
            desc_sanitize = sanitize.getProperty('body', [])
            for expr in desc_sanitize:
                description = description.replace(expr, '')

        body = description

        utils = getUtility(IText)
        description = utils.truncate(description, 20, 200)

        if not (title and description):
            return None

        url = entry.get('link', '#').strip()

        updated = entry.get('updated', None)
        if not updated:
            updated = datetime.now(bucharest)
        else:
            try:
                updated = parseDatetimetz(updated)
            except SyntaxError:
                updated = parseDatetimetz(updated.replace(' ', 'T', 1))
            except:
                updated = datetime.now(bucharest)

            # Skip news older than 30 days
            plone_ro = 'plone.ro' in url
            if not plone_ro:
                try:
                    if updated < (datetime.now() - timedelta(10)):
                        return None
                except TypeError:
                    if updated < (datetime.now(bucharest) - timedelta(10)):
                        return None
                except Exception, err:
                    logger.exception(err)

 def test_getInputValue(self, value=u"2004-03-26 12:58:59", check_value=parseDatetimetz("2004-03-26 12:58:59")):
     self._widget.request.form["field.foo"] = u""
     self.assertRaises(WidgetInputError, self._widget.getInputValue)
     self._widget.request.form["field.foo"] = value
     self.assertEquals(self._widget.getInputValue(), check_value)
     self._widget.request.form["field.foo"] = u"abc"
     self.assertRaises(ConversionError, self._widget.getInputValue)

def principalProfileModified(profile, event):
    profile.modified = parseDatetimetz(str(datetime.datetime.now()))

    configlet = getUtility(IProfilesCategory)
    if configlet.photoAsAvatar and profile.profileImage:
        image = copy(profile.profileImage)
        configlet = getUtility(IAvatarConfiglet)
        if (image.width > configlet.maxWidth or
            image.height > configlet.maxHeight):
            try:
                image.data = convert(
                    image.data, 'image/jpeg',
                    sourceMimetype = image.mimeType,
                    width = configlet.maxWidth,
                    height = configlet.maxHeight, quality=88)
            except ConverterException, err:
                log = logging.getLogger('zojax.personal.profile')
                log.log(logging.WARNING, str(err))
                return
            else:
                profile.avatarImage = image
        else:
            profile.avatarImage = image

        profile.avatar = 0

    def __get__(self, inst, klass):
        if inst is None:
            return self

        attribute = getattr(inst.context, self._get_name, _marker)
        if attribute is _marker:
            field = self._field.bind(inst)
            attribute = getattr(field, 'default', _marker)
            if attribute is _marker:
                raise AttributeError(self._field.__name__)
        elif isinstance(attribute, Pdata):
            attribute = str(attribute)
        elif callable(attribute):
            attribute = attribute()

        if self._field._type == str:
            return attribute
        if isinstance(attribute, str) and inst.encoding:
            return attribute.decode(inst.encoding)
        if isinstance(attribute, DateTime):
            return parseDatetimetz(attribute.ISO8601())
        if isinstance(attribute, (tuple, list)):
            if inst.encoding:
                attribute = [ isinstance(v, str)
                              and v.decode(inst.encoding) or v
                              for v in attribute ]
            if self._field._type == list:
                return attribute
            if self._field._type == tuple:
                return tuple(attribute)
            return set(attribute)
        return attribute

 def __get__(self, inst, klass):
     if inst is None:
         return self
     data = inst._mapping.get(self.__name__, ())
     if data:
         return parseDatetimetz(data[0])
     else:
         return None

 def test_getInputValue(self,
         value=u'2004-03-26 12:58:59',
         check_value=parseDatetimetz('2004-03-26 12:58:59')):
     self._widget.request.form['field.foo'] = u''
     self.assertRaises(WidgetInputError, self._widget.getInputValue)
     self._widget.request.form['field.foo'] = value
     self.assertEquals(self._widget.getInputValue(), check_value)
     self._widget.request.form['field.foo'] = u'abc'
     self.assertRaises(ConversionError, self._widget.getInputValue)

    def json_to_python(self, d):
        for key in d:
            if key in ['created','modified','effective']:
               d[key] = parseDatetimetz(d[key])
            if isinstance(d[key],str):
                d[key] = unicode(d[key])
            if type(d[key]) in [ListType,TupleType]:
                d[key] = map(unicode,d[key])

        return d

 def _toFieldValue(self, value):
     dates = []
     for token in itertools.chain(*[line.split("\n") for line in value.split(",")]):
         token = token.strip()
         if not token:
             continue
         try:
             date = parseDatetimetz(token)
             dates.append(date.date())
         except (DateTimeError, ValueError, IndexError), v:
             raise ConversionError(_("Invalid date: $value", mapping={"value": token}), v)

 def _toFieldValue(self, input):
     # TODO: Manually check if weekday is enabled -- the user could have
     # directly entered the date.
     if input == self._missing:
         return self.context.missing_value
     else:
         try:
             dt = parseDatetimetz(input)
         except (DateTimeError, ValueError, IndexError), v:
             return super(DatetimeBase, self)._toFieldValue(input)
         else:

 def _toFieldValue(self, input):
     if input == self._missing:
         return self.context.missing_value
     else:
         try:
             # TODO: Currently datetimes return in local (server)
             # time zone if no time zone information was given.
             # Maybe offset-naive datetimes should be returned in
             # this case? (DV)
             return parseDatetimetz(input)
         except (DateTimeError, ValueError, IndexError), v:
             raise ConversionError(_("Invalid datetime data"), v)

 def _handle_success(self, action, data):
     # normalize set and datetime
     for k, v in data.iteritems():
         if isinstance(v, Set):
             data[k] = set(v)
         elif isinstance(v, datetime) and v.tzname() is None:
             data[k] = parseDatetimetz(str(v))
     changes = self.applyChanges(data)
     if changes:
         self.status = self.successMessage
     else:
         self.status = self.noChangesMessage
     return changes

 def _handle_success(self, action, data):
     # normalize set and datetime
     for k, v in data.iteritems():
         if isinstance(v, Set):
             data[k] = set(v)
         elif isinstance(v, datetime) and v.tzname() is None:
             data[k] = parseDatetimetz(str(v))
     if form.applyChanges(self.context, self.form_fields, data,
                          self.adapters):
         self.context.reindexObject()
         obj_type = translate(self.context.Type(), self.context)
         self.status = _(u'${obj_type} changed.',
                         mapping={'obj_type': obj_type})
     else:
         self.status = _(u'Nothing to change.')

    def getDateForField(self, field, source):
        """Returns a datetime object for the specified field in source.

        Returns None if the field value cannot be converted to date.
        """

        # look in input element first
        pattern = '<input .* name="form.%s".* value="(.*)".*>' % field
        m = re.search(pattern, source)
        if m is None:
            # look in a select element
            pattern = '<select .* name="form.%s".*>.*' '<option value="(.*)" selected>*.</select>' % field
            m = re.search(pattern, source, re.DOTALL)
            if m is None:
                return None
        return parseDatetimetz(m.group(1))

    def testDates(self):
        self.__testQualified('Dates', [
            (u'', u'1990-01-01'),
            (u'Created', u'1980-10-01T23:11:10-04:00'),
            (u'Modified', u'2002-10-01T12:09:22-04:00'),
            (u'Effective', u'2002-10-09T00:00:00-04:00'),
            (u'Expires', u'2002-10-16T00:00:00-04:00'),
            (u'xxx', u'2000-07-04'),
            (u'xxx', u'2001-12-31'),
            (u'foo \u1111', u'2001-12-31'),
            ])

        from zope.datetime import parseDatetimetz

        dc = self.dc
        self.assertEqual(dc.created,
                         parseDatetimetz('1980-10-01T23:11:10-04:00'))
        self.assertEqual(dc.modified,
                         parseDatetimetz('2002-10-01T12:09:22-04:00'))
        self.assertEqual(dc.effective,
                         parseDatetimetz('2002-10-09T00:00:00-04:00'))
        self.assertEqual(dc.expires,
                         parseDatetimetz('2002-10-16T00:00:00-04:00'))

        self.assertEqual(dc.Date(), u'1990-01-01')
        self.assertEqual(dc.CreationDate(), u'1980-10-01T23:11:10-04:00')
        self.assertEqual(dc.ModificationDate(), u'2002-10-01T12:09:22-04:00')
        self.assertEqual(dc.EffectiveDate(), u'2002-10-09T00:00:00-04:00')
        self.assertEqual(dc.ExpirationDate(), u'2002-10-16T00:00:00-04:00')


        dt = parseDatetimetz('2002-10-03T14:51:55-04:00')

        dc.modified = dt

        self.assertRaises(Exception, setattr, dc, 'modified', 'foo')

        modified = [qv[1]
                    for qv in dc.getQualifiedDates()
                    if qv[0] == u'Modified']

        self.assertFalse(len(modified) != 1,
                         "should be only one: %r" % modified)

        self.assertEqual(parseDatetimetz(modified[0]), dt)

        modified = dc.ModificationDate()
        self.assertEqual(parseDatetimetz(modified), dt)

 def __call__(self):
     if os.path.exists('+maintenancetime.txt'):
         message = file('+maintenancetime.txt').read()
         try:
             maintenancetime = parseDatetimetz(message)
         except DateTimeError:
             # XXX SteveAlexander 2005-09-22: log a warning here.
             return ''
         timeleft = maintenancetime - utc_now()
         if timeleft > self.toomuchtime:
             return ''
         elif timeleft < self.notmuchtime:
             self.timelefttext = 'very very soon'
         else:
             self.timelefttext = 'in %s' % (
                 DurationFormatterAPI(timeleft).approximateduration())
         return self.index()
     return ''

    def __call__(self, nextURL):
        profile = IPersonalProfile(self.principal)

        if not profile.isComplete() and checkPermission('zojax.PersonalSpace', getSite()):
            if profile.firstname and profile.lastname:
                profile.modified = parseDatetimetz(str(datetime.datetime.now()))

            space = profile.space
            if space is not None:
                self.request.response.redirect(
                    u'%s/profile/profile/'%absoluteURL(space, self.request))

                IStatusMessage(self.request).add(
                    _('You successfully logged in to portal. Please complete your profile.'))

                return True

        return False

    def testDates(self):
        self.__testQualified(
            "Dates",
            [
                (u"", u"1990-01-01"),
                (u"Created", u"1980-10-01T23:11:10-04:00"),
                (u"Modified", u"2002-10-01T12:09:22-04:00"),
                (u"Effective", u"2002-10-09T00:00:00-04:00"),
                (u"Expires", u"2002-10-16T00:00:00-04:00"),
                (u"xxx", u"2000-07-04"),
                (u"xxx", u"2001-12-31"),
                (u"foo \u1111", u"2001-12-31"),
            ],
        )

        from zope.datetime import parseDatetimetz

        dc = self.dc
        self.assertEqual(dc.created, parseDatetimetz("1980-10-01T23:11:10-04:00"))
        self.assertEqual(dc.modified, parseDatetimetz("2002-10-01T12:09:22-04:00"))
        self.assertEqual(dc.effective, parseDatetimetz("2002-10-09T00:00:00-04:00"))
        self.assertEqual(dc.expires, parseDatetimetz("2002-10-16T00:00:00-04:00"))

        self.assertEqual(dc.Date(), u"1990-01-01")
        self.assertEqual(dc.CreationDate(), u"1980-10-01T23:11:10-04:00")
        self.assertEqual(dc.ModificationDate(), u"2002-10-01T12:09:22-04:00")
        self.assertEqual(dc.EffectiveDate(), u"2002-10-09T00:00:00-04:00")
        self.assertEqual(dc.ExpirationDate(), u"2002-10-16T00:00:00-04:00")

        dt = parseDatetimetz("2002-10-03T14:51:55-04:00")

        dc.modified = dt

        self.assertRaises(Exception, setattr, dc, "modified", "foo")

        modified = [qv[1] for qv in dc.getQualifiedDates() if qv[0] == u"Modified"]

        self.failIf(len(modified) != 1, "should be only one: %r" % modified)

        self.assertEqual(parseDatetimetz(modified[0]), dt)

        modified = dc.ModificationDate()
        self.assertEqual(parseDatetimetz(modified), dt)

    def joinPrincipal(self, principalId, approved=True,
                      _td = timedelta(milliseconds=1)):
        if principalId not in self:
            member = Member()
            event.notify(ObjectCreatedEvent(member))
            self[principalId] = member

            joined = parseDatetimetz(str(datetime.now()))
            while joined in self.joined:
                joined = joined + _td

            member.joined = joined
            self.joined[joined] = principalId

            if not approved:
                member.approved = False
                self.notapproved.insert(principalId)
            else:
                event.notify(MemberApprovedEvent(member))

            event.notify(ObjectModifiedEvent(self.__parent__))
            updatePermissions(self.__parent__)

def principalRegisteredHandler(event):
    prefs = IPersonalProfile(event.principal, None)
    if prefs is not None:
        prefs.registered = parseDatetimetz(str(datetime.datetime.now()))