def update(self):
        topic = self.context
        request = self.request
        formatter = getFormatter(request, 'fancyDatetime', 'medium')

        name = topic.__name__
        owner = IOwnership(topic).owner
        profile = IPersonalProfile(owner)
        space = getattr(profile, 'space', None)

        self.name = name
        self.replies = len(topic)-1
        self.owner = getattr(profile, 'title', '')
        self.avatar = profile is not None and profile.avatarUrl(request) or '#',
        self.personal = '%s/'%(space and absoluteURL(space, request) or '',)

        message = topic.lastMessage

        if message is not None:
            owner = IOwnership(message).owner
            profile = IPersonalProfile(owner, None)
            space = getattr(profile, 'space', None)

            self.lastmessage = {
                'date': formatter.format(IDCTimes(message).modified),
                'owner': getattr(profile, 'title', ''),
                'personal': '%s/'%(space and absoluteURL(space,request) or '',),
                'avatar': profile is not None and profile.avatarUrl(request) or '#',
                'url': '%s/%s/'%(name, message.__name__)}

    def getUserInfo(self, loginOrId):
        """Return the user name details, and avatar url for given userid"""

        principal = getPrincipal(loginOrId)
        if principal is None:
            principal = getPrincipalByLogin(loginOrId)

        if principal is not None:
            profile = IPersonalProfile(principal, None)
            homeFolder = IPersonalSpace(principal, None)
            profileUrl = homeFolder is not None and '%s/profile/'%absoluteURL(homeFolder, self.request) or ''

            if profile.avatar is not None:
                iconURL = '%s/profile.avatar/%s' % (absoluteURL(getSite(), self.request), principal.id)
            else:
                iconURL = '%sprofileImage' % profileUrl

            return {'username' : loginOrId,
                    'fullname' : principal.title,
                    'email' : profile.email,
                    'home_page' : profileUrl,
                    'location' : profileUrl,
                    'description' : principal.description,
                    'portrait_url' : iconURL
                    }
        else:
            raise ValueError("User %s Does not Exist!" % loginOrId)

    def handleNext(self, action):
        currentStep = self.step

        if IPageletForm.providedBy(currentStep):
            data, errors = currentStep.extractData()
            if errors:
                return

        if not currentStep.isComplete():
            return

        self.updateSteps()

        nextStep = self.request.get(self.nextStepName)
        if nextStep:
            try:
                nextStep = int(nextStep)
            except:
                nextStep = int(nextStep[0])
            self.redirect(
                '%s/'%absoluteURL(self.steps[nextStep], self.request))
        else:
            for pos, step in enumerate(self.steps):
                if currentStep.name == step.name:
                    break
            self.redirect('%s/'%absoluteURL(self.steps[pos+1], self.request))

    def update(self):
        super(MemberMessageNotification, self).update()

        context = self.context
        request = self.request

        group = removeAllProxies(context.context).__parent__
        visible = checkPermission('zope.View', group)

        owner = IOwnership(group).owner
        profile = IPersonalProfile(owner, None)

        message = cgi.escape(context.message)
        message = message.replace(' ', ' ')
        message = message.replace('\n', '<br />')

        self.title = group.title
        self.sender = getattr(profile, 'title', 'Unknown member')

        self.info = {
            'title': group.title,
            'description': group.description,
            'created': IDCTimes(group).created,
            'members': len(group),
            'url': '%s/'%absoluteURL(group, request),
            'message': message,
            'default': not visible or not bool(getattr(group, 'logo', None)),
            'sender': self.sender}

        if profile is not None:
            self.addHeader(u'From', formataddr((self.sender, profile.email),))

        self.site = getSite()
        self.siteTitle = getattr(self.site, 'title', u'') or self.site.__name__
        self.siteURL = u'%s'%absoluteURL(self.site, request)

    def handlePublish(self, action):
        errorSteps = []
        for step in self.steps:
            if not step.isComplete():
                errorSteps.append(step)

        if errorSteps:
            IStatusMessage(self.request).add(errorSteps, 'wizardError')
            return

        draft = self.draft
        request = self.request
        try:
            content = draft.publish()
            IStatusMessage(self.request).add(
                _(u'Your ${type_title} has been published.',
                  mapping={'type_title': IContentType(content).title}))

            view = queryMultiAdapter((content, request), IContentViewView)
            if view is not None:
                self.redirect('%s/%s'%(absoluteURL(content,request), view.name))
            else:
                self.redirect('%s/'%absoluteURL(content, request))

            del draft.__parent__[draft.__name__]
        except DraftException, err:
            IStatusMessage(request).add(str(err), 'error')
            self.wizard.setCurrentStep('content')
            self.redirect('%s/index.html'%absoluteURL(draft, request))

    def update(self):
        try:
            author = getUtility(IAuthentication).getPrincipal(
                self.context.author)
        except:
            author = None

        if author is not None:
            profile = IPersonalProfile(author)
            self.avatar = profile.avatarUrl(self.request)
            self.author = profile.title

            if profile.space is not None:
                self.url = absoluteURL(profile.space, self.request)
        else:
            self.avatar = u'%s/@@profile.avatar/0'%absoluteURL(
                getSite(), self.request)

        if author is not None or author == u'Unauthenticated User':
            if getattr(self.context, 'authorName'):
                self.author = self.context.authorName
                if 'social_avatar_url' in dir(self.context) and self.context.social_type:
                    self.social_avatar = self.context.social_avatar_url
                    if self.context.social_type==1:
                        self.social_name = 'Twitter'
                    elif self.context.social_type==2:
                        self.social_name = 'Facebook'

        self.comment = self.context.comment

        content = self.context.content
        self.postsAllowed = (
            IContentDiscussion(content).status in [1, 4] and
            checkPermission('zojax.AddComment', content))

    def update(self):
        super(TaskDeletedNotification, self).update()

        context = removeAllProxies(self.context)
        request = self.request
        principal = self.request.principal

        self.name = context.__name__

        mailer = getUtility(IMailer)

        profile = IPersonalProfile(principal, None)
        if profile is not None and profile.email:
            author = profile.title
            self.author = author
            self.addHeader(u"To", formataddr((author, profile.email)))
        else:
            self.author = principal.title or principal.id

        self.addHeader(u"From", formataddr((self.author, mailer.email_from_address)))

        self.url = "%s/" % absoluteURL(context, request)
        self.project = context.__parent__.__parent__

        # project
        self.projectTitle = self.project.title
        self.projectUrl = u"%s/" % absoluteURL(self.project, request)

    def listDrafts(self):
        ids = getUtility(IIntIds)
        request = self.request
        context = self.context

        drafts = []
        for name in context:
            draft = context[name]
            if not checkPermission('zope.View', draft):
                continue

            try:
                loc = ids.queryObject(draft.location)
                locTitle = loc.title
                locUrl = '%s/'%absoluteURL(loc, request)
            except:
                locTitle = _('Unknown')
                locUrl = u''

            dc = ICMFDublinCore(draft.content)

            info = {'name': name,
                    'title': draft.title or _('[No title]'),
                    'description': draft.description,
                    'url': '%s/'%absoluteURL(draft, request),
                    'location': locTitle,
                    'locationURL': locUrl,
                    'icon': queryMultiAdapter((draft, request), name='zmi_icon'),
                    'draft': draft,
                    'modified': dc.modified,
                    'status': ISubmittedDraftContent.providedBy(draft),
                    'contentType': IContentType(draft.content)}
            drafts.append(info)

        return drafts

    def __call__(self):
        """Create breadcrumbs for an interface object.

        The breadcrumbs are rooted at the code browser.
        """
        docroot = findAPIDocumentationRoot(self.context)
        codeModule = traverse(docroot, "Code")
        crumbs = [{
            'name': _('[top]'),
            'url': absoluteURL(codeModule, self.request)
        }]
        # We need the __module__ of the interface, not of a location proxy,
        # so we have to remove all proxies.
        iface = removeAllProxies(self.context)
        mod_names = iface.__module__.split('.')
        obj = codeModule
        for name in mod_names:
            try:
                obj = traverse(obj, name)
            except KeyError: # pragma: no cover
                # An unknown (root) module, such as logging
                continue
            crumbs.append({
                'name': name,
                'url': absoluteURL(obj, self.request)
            })
        crumbs.append({
            'name': iface.__name__,
            'url': absoluteURL(self.context, self.request)
        })
        return crumbs

    def update(self):
        super(EventDeletedNotification, self).update()

        context = removeAllProxies(self.context)
        request = self.request
        principal = self.request.principal

        self.name = context.__name__

        mailer = getUtility(IMailer)

        profile = IPersonalProfile(principal, None)
        if profile is not None and profile.email:
            author = profile.title
            self.author = author
            self.addHeader(u'To', formataddr((author, profile.email),))
        else:
            self.author = principal.title or principal.id

        self.addHeader(u'From', formataddr((self.author, mailer.email_from_address),))

        self.url = '%s/'%absoluteURL(context, request)
        self.calendar = context.__parent__

        # calendar
        self.calendarUrl = u'%s/'%absoluteURL(self.calendar, request)

    def update(self):
        super(CommentNotificationMail, self).update()

        content = self.context
        comment = self.context0
        self.comment = comment

        request = self.request

        principal = self.request.principal

        mailer = getUtility(IMailer)

        profile = IPersonalProfile(principal, None)
        if profile is not None and profile.email:
            author = profile.title
            self.author = author
            space = getattr(profile, 'space', None)
            if space is not None:
                self.profile_url = '%s/profile/' % absoluteURL(space, request)
            self.addHeader(u'To', formataddr((author, profile.email),))
            self.addHeader(u'From', formataddr((author, mailer.email_from_address),))
        else:
            self.author = principal.title or principal.id

        view = queryMultiAdapter((content, request), IContentViewView)
        if view is not None:
            self.url = '%s/%s'%(absoluteURL(content, request), view.name)
        else:
            self.url = '%s/'%absoluteURL(content, request)

        self.content = comment.content
        self.portal_title = getMultiAdapter((getSite(), request), IBreadcrumb).name
        self.available = comment.isAvailable()

    def listComments(self):
        auth = getUtility(IAuthentication)
        formatter = getFormatter(self.request, 'fancyDatetime', 'medium')

        comments = []
        for comment in self.comments:
            info = {'name': comment.__name__,
                    'title': comment.content.title,
                    'url': absoluteURL(comment.content, self.request),
                    'author': None,
                    'profile': None,
                    'date': comment.date,
                    'fomratteddate': formatter.format(comment.date)}

            try:
                principal = auth.getPrincipal(comment.author)
                profile = IPersonalProfile(principal)
                info['author'] = profile.title

                space = profile.space
                if space is not None:
                    info['profile'] = '%s/'%absoluteURL(space, self.request)

            except PrincipalLookupError:
                pass

            comments.append(info)

        return comments

    def update(self):
        super(NotificationMail, self).update()

        content = self.context
        event = self.contexts[0]
        request = self.request

        self.url = "%s/" % absoluteURL(content, request)

        principal = IOwnership(content).owner

        profile = IPersonalProfile(principal)
        if profile.email:
            author = profile.title
            self.author = author
            self.addHeader(u"From", formataddr((author, profile.email)))
            self.addHeader(u"To", formataddr((self.author, profile.email)))
        else:
            self.author = principal.title or principal.id

        self.site = getSite()

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

        cId = getUtility(IIntIds).getId(content)

        self.messageId = u"<%s.%[email protected]>" % (cId, time.time())

    def query(self, default=None):
        request = self.request
        content = self.getLocation()
        if content is None:
            return

        item = IItem(content, None)

        title = u''
        description = u''
        if item is not None:
            title = item.title
            description = item.description

        view = queryMultiAdapter((content, request), IContentViewView)
        if view is not None:
            url = '%s/%s'%(absoluteURL(content, request), view.name)
        else:
            url = '%s/'%absoluteURL(content, request)

        return {'url': url,
                'title': title or _('[No title]'),
                'content': content,
                'icon': queryMultiAdapter((content, request), name='zmi_icon'),
                'description': description or u''}

 def url(self):
     viewName = queryMultiAdapter(
         (self.context, self.request), IContentViewView)
     if viewName is not None:
         return '%s/%s'%(
             absoluteURL(self.context, self.request), viewName.name)
     else:
         return '%s/'%(absoluteURL(self.context, self.request))

 def nextURL(self):
     viewName = queryMultiAdapter(
         (self._addedObject, self.request), IContentViewView)
     if viewName is not None:
         return '%s/%s'%(
             absoluteURL(self._addedObject, self.request), viewName.name)
     else:
         return '%s/'%absoluteURL(self._addedObject, self.request)

 def nextURL(self):
     if 'person_id' in self.request:
         person_id = self.request['person_id']
         app = ISchoolToolApplication(None)
         persons = app['persons']
         if person_id in persons:
             return absoluteURL(persons[person_id], self.request)
     return absoluteURL(self.context, self.request)

 def getLinkURL(self, item):
     """Setup link url."""
     state = IWorkflowState(item).getState()
     if state != None:
         state = titleForState(state)
     if self.linkName is not None and state == "Entwurf":
         return '%s/%s' % (absoluteURL(item, self.request), self.linkName)
     return absoluteURL(item, self.request)

 def update(self):
     base_resource_url = '%s/@@/jquery-uploadify/' % absoluteURL(getSite(), self.request)
     url = self.request.getURL()
     params = {
         'uploader_url': base_resource_url + 'uploadify.swf',
         'script_url': '%s/bulk-upload-process' % absoluteURL(self.context, self.request),
         'ticket': issueTicket(url),
         'button_text': translate(self.buttonText, context=self.request),
         'cancel_image_url': base_resource_url + 'cancel.png',
     }
     includeInplaceSource(INIT_TEMPLATE % params, ('jquery-uploadify',))

    def update(self):
        super(MessageTemplate, self).update()

        request, context = self.request, self.context

        self.portal_title = getMultiAdapter((getSite(), request), IBreadcrumb).name
        self.portal_url = '%s/' % absoluteURL(getSite(), request)
        self.url = '%s/' % absoluteURL(context, request)

        self.form = getMultiAdapter((context, request), IFormResults)
        self.form.update(self.record)