def isAvailable(self):
        context = self.context
        if checkPermission('zojax.AddPhoto', context) or \
                checkPermission('zojax.SubmitPhoto', context):
            return True

        return False

def create_sittings_map(sittings, request):
    """Returns a dictionary that maps:

      (day, hour) -> {
         'record'   : sitting database record
         'actions'  : actions that apply to this sitting
         'class'    : sitting
         'span'     : span
         }
         
      (day, hour) -> ``None``
      
    If the mapped value is a sitting, then a sitting begins on that
    day and hour, if it's ``None``, then a sitting is reaching into
    this day and hour.
    
    The utility of the returned structure is to aid rendering a
    template with columns spanning several rows.
    """

    mapping = {}
    for sitting in sittings.values():
        day = sitting.start_date.weekday()
        hour = sitting.start_date.hour

        start_date = utils.timedict(sitting.start_date.hour, sitting.start_date.minute)

        end_date = utils.timedict(sitting.end_date.hour, sitting.end_date.minute)

        status = misc.get_wf_state(sitting)

        proxied = ProxyFactory(sitting)

        if checkPermission(u"bungeni.agendaitem.wf.schedule", proxied):
            link = "%s/schedule" % url.absoluteURL(sitting, request)
        else:
            link = url.absoluteURL(sitting, request)

        if checkPermission("zope.View", proxied):
            mapping[day, hour] = {
                "url": link,
                "record": sitting,
                "class": u"sitting",
                "actions": get_sitting_actions(sitting, request),
                "span": sitting.end_date.hour - sitting.start_date.hour,
                "formatted_start_time": start_date,
                "formatted_end_time": end_date,
                "status": status,
            }
            for hour in range(sitting.start_date.hour + 1, sitting.end_date.hour):
                mapping[day, hour] = None

        # make sure start- and end-date is the same DAY
        assert (
            (sitting.start_date.day == sitting.end_date.day)
            and (sitting.start_date.month == sitting.end_date.month)
            and (sitting.start_date.year == sitting.end_date.year)
        )

    return mapping

 def __call__(self):
     if checkPermission('simplemanagement.EditCompass', self.context):
         return super(Compass, self).__call__()
     elif checkPermission('simplemanagement.ViewCompass', self.context):
         self.request.response.redirect('{0}history'.format(self.base_url()))
         return u''
     raise Unauthorized

    def update(self):
        if self.updated:
            return

        self.updated = True

        context = self.context
        if checkPermission('zojax.ModifyTaskStatus', context):
            self.severity = getUtility(
                IVocabularyFactory, 'project.task.severity')(context)

        if checkPermission('zojax.ModifyTaskAttributes', context):
            self.allowAttributes = True

        if checkPermission('zojax.AssignTo', context):
            self.allowAssign = True

        if checkPermission('zojax.AddContentAttachment', context):
            self.allowAttachments = True

        self.wfinfo = IWorkflowInfo(context)
        self.wfinfo.fireAutomatic()

        # subscribers
        auth = getUtility(IAuthentication)

        subs = getSubscribers(('tasks',), context)
        assignees = getSubscribers(('assigneetasks'), context)

        for pid in IAssignments(context).assignees:
            if pid in assignees:
                subs.add(pid)

        subscribers = []
        for subs in subs:
            try:
                principal = auth.getPrincipal(subs)
            except PrincipalLookupError:
                continue

            profile = IPersonalProfile(principal)

            subscribers.append(profile.title)

        subscribers.sort()
        self.subscribers = subscribers

        task = removeAllProxies(context)
        if checkPermission('zojax.ModifyContent', task.__parent__.__parent__):
            self.manageSubscribers = absoluteURL(
                task.__parent__.__parent__, self.request)

        super(TaskCommentForm, self).update()

        include('jquery-plugins')

        if 'file' in self.widgets:
            self.widgets['file'].klass = 'multi'

    def update(self):
        context = self.context
        request = self.request

        self.noIcon = not bool(self.context.icon)

        principal = self.request.principal
        if not IUnauthenticatedPrincipal.providedBy(principal):
            self.menu = True

            self.submitTopic = \
                checkPermission('zojax.forum.AddTopic', context) or \
                checkPermission('zojax.forum.SubmitTopic', context)

            notifications = getAdapter(context, IContentNotification, 'forum')
            self.subscribed = notifications.isSubscribed(principal.id)

        if len(self.context) > 1:
            self.searching = True

        data = ISession(request)[SESSIONKEY]
        forum = removeAllProxies(context)
        key = getUtility(IIntIds).getId(forum)

        if 'form.button.search' in request:
            searchableText = request['form.searchforum']
            data[key] = (searchableText, True)

        if 'form.button.clear' in request:
            searchableText = None
            if key in data:
                del data[key]

        else:
            searchtext, searching = data.get(key, (u'', False))
            if searchtext and searching:
                searchableText = searchtext
            else:
                searchableText = None

        if searchableText:
            query = {'searchableText': searchableText,
                     'type': {'any_of': ('forum.message',)},
                     'traversablePath': {'any_of': (forum,)},
                     'noPublishing': True, 'noSecurityChecks': True}

            try:
                results = getUtility(ICatalog).searchResults(**query)
            except Exception, e:
                IStatusMessage(self.request).add(e, 'error')
                return

            self.total = len(results)
            self.searchableText = searchableText
            self.searchResults = Batch(results, size=20, request=request)

    def __call__(self):
        try:
            date = self.request.get("from")
            dateobj = datetime.datetime(*time.strptime(date, "%Y-%m-%d")[0:5])
            start_date = utils.datetimedict.fromdate(dateobj)
        except:
            start_date = None

        try:
            date = self.request.get("to")
            dateobj = datetime.datetime(*time.strptime(date, "%Y-%m-%d")[0:5])
            end_date = utils.datetimedict.fromdate(dateobj)
        except:
            end_date = None

        if start_date is None:
            start_date = utils.datetimedict.fromdate(datetime.date.today())
            days = tuple(start_date + timedelta(days=d) for d in range(7))
            end_date = days[-1]
        elif end_date is None:
            start_date = utils.datetimedict.fromdate(datetime.date.today())
            days = tuple(start_date + timedelta(days=d) for d in range(7))
            end_date = days[-1]
        sittings = self.context.get_sittings(start_date, end_date)
        self.sittings = []
        for sitting in sittings.values():
            if checkPermission("zope.View", sitting):
                trusted = removeSecurityProxy(sitting)
                trusted.text = dict(sitting_status=_(misc.get_wf_state(trusted, trusted.status)))
                self.sittings.append(trusted)
        self.request.response.setHeader("Content-type", self.content_mimetype)
        return self.render()

 def render(self, template=None):
     if template is None:
         template = self.template
     if (not checkPermission(u"bungeni.sitting.Add", self.context)) or \
         (IBusinessSectionLayer.providedBy(self.request)):
         self.edit = False
     else:
         self.edit = True
     session = Session()
     venues = session.query(domain.Venue).all()
     languages = get_all_languages()
     session.close()
     self.display_language = get_default_language()
     if self.request.get("I18N_LANGUAGE"):
         self.display_language = self.request.get("I18N_LANGUAGE")
     #html is hardcoded in here because doing it in the template
     #would have been a colossal pain
     #TODO: FIX THIS
     s = '<div class="dhx_cal_ltext" style="height:90px;">' 
     s += '<table>'
     s += '<tr><td>Venue</td><td><select id="select_sitting_venue">'
     for venue in venues:
         s += '<option value="'+str(venue.venue_id)+'">'+venue.short_name+'</option>'
     s += '</select></td></tr>'
     s += '<tr><td>Language</td><td><select id="select_sitting_lang">'
     for lang in languages:
         if lang == 'en':
             s += '<option value="'+lang+'" selected>'+lang+'</option>'
         else:
             s += '<option value="'+lang+'">'+lang+'</option>'
     s += '</select></td></tr></table></div>'
     self.sitting_details_form = s
     return template()

    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 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 get_sessions(self):
     sessions = [ removeSecurityProxy(session) for key, session in 
         self.context.get_group().sessions.items()
         if checkPermission("bungeni.session.View", session)
     ]
     sessions.sort(key=lambda sess:sess.start_date)
     return sessions

 def getMenuItems(self, context, request):
     """Return menu item entries in a TAL-friendly form."""
     _url = url.absoluteURL(context, request)
     if checkPermission("bungeni.translation.Add", context):
         language = get_language(context)
         available = get_available_translations(context)
         results = []
         for name, obj in get_all_languages().items():
             title = obj["name"]
             # skip the current language
             if name == language:
                 continue
             action_url = "%s/translate?language=%s" % (_url, name)
             extra = {
                 "id": "translation-action-%s" % name,
                 "separator": None,
                 "class": ""
             }
             translation_id = available.get(name)
             results.append(
                 dict(title=title,
                      description="",
                      action=action_url,
                      selected=translation_id is not None,
                      icon=None,
                      extra=extra,
                      submenu=None))
         return results
     else:
         return None

def list_container_items(container, permission="zope.View"):
    """Generate list of container items with permission check
    """
    trusted = proxy.removeSecurityProxy(container)
    for contained in trusted.values():
        if checkPermission(permission, contained):
            yield contained

 def __call__(self, force=None):
     """ try executing all pending request with dates older than "now" """
     if not checkPermission('synchro.Execute', self.context):
         raise Forbidden
     if self.storage.busy:
         if force:
             LOG_INFO("Forcing synchro on busy storage")
         else:
             LOG_ERROR("Synchro is busy, use force=true to force execution")
             raise BadRequest("Synchro is busy")
     LOG_INFO("Locking synchro", BLATHER)
     self.storage.busy = True
     transaction.commit()
     LOG_INFO("Starting synchro processing", BLATHER)
     processed = 0
     try:
         for entry in self.olderPending():
             self.process(entry)
             processed += 1
         return "Synchro finished. %s entries processed" % processed
     finally:
         LOG_INFO("Unlocking synchro", BLATHER)
         self.storage.busy = False
         transaction.commit()
         LOG_INFO("Synchro finished. %s entries processed" % processed, BLATHER)

 def execute_static_deployment(self, entry):
     """
     executes defined staticdeployment process
     @rtype: dict
     """
     response = {}
     action = entry.action
     
     def handle_error(msg):
         LOG_ERROR(msg)
         response['status'] = 'error'
         response['data'] = [msg]
         
     if not checkPermission('static.Export', self.context):
         mtool = getToolByName(self.context, 'portal_membership')
         username = mtool.getMemberInfo().get('username', '')
         errmsg = "User '%s' has no 'static.Export' permission" % username
         handle_error(errmsg)
         return response
     
     action_items = getattr(entry, 'props', {})
     staticdeployment = getMultiAdapter((self.context, self.request),
                                         name='staticdeployment-controlpanel')
     if not action_items.has_key('section_choice'):
         errmsg = "Deployment skin is not defined in config file"
         handle_error(errmsg)
         return response
     
     staticdeployment._on_save(dict(action_items))
     response['status'] = 'ok'
           
     return response

    def getMenuItems(self, context, request):
        """Return menu item entries in a TAL-friendly form."""

        types = []
        for type_ in getAllUtilitiesRegisteredFor(ITileType):
            if checkPermission(type_.add_permission, context):
                try:
                    if request.traverseName(
                        context, "@@" + type_.__name__):
                        types.append(type_)
                except NotFound:
                    continue
        types.sort(lambda x, y: cmp(x.title, y.title))

        normalizer = getUtility(IIDNormalizer)
        return [{
                'title': type_.title,
                'description': type_.description,
                'action': "%s/@@add-tile?form.button.Create=1&type=%s"\
                    % (context.absolute_url(), type_.__name__),
                'selected': False,
                'icon': None,
                'extra': {
                    'id': "add-%s" % normalizer.normalize(type_.__name__),
                    'separator': None, 'class': ''
                    },
                'submenu': None,
                } for type_ in types]

 def showCreateCommunity(self):
     """ The Contributor role is assumed that will be applied at the group in
         the portal root.
     """
     if IHomePage.providedBy(self.context) and \
        checkPermission('ulearn.addCommunity', self.portal()):
         return True

 def values(self):
     workflow = get_workflow(self.context.domain_model.__name__.lower())
     public_wfstates = workflow.get_state_ids(tagged=["public"],
         restrict=False)
     return [ x for x in self.context.values()
         if checkPermission("zope.View", x)
              and x.status in public_wfstates ]

    def tileTypes(self):
        """Get a list of addable ITileType objects representing tiles
        which are addable in the current context
        """
        tiles = []

        for tile_name in getUtility(IRegistry)['plone.app.tiles']:
            tiletype = getUtility(ITileType, tile_name)
            # check if we have permission to add this tile
            if checkPermission(tiletype.add_permission, self.context):
                # tile actions
                # TODO: read from registry
                tiletype.actions = [{
                    'name': 'edit',
                    'url': '@@edit-tile',
                    'title': _('Edit'),
                }, {
                    'name': 'remove',
                    'url': '@@delete-tile',
                    'title': _('Remove'),
                }]
                tiles.append(tiletype)

        tiles.sort(self.tileSortKey)
        return tiles

    def show_controls(self):
        """ Returns True if the sources should be modifyable/removeable. """

        # not exactly the required permission, but that's not the point:
        # if the user has the permission to edit the context the permission
        # to edit the sources probably inherited.
        return checkPermission('cmf.ModifyPortalContent', self.context)

    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))