コード例 #1
0
ファイル: poll.py プロジェクト: mrmaple/open_qon
class Poll(QonPersistent, Watchable):
    """A single Poll."""

    persistenceVersion = 1
    
    def __init__(self, creator, title, description, end_date, choices):
        """Create a poll. Choices is a list of strings."""
        
        Watchable.__init__(self)
        
        # PollContainer (set by container when added)
        self.container = None
        
        # User who created poll
        self.creator = creator
        
        # Date created/modified
        self.date = datetime.utcnow()
        
        # End date
        self.end_date = end_date
        
        # Title/Description
        self.title = title
        self.__description = CompressedText(description)
        self.__cached_html = PersistentCache(self._update_html_cache)
        
        # Other settings and vote data
        self.__data = PollData(choices)
        
        # cache of PollData items
        self.__num_votes_cast = None
        
        # poll index within container
        self.__item_index = None

    def upgradeToVersion1(self):
        self.title = iso_8859_to_utf_8(self.title)
        
    def get_data(self):
        return self.__data
    
    def get_description(self):
        return self.__description.get_raw()
    
    def set_description(self, raw):
        self.__description.set_raw(raw)
        self.invalidate_html_cache()
        
    def has_voted(self, user):
        """True if user has already voted."""
        return self.__data.has_voted(user)
        
    def user_vote(self, user):
        try:
            return self.__data.user_vote(user)
        except KeyError:
            return []

    def user_vote_choices(self, user):
        """Return list of strings representing user's choices."""
        choices = self.user_vote(user)
        
        pd = self.get_data()
        votes = []
        for v in choices:
            votes.append(pd.choices[v])
        
        return votes
    
    def user_votes_choices(self):
        """Returns dict of {user_id: [string1, string2, ...]} of user votes."""
        vote_choice_data = self.__data.user_votes()
        
        vote_data = {}
        for user_id, choices in vote_choice_data.iteritems():
            vote_data[user_id] = [self.__data.choices[i] for i in choices]
        return vote_data

    def is_active(self, as_of=None):
        """Return True if Poll is currently active."""
        if not as_of:
            as_of = datetime.utcnow()
            
        is_active = as_of < self.end_date
        
        # check if we need to update our watchable_changed status
        if not is_active:
            if self.watchable_last_change() < self.end_date:
                self.watchable_changed()
        
        return is_active
    
    def cancel_poll(self, note=None):
        """Immediately ends poll, inserting note if any at beginning of description."""
        self.end_date = datetime.utcnow()
        if note:
            self.set_description(note + '\n\n\n' + self.get_description())
            
        # set changed when poll is canceled
        self.watchable_changed(self.end_date)
        
    def num_votes_cast(self):
        if not self.__num_votes_cast:
            self.__num_votes_cast = self.__data.num_votes_cast()
        return self.__num_votes_cast
        
    def valid_vote(self, user, choices):
        """Check various permissions to vote. If choices is not None, also checks validity
        of choices. Use can_vote to pre-check user's access before validity of choices.
        
        Returns:
            1: if user is allowed to vote and choices includes required votes.
            0: if choices are not valid
            -1: if user does not have access to vote
            -2: user has already voted
            -3: user has insufficient feedback score to vote
            -4: user has insufficnent bank to vote
            -5: user joined ned.com after poll started
        """
        
        # general vote access
        if self.__data.vote_access == 'owner':
            if not self.container.ihb.is_owner(user):
                return -1
        elif self.__data.vote_access == 'member':
            if not self.container.ihb.is_member(user) and not self.container.ihb.is_owner(user):
                return -1
        
        # min karma
        if not self.enough_karma_to_vote(user):
            return -3
        
        # karma bank cost
        if user.get_karma_bank_balance() < self.__data.karma_cost:
            return -4
        
        # valid choices
        if choices and not self.__data.choices_valid(choices):
            return 0
        
        # check if trying to vote for no choices
        if choices is not None and not choices:
            return 0
        
        if not self.__data.voter_can_revise:
            if self.__data.has_voted(user):
                return -2
        
        if not self.old_enough_to_vote(user):
            return -5
        
        return 1
        
    def can_pay_for_vote(self, user):
        if not user:
            return False
        return user.can_give_karma(self.get_data().karma_cost)

    def enough_karma_to_vote(self, user):
        return user.get_karma_score() >= self.get_data().min_karma

    def old_enough_to_vote(self, user):
        return user.get_user_data().member_since() <= self.date

    def can_vote(self, user):
        return self.valid_vote(user, choices=None) == 1
    
    def can_see_intermediate_results(self, user):
        pd = self.get_data()
        
        vote_required = pd.vote_required_to_view
        has_voted = self.has_voted(user)
        
        if vote_required and not has_voted:
            return False
        
        if pd.intermediate_access == 'none':
            return False
        if pd.intermediate_access == 'all':
            return True
        if pd.intermediate_access == 'member':
            return self.container.ihb.is_member(user) or self.container.ihb.is_owner(user)
        if pd.intermediate_access == 'owner':
            return self.container.ihb.is_owner(user)
        return False
        
    def can_see_results(self, user):
        pd = self.get_data()
                
        if pd.results_access == 'all':
            return True
        if pd.results_access == 'member':
            return self.container.ihb.is_member(user) or self.container.ihb.is_owner(user)
        if pd.results_access == 'owner':
            return self.container.ihb.is_owner(user)
        return False
        
    def record_vote(self, user, choices):
        """Record a vote. Raises ValueError if valid_vote() check fails.
        
        Fails silently if poll is no longer open or if user can't pay.
        """
        
        if not self.is_active():
            return
        
        if self.valid_vote(user, choices) != 1:
            raise ValueError
            
        # see if new vote is identical to previous vote
        if self.has_voted(user):
            if choices == self.user_vote(user):
                return
            
        if not _ROLLOUT_TEST:
            # try to pay for item
            try:
                user.pay_karma(self.get_data().karma_cost)
            except NoKarmaToGive:
                return
        
        self.__data.record_vote(user, choices)
        self.__num_votes_cast = None
        
        # karma credit
        user.karma_activity_credit()
    
    def choice_list_to_choices(self, choice_list):
        """Convert a list of strings to their corresponding list of indices.
        
        Raises ValueError if there is an invalid item in choice_list.
        """
        pd = self.get_data()
        choices = []
        for item in choice_list:
            choices.append(pd.choices.index(item))
        return choices
        
    def _set_item_index(self, index):
        """Used by PollContainer to set this item's index when added to container."""
        self.__item_index = index
    
    def get_item_index(self):
        return self.__item_index

    def add_html_dependency(self, target):
        """Adds target as something self depends on for its HTML cache."""
        self.__cached_html.add_dependency(target)

    def invalidate_html_cache(self):
        self.__cached_html.flush()
        
    def get_cached_html(self):
        return self.__cached_html.get().get_raw()

    def _update_html_cache(self):
        from qon.ui.blocks.wiki import rst_to_html
        return CompressedText(str(rst_to_html(self.get_description(),
            wiki=self.container.ihb.get_wiki(),
            container=self)))

    def disable_cache(self):
        self.__cached_html.disable_cache()

    def cache_disabled(self):
        return self.__cached_html.cache_disabled()        
            
    def watchable_name(self):
        return self.title

    def watchable_changed(self, now=None):
        # tells container he has changed, too
        Watchable.watchable_changed(self, now)
        self.container.watchable_changed(now)

    def can_read(self, user):
        return self.container.ihb.can_read(user)        
コード例 #2
0
ファイル: wiki.py プロジェクト: mrmaple/open_qon
class Wiki(QonPersistent, Watchable):

    persistenceVersion = 1
    _inactive_period            = timedelta(days=7)
    _inactive_karma_discount    = 1

    def __init__(self, group):
        Watchable.__init__(self)
        self.group = group
        self.pages = OOBTree.OOBTree()
        self.__cached_recent_changes = PersistentCache(self._update_recent_changes_cache)
        self.index_page = WikiPage(self, name='index')
        self.pages['index'] = self.index_page
        self.index_page.versions[-1].set_raw(_default_index_page % \
            dict(top_header='='*len(self.group.name),
                bottom_header='='*len(self.group.name),
                title=self.group.name,
                group_name=self.group.get_user_id()
                )
            )
        self.index_page.versions[-1].set_date(datetime.utcnow())
        self.index_page.versions[-1].set_author(self.group.owners[0])
        self.index_page.versions[-1].set_title(self.group.name)
        self.__uniques = OOBTree.OOBTree()

        self._create_default_pages()
        
    def upgradeToVersion1(self):
        self.__cached_recent_changes = PersistentCache(self._update_recent_changes_cache)
        self.version_upgrade_done()
        
    def new_page(self, name):
        page = WikiPage(self, name)
        name = clean_page_name(name)
        self.pages[name] = page
        self.watchable_changed(page.versions[-1].date)
        self._p_changed = 1
        return page

    def remove_page(self, page):
        del self.pages[page.name]
        if self.__uniques.get(page.name):
            del self.__uniques[page.name]
        
    def get_page(self, page_name):
        """Return page or None."""
        # jimc: not cleaning the page name
        # led to case differences wiping out
        # an old workspace page.
        name = clean_page_name(page_name)

        if self.pages.has_key(name):
            return self.pages[name]
        return None

    def decay_inactive_items(self):
        """Call this daily to decay karma of inactive items.
        Returns a list of items that were decayed.
        """
        # XXX This could be refactored into an interface shared by
        # XXX Wiki.decay_inactive_items and Blog.decay_inactive_items

        decayed_items = []
        decay_time = datetime.utcnow() - self._inactive_period
        for page_name, item in self.pages.iteritems():
            if item.get_karma_score() > 0:
                if item.watchable_last_change() < decay_time:
                    item.add_anon_karma(-self._inactive_karma_discount)
                    decayed_items.append(item)
        return decayed_items

    def recent_changes(self):
        """Returns list of pages sorted newest first."""
        return [page for date, page in self.recent_changes_with_date()]
        
    def _update_recent_changes_cache(self):
        bydate = []
        for name, page in self.pages.items():
            bydate.append((page.watchable_last_change(), page))
        bydate.sort()
        bydate.reverse()
        return bydate
        
    def recent_changes_with_date(self):
        return self.__cached_recent_changes.get()
        
    def recent_edits_by_author(self, author, count=10):
        """Return count pages most-recently edited by author."""
        edits = []
        for name, page in self.pages.items():
            version = page.latest_edit_by(author)
            if version:
                edits.append(page)
        
        edits = sort_list(edits, lambda x: x.watchable_last_change(), count=count)
        return edits        
    
    def recent_comments_by_author(self, author, count=10):
        """Return count most-recent comments by author in this wiki. Returns list of (page, comment)
        tuples.
        """
        bydate = []
        for page in self.pages.values():
            bydate.extend([(c.date, page, c) for c in page.get_comments() if c.author is author])
        
        bydate.sort()
        
        comments = [(page, comment) for date, page, comment in bydate[-count:]]
        comments.reverse()
        return comments

    def num_pages(self):
        return len(self.pages)

    def num_active_pages(self, days=3):
        """Returns the number of pages that have been modified in the last X days
        Also returns the date of the latest page, in case it's useful"""
        cutoff_date = datetime.utcnow() - timedelta(days=days)
        # active_pages = [p for p in self.pages if p.watchable_last_change() > cutoff_date]      // slower because it creates a new list
        # return len(active_pages)         
        num = 0
        latest_date = never        
        for n, p in self.pages.items():
            mod = p.watchable_last_change()
            if mod > cutoff_date:
                num += 1
            if mod > latest_date:
                latest_date = mod                
        return (num, latest_date)
        
    def search_pages(self, text_to_find):
        """Search pages for text. Slow and lame. Fix me, please."""
        if text_to_find is None:
            return []
            
        matching = []
        text_to_find = text_to_find.strip().lower()
        
        for page_name in self.pages.keys():
            page = self.pages[page_name]
            if page.name.find(text_to_find) != -1:
                matching.append(page)
            elif page.versions[-1].title.find(text_to_find) != -1:
                matching.append(page)
            elif page.versions[-1].get_raw().lower().find(text_to_find) != -1:
                matching.append(page)
        return matching
        
    def references_to(self, page, all=1, all_groups=1):
        """Return pages which refer to page. If all is false, returns first match."""
        
        # if page has up-to-date inbound_references
        if hasattr(page, 'inbound_references') and page.inbound_references is not None:
            matching = []
            sorted_refs = _sort_refs(page.inbound_references, self.group)
            for ref in sorted_refs:
                if all:
                    matching.append(_ref_to_page(ref, self.group))
                else:
                    return _ref_to_page(ref, self.group)
            return matching
        
        # otherwise recompute inbound_references
        matching = []
        for n, p in self.pages.iteritems():

            if not p.outbound_references:
                continue
                
            for group, name in p.outbound_references:
                # For same-group references, group is None
                if group is None and (page.name == name):
                    if all:
                        matching.append(p)
                    else:
                        return p

        # now look through all other groups
        if all_groups:
            for group_id, group in get_group_database().root.iteritems():
                wiki = group.get_wiki()
                for n, p in wiki.pages.iteritems():

                    if not p.outbound_references:
                        continue
                    
                    for refgroup, refname in p.outbound_references:
                        if refgroup is self.group and (page.name == refname):
                            if all:
                                matching.append(p)
                            else:
                                return p

        # convert to references format
        in_refs = [p.get_ref() for p in matching]

        # sort references for storage
        in_refs = _sort_refs(in_refs, self.group)

        # record inbound_references in page, since we just recomputed it all
        page.inbound_references = PersistentList(in_refs)

        # return sorted references
        matching = [_ref_to_page(ref, self.group) for ref in in_refs]
        return matching
        
    backlinks = references_to
    
    def is_orphan(self, page):
        """Returns true if page has no references to it, unless it's the index page."""
        if page is self.index_page:
            return False
        if self.references_to(page, all=0):
            return False
        return True

    def highest_score_items(self, count=10):
        """Return list of pages with highest karma, highest first. Zeros are filted out."""
        bykarma = []
        for n, p in self.pages.items():
            bykarma.append((p.get_karma_score(), p.watchable_last_change(), p))
        bykarma.sort()
        items = [p for karma, date, p in bykarma[-count:] if karma > 0]
        items.reverse()
        return items
    
    def orphans(self):
        """Return pages which are not referred to."""
        orphans = []
        for name, page in self.pages.items():
            if not self.references_to(page, all=0):
                orphans.append(page)
                
        bydate = [(p.watchable_modified_date(), p) for p in orphans]
        bydate.sort()
        bydate.reverse()
        return [p for d, p in bydate]
        
        
    def get_unique_name(self, page):
        """Return a unique name using page.name as prefix."""
        cur_index = self.__uniques.get(page.name, 0)
        cur_index += 1
        while self.pages.has_key(page.name + str(cur_index)):
            cur_index += 1
        self.__uniques[page.name] = cur_index
        return page.name + str(cur_index)
        
    def watchable_name(self):
        return self.group.name + ' Workspace'
        
    def watchable_changed(self, now=None):
        Watchable.watchable_changed(self, now)

        # flush recent changes cache
        self.__cached_recent_changes.flush()

        # group changed, too
        self.group.watchable_changed(now)

    def watchable_modified_date(self):
        return self.watchable_last_change()

    def can_read(self, user):
        return self.group.can_read(user)
        
    def _create_default_pages(self):
        pass
        if 0:
            # There should only be a single Puntuation Help page: /help/Punctuation Help
            page = self.new_page('Punctuation Help')
            page.versions[-1].set_raw(_punc_help)
            
            page.versions[-1].set_date(datetime.utcnow())
            page.versions[-1].set_author(self.group.owners[0])
            page.versions[-1].set_title('Punctuation Help')
コード例 #3
0
ファイル: wiki.py プロジェクト: mrmaple/open_qon
class WikiPage(QonPersistent, Watchable, qon.karma.HasKarma, IHasBlog):

    persistenceVersion = 4

    def __init__(self, wiki, name=''):
        Watchable.__init__(self)
        qon.karma.HasKarma.__init__(self)
        self.wiki = wiki
        self.outbound_references = None
        self.inbound_references = None
        self.name = clean_page_name(name)
        self.versions = PersistentList()
        self.blog = Blog(self)
        self.locked_by_user = None
        self.__cached_html = PersistentCache(self._update_html_cache)
        self.__cached_html2 = PersistentCache(self._update_html2_cache)
        self.new_revision(force_new=1)
        
    def upgradeToVersion4(self):
        self.inbound_references = None
        self.version_upgrade_done()

    def upgradeToVersion3(self):
        self.__cached_html2 = PersistentCache(self._update_html2_cache)
        self.version_upgrade_done()

    def upgradeToVersion2(self):
        self.__cached_html = PersistentCache(self._update_html_cache)
        self.version_upgrade_done()

    def upgradeToVersion1(self):
        self.blog.ihb = self
        self.version_upgrade_done()
        
    def __repr__(self):
        return '<%s object at 0x%x: %s>' % (self.__module__ + '.' + self.__class__.__name__,
            id(self), self.name or "*no name*")

    def new_revision(self, set_date=True, author=None, title='', raw='', force_new=0):
        """Create a new revision for this page.
        
        Check to make sure that the new text is actually different
        from the latest revision.  If it's not, then don't bother creating a
        new revision."""
        if force_new or (self.versions[-1].get_raw() != raw):
            w = WikiVersion(page=self, author=author, title=title, raw=raw)
            if set_date:
                w.set_date(datetime.utcnow())
            self.versions.append(w)
            
            self.watchable_changed(w.date)
            if author:
                author.karma_activity_credit()
                
            # before invalidating referring pages, we want to 
            # update the html cache, which has the side effect
            # of updating the outbound references.
            self.invalidate_html_cache()
            unused_html = self.get_cached_html()

            # may seem useless for new pages, but we could be creating
            # a new page that was referred to from another page somewhere
            self._invalidate_referring_pages()
            
            self._p_changed = 1
            
    def _invalidate_referring_pages(self, all_groups=0):
        """Invalidate HTML cache of pages which refer to this one."""

        # we changed default behavior to not scan all groups when invalidating.
        # this means that cross-group links for new pages after this change
        # will not be accurate, until the page(s) linking to the new page
        # is itself modified.

        refs = self.wiki.references_to(self, all_groups=all_groups)
        for p in refs:
            p.invalidate_html_cache()
        
    def latest_edit_by(self, user):
        """Return latest edit by user, or None."""
        rvers = self.versions[:]
        rvers.reverse()
        for version in rvers:
            if version.author is user:
                return version
        return None
        
    def get_comments(self):
        """Return list of comments (BlogItems)."""
        blog_item = self.blog.get_item(0)
        if blog_item:
            return blog_item.get_comments()
        else:
            return []
        
    def get_revision(self, rev_id):
        """Return revision index rev_id or None."""
        rev_id = max(0, rev_id)
        try:
            rev = self.versions[rev_id]
        except IndexError:
            rev = None
        return rev

    def revision_index(self, version):
        """Return revision index of version, or raise ValueError."""
        return self.versions.index(version)

    def merge_revisions(self, base, old, new):
        """Merge the newest revision with older revision, off of base. Returns (merged text, exit_code) or None.
        
        Base may be -1 to signify empty text.
        Exit code is 0 for no conflicts, or 1 if conflicts exist.
        """
        if len(self.versions) < 2:
            return None

        if base == -1:
            base_text = ''
        else:
            base_text = self.versions[base].get_raw()

        old_text = self.versions[old].get_raw()
        new_text = self.versions[new].get_raw()

        merger = Merger(base_text, old_text, new_text)
        merged = merger.merge('Revision %d' % base,
            'Revision %d' % old,
            'Revision %d' % new,
            )

        if not merged:
            return None

        exit_code = 0
        if merger.has_conflicts():
            exit_code = 1

        return (merged, exit_code)


    def watchable_name(self):
        #return self.wiki.group.name + ' ' + self.versions[-1].title
        return self.versions[-1].title or self.name
        
    def watchable_changed(self, now=None):
        # wiki changed, too
        Watchable.watchable_changed(self, now)
        self.wiki.watchable_changed(now)

    def watchable_modified_date(self):
        return self.watchable_last_change()
        
    def last_modified(self):
        sys.stderr.write('WARNING: using deprecated qon.wiki.WikiPage.last_modified.')
        return self.watchable_last_change()

    def who_has_lock(self):
        return self.locked_by_user

    def can_edit(self, user):
        """ A page is editable if either it's not locked by anybody,
        or if the requesting user is the one who holds the lock, or
        if the user is allowed to edit within the group"""
        
        # user must be logged in to edit
        if not user:
            return False
            
        # check lock
        if (self.locked_by_user) and (self.locked_by_user is not user) and (not self.can_manage(user)):
            return False
            
        if self.wiki.group.can_edit(user):
            return True
        
        return False
        
    def can_show(self):
        """Return False if this item should be suppressed due to feedback score."""
        if self.get_karma_score() < qon.karma.min_karma_to_show:
            return False
        return True
        

    def can_lock(self, user):
        """ For now, let only a group owner lock/unlock a page.
        In the future, we may want to consider allowing the original
        page author to lock/unlock as well."""
        return self.wiki.group.is_owner(user)

    def lock(self, user):
        if self.can_lock(user):
            self.locked_by_user = user

    def unlock(self, user):
        if self.can_lock(user):
            self.locked_by_user = None
            
    def can_get_karma_from(self, other):
        return other is not None
        
    # HTML cache methods
    
    def add_html_dependency(self, target):
        """Adds target as something self depends on for its HTML cache."""
        self.__cached_html.add_dependency(target)
        self.__cached_html2.add_dependency(target)
        
    def invalidate_html_cache(self):
        self.__cached_html.flush()
        self.__cached_html2.flush()
        
    def get_cached_html(self):
        return self.__cached_html.get()

    def get_cached_html2(self):
        return self.__cached_html2.get()

    def _update_html_cache(self):
        
        v = self.versions[-1]
        html = v.raw_to_html(v.get_raw())
        
        # take this opportunity to update the page's outbound references
        if hasattr(v, '_v_references'):
            self.set_outbound_references(v._v_references)
            del v._v_references
            
        return html

    def _update_html2_cache(self):
        
        v = self.versions[-1]
        html = v.raw_to_html(v.get_raw(), suppress_tooltip=1)
        
        return html

    def disable_cache(self):
        self.__cached_html.disable_cache()
        self.__cached_html2.disable_cache()

    def cache_disabled(self):
        return self.__cached_html.cache_disabled() or self.__cached_html2.cache_disabled()
  
    def get_ref(self):
        """Return a reference (group, page_name) to this page, for use in
        outbound/inbound references."""
        return (self.wiki.group, self.name)
            
    def set_outbound_references(self, new_out_refs):
        """Record new outbound references."""

        # filter non-existent cross-group page refs out of new_out_refs
        # this interacts with the change that no longer scans all groups
        # for references to new pages. if a cross-group link existed to a new
        # page, this method (pre-filtering) would have neglected to add the inbound
        # link from the cross-group reference, even if both pages had been edited.
        l = []
        for r in new_out_refs:
            group_name, page_name = r
            if not group_name:
                l.append(r)
            else:
                page = _ref_to_page(r, self.wiki.group)
                if page:
                    l.append(r)
        new_out_refs = l

        # get old outbound refs
        old_out_refs = self.outbound_references or []

        # get two lists: items that used to be outbound references but
        # are no longer (old_not_new), and new outbound references that
        # weren't there before (new_not_old)
        old_not_new, new_not_old = xor_lists(old_out_refs, new_out_refs)

        # pre-fill reference to me
        me_ref = self.get_ref()

        # invalidate inbound references of pages that we no longer refer to
        for ref in old_not_new:
            page = _ref_to_page(ref, self.wiki.group)
            if page:    # added by Alex
                page.remove_inbound_reference(me_ref)

        # add inbound references for pages we've added outbound links to
        for ref in new_not_old:
            page = _ref_to_page(ref, self.wiki.group)
            if page:    # could be ref to new page
                page.add_inbound_reference(me_ref)

        # record new outbound references
        self.outbound_references = PersistentList()
        self.outbound_references.extend(new_out_refs)

    def remove_inbound_reference(self, ref):
        if self.inbound_references is not None:
            if ref in self.inbound_references:
                self.inbound_references.remove(ref)

    def add_inbound_reference(self, ref):
        if self.inbound_references is not None:
            if ref not in self.inbound_references:
                self.inbound_references.append(ref)

    # IHasBlog methods not implemented by other base classes
    
    def can_manage(self, user):
        """Who can manage this blog? Group owners."""
        return self.wiki.group.is_owner(user)
        
    def can_read(self, user):
        return self.wiki.can_read(user)
        
    def can_delete_item(self, item):
        """Can't delete item 0, which holds page comments."""
        if self.blog.get_item(0) is item:
            return False
        return True
        
    def can_create_item(self):
        """Users aren't allowed to create new topics in wiki pages."""
        return False
    
    def is_accepted(self):
        return self.wiki.group.is_accepted()
    
    def get_owners(self):
        return self.wiki.group.get_owners()
    
    def is_owner(self, user):
        return self.wiki.group.is_owner(user)
        
    def get_title(self):
        # this is here and in BlogItem
        return self.versions[-1].title or self.name
    
    def get_blog(self):
        return self.blog
    
    def get_wiki(self):
        return self.wiki
    
    def get_name(self):
        return self.name
    
    def get_all_owners(self):
        return self.get_owners()
    
    def get_all_blogs(self):
        return [self.blog]
        
    def get_member_list(self):
        return self.wiki.group.get_member_list()
コード例 #4
0
ファイル: blog.py プロジェクト: mrmaple/open_qon
class BlogItem(QonPersistent, qon.karma.HasKarma, Watchable, HasComments):

    persistenceVersion = 6

    def __init__(self, blog, author, title, summary, main='', dont_watch=0):
        qon.karma.HasKarma.__init__(self)
        Watchable.__init__(self)
        HasComments.__init__(self)
        self.blog = blog
        self.__deleted = 0
        self.author = author
        self.title = title
        self.__summary = CompressedText(summary)
        if main:
            self.__main = CompressedText(main)
        else:
            self.__main = None
        self.__cached_html_summary = PersistentCache(self._update_html_cache)
        # history is a string, showing diffs as items are edited
        self.history = None
        self.date = datetime.utcnow()
        self.modified = None
        self.parent_blogitem = None     # for comment, will point to parent blogitem upon add_comment(); otherwise None
        
        if dont_watch:
            """Comments aren't watchable."""
            self.not_watchable = 1
        else:
            # for watchable items only (not comments)
            self.__user_access = ConflictAvoidingOOBTree()

    def upgradeToVersion6(self):
        self.history = None

    def upgradeToVersion5(self):
        self.title = iso_8859_to_utf_8(self.title)

    def upgradeToVersion4(self):
        self.__deleted = self.deleted
        del self.deleted

        # upgrade HasComments
        HasComments._upgradeToVersion1(self)

        # elim __main's CompressedText
        if not self.get_main():
            self.__main = None

        self.version_upgrade_done()        
        
    def upgradeToVersion3(self):
        if not self.not_watchable:
            self.__user_access = ConflictAvoidingOOBTree()

        # get rid of old Readers attribute
        if hasattr(self, '_BlogItem__readers'):
            del self.__readers
        
        self.version_upgrade_done()        
        
    def upgradeToVersion2(self):
        # do self.parent_blogitem 2005-03-17
        self.parent_blogitem = None        
        comments = HasComments.get_all_comments(self)
        for item in comments:
            item.parent_blogitem = self # point comments to point to itself
             
        self.version_upgrade_done()        
                
    def upgradeToVersion1(self):
    
        # compress text
        self.__summary = CompressedText(self.summary)
        self.__main = CompressedText(self.main)
        del self.summary
        del self.main
        
        # create cache
        self.__cached_html_summary = PersistentCache(self._update_html_cache)
        
        self.version_upgrade_done()
            
    def is_deleted(self, use_attr=False):
        if use_attr or not self.parent_blogitem:
            return self.__deleted

        return self.parent_blogitem.get_comment_flags(self)

    def set_deleted(self, val):
        self.__deleted = bool(val)

        # cache/copy deleted attribute into paren't comment_flags
        # for fast lookup to avoid db reading each comment
        if self.parent_blogitem:
            self.parent_blogitem.set_comment_flags(self, bool(val))

        # alex added so that recent items cache for parent blog gets marked as dirty
        self.watchable_changed()        

    def set_deleted_note(self, note):
        self._deleted_note = note

    def get_deleted_note(self):
        return getattr(self, '_deleted_note', None)

    def can_read(self, user):
        return self.blog.ihb.can_read(user)
    
    def can_edit(self, user):
        return (self.author is user) or self.can_manage(user)
    
    def can_delete(self, user):
        """Return True if user can delete this item."""
        
        # managers can always delete
        if self.can_manage(user):
            return True
            
        # authors can only delete if there are no undeleted comments
        if self.num_comments() == 0:
            return self.author is user
        
        return False
    
    def can_manage(self, user):
        """Return True if user can manage this item (usually a group owner)."""
        return self.blog.ihb and self.blog.ihb.can_manage(user)
        
    def can_show(self):
        """Return False if this item should be suppressed due to feedback score."""
        if self.get_karma_score() < qon.karma.min_karma_to_show:
            return False
        
        if self.author.get_karma_score() < qon.karma.min_author_karma:
            return False
        
        return True

    def why_cant_show(self):
        """Only really useful when can_show()==False.  Returns the reason for an item
        not being shown.  Return value is ('item' | 'user', fbscore)"""
        if self.get_karma_score() < qon.karma.min_karma_to_show:
            return ('item', self.get_karma_score())

        if self.author.get_karma_score() < qon.karma.min_author_karma:
            return ('user', self.author.get_karma_score())

        return ()
                            
    def last_modified(self, consider_comments=True):
        if consider_comments:
            # this Watchable changes whenever a comment is added
            dt = self.watchable_last_change()
            if dt is never:
                dt = self.modified or self.date
            return dt
        else:
            return self.modified or self.date
        
    def new_comment(self, author, title, summary, main=''):
        """Create a new comment item and return it."""
        comment = BlogItem(blog=self.blog,
            author=author,
            title=title,
            summary=summary,
            main=main,
            dont_watch=1)
        
        # Check to see if this new comment is a duplicate
        #  of the previous comment.  If so, ignore it, since
        #  it's probably unintended, and just return None.
        if HasComments.is_duplicate(self, comment):
            comment = None
        else:            
            self.add_comment(comment)

            # avoid 'bogus new to me'
            comment.read_item(author, datetime.utcnow())

            author.karma_activity_credit()
        return comment
        
    def notify_karma_changed(self):
        """Called by HasKarma.add_karma."""
        
        # also delegate to watchable_changed
        # self.watchable_changed() # removed by alex to keep blogitems from boldfacing when left feedback
        
        if self.blog and hasattr(self.blog, 'notify_karma_changed'):
            self.blog.notify_karma_changed()

    def add_comment(self, comment):
        comment.parent_blogitem = self        
        HasComments.add_comment(self, comment)
        self.watchable_changed(comment.date)
    
    def watchable_name(self):
        return self.title
    
    def watchable_changed(self, now=None):
        # tells blog he has changed, too
        Watchable.watchable_changed(self, now)
        if self.blog:
            self.blog.watchable_changed(now)

    def watchable_modified_date(self):
        return self.last_modified()

    def can_get_karma_from(self, other):
        return other is not self.author
        
    def get_summary(self):
        return self.__summary.get_raw()
        
    def set_summary(self, raw):
        self._log_summary_change()
        self.__summary.set_raw(raw)
        self.invalidate_html_cache()
        
    def get_main(self):
        if not self.__main:
            return ''
        return self.__main.get_raw()
        
    def set_main(self, raw):
        if not self.__main:
            self.__main = CompressedText()
        self.__main.set_raw(raw)
    
    def _log_summary_change(self):
        import qon.log
        if hasattr(self.blog.ihb, 'get_user_id'):
            qon.log.edit_info('SetSummary\t%s\n%s' % (self.blog.ihb.get_user_id(), self.get_summary()))
        else:
            qon.log.edit_info('SetSummary2\t%s\n%s' % (self.blog.ihb.get_name(), self.get_summary()))

    # HTML cache methods
        
    def add_html_dependency(self, target):
        """Adds target as something self depends on for its HTML cache."""
        self.__cached_html_summary.add_dependency(target)

    def invalidate_html_cache(self):
        self.__cached_html_summary.flush()
        
    def get_cached_html(self):
        return self.__cached_html_summary.get().get_raw()

    def _update_html_cache(self):
        from qon.ui.blocks.wiki import rst_to_html
        return CompressedText(str(rst_to_html(self.get_summary(),
            wiki=self.blog.ihb.get_wiki(),
            container=self)))

    def disable_cache(self):
        self.__cached_html_summary.disable_cache()

    def cache_disabled(self):
        return self.__cached_html_summary.cache_disabled()
    
    def read_item(self, user, now=None):
        """Notice that user has accessed this item.
        
        If we are a comment, we pass this on to our parent item, to
        catch up based on comment's submission date.
        """

        if not hasattr(self, "_BlogItem__user_access"):

            # we don't keep track of user access -- we're a comment,
            # so just pass this on to our parent.
            if self.parent_blogitem:
                return self.parent_blogitem.read_item(user, self.date)
            return
        
        if not user:
            return
            
        now = now or datetime.utcnow()
        user_oid = unpack_oid(user._p_oid)
        
        dt, count = self.__user_access.get(user_oid, (never, 0))
        now = max(now, dt)
        
        # increment hit count
        self.__user_access[user_oid] = (now, count + 1)

    def has_read_item(self, user, updated=None):
        if not hasattr(self, "_BlogItem__user_access"):
            return False
        
        if not user:
            return True
        
        dt, count = self._get_user_access(user)
        if count == 0:
            return False
        
        if updated:
            return dt >= updated
        else:
            return True
    
    def last_read(self, user):
        """Return datetime when user last read this item."""
        dt, count = self._get_user_access(user)
        return dt
    
    def _get_user_access(self, user):
        if not hasattr(self, "_BlogItem__user_access"):
            return (never, 0)
            
        user_oid = unpack_oid(user._p_oid)
        return self.__user_access.get(user_oid, (never, 0))
    
    def item_views(self):
        """Returns (number of views, number of readers).""" 
        
        views = 0
        readers = 0
        for user_oid, (dt, count) in self.__user_access.iteritems():
            if count > 0:   # alex added if on 2006-10-09
                readers += 1
                views += count
        
        return (views, readers)
 
    def get_pageview_counts_per_user(self):
        """return a list of (user, counts)"""
        return_list = []
        for user_oid, (dt, count) in self.__user_access.iteritems():
            if count > 0:
                return_list.append((get_oid(pack_oid(user_oid)), count))
        return return_list
            
    def get_title(self):
        # this is here and in WikiPage
        return self.title