Python Subreddit._byID方法代码示例

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
    def subreddit_slow(self):
        from subreddit import Subreddit

        """return's a link's subreddit. in most case the subreddit is already
        on the wrapped link (as .subreddit), and that should be used
        when possible. """
        return Subreddit._byID(self.sr_id, True, return_dict=False)

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
    def add_props(cls, user, wrapped):
        #fetch parent links
        links = Link._byID(set(l.link_id for l in wrapped), True)
        

        #get srs for comments that don't have them (old comments)
        for cm in wrapped:
            if not hasattr(cm, 'sr_id'):
                cm.sr_id = links[cm.link_id].sr_id
        
        subreddits = Subreddit._byID(set(cm.sr_id for cm in wrapped),
                                     data=True,return_dict=False)
        can_reply_srs = set(s._id for s in subreddits if s.can_comment(user))

        min_score = c.user.pref_min_comment_score

        cids = dict((w._id, w) for w in wrapped)

        for item in wrapped:
            item.link = links.get(item.link_id)
            if not hasattr(item, 'subreddit'):
                item.subreddit = item.subreddit_slow
            if hasattr(item, 'parent_id'):
                parent = Comment._byID(item.parent_id, data=True)
                parent_author = Account._byID(parent.author_id, data=True)
                item.parent_author = parent_author

                if not c.full_comment_listing and cids.has_key(item.parent_id):
                    item.parent_permalink = '#' + utils.to36(item.parent_id)
                else:
                    item.parent_permalink = parent.make_anchored_permalink(item.link, item.subreddit)
            else:
                item.parent_permalink = None
                item.parent_author = None

            item.can_reply = (item.sr_id in can_reply_srs)

            # Don't allow users to vote on their own comments
            item.votable = bool(c.user != item.author)

            # not deleted on profile pages,
            # deleted if spam and not author or admin
            item.deleted = (not c.profilepage and
                           (item._deleted or
                            (item._spam and
                             item.author != c.user and
                             not item.show_spam)))

            # don't collapse for admins, on profile pages, or if deleted
            item.collapsed = ((item.score < min_score) and
                             not (c.profilepage or
                                  item.deleted or
                                  c.user_is_admin))
                
            if not hasattr(item,'editted'):
                item.editted = False
            #will get updated in builder
            item.num_children = 0
            item.score_fmt = Score.points
            item.permalink = item.make_permalink(item.link, item.subreddit)

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
 def can_submit(self, user):
     if c.user_is_admin:
         return True
     elif self.author_id == c.user._id:
         # They can submit if they are the author and still have access
         # to the subreddit of the article
         sr = Subreddit._byID(self.sr_id, data=True)
         return sr.can_submit(user)
     else:
         return False

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
    def subreddit_slow(self):
        from subreddit import Subreddit
        """return's a comments's subreddit. in most case the subreddit is already
        on the wrapped link (as .subreddit), and that should be used
        when possible. if sr_id does not exist, then use the parent link's"""
        self._safe_load()

        if hasattr(self, 'sr_id'):
            sr_id = self.sr_id
        else:
            l = Link._byID(self.link_id, True)
            sr_id = l.sr_id
        return Subreddit._byID(sr_id, True, return_dict = False)

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
 def can_view_slow(self):
     if c.user_is_loggedin:
         # simple case from before:
         if (c.user_is_admin or c.user._id in (self.author_id, self.to_id)):
             return True
         elif self.sr_id:
             sr = Subreddit._byID(self.sr_id)
             is_moderator = sr.is_moderator(c.user)
             # moderators can view messages on subreddits they moderate
             if is_moderator:
                 return True
             elif self.first_message:
                 first = Message._byID(self.first_message, True)
                 return (first.author_id == c.user._id)

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
    def add_props(cls, user, wrapped):
        #TODO global-ish functions that shouldn't be here?
        #reset msgtime after this request
        msgtime = c.have_messages
        
        #load the "to" field if required
        to_ids = set(w.to_id for w in wrapped)
        tos = Account._byID(to_ids, True) if to_ids else {}
        links = Link._byID(set(l.link_id for l in wrapped if l.was_comment),
                           data = True,
                           return_dict = True)
        subreddits = Subreddit._byID(set(l.sr_id for l in links.values()),
                                     data = True, return_dict = True)
        parents = Comment._byID(set(l.parent_id for l in wrapped
                                  if hasattr(l, "parent_id") and l.was_comment),
                                data = True, return_dict = True)

        for item in wrapped:
            item.to = tos[item.to_id]
            if msgtime and item._date >= msgtime:
                item.new = True
            else:
                item.new = False
            item.score_fmt = Score.none

            item.message_style = ""
            if item.was_comment:
                link = links[item.link_id]
                sr = subreddits[link.sr_id]
                item.link_title = link.title
                item.link_permalink = link.make_permalink(sr)
                if hasattr(item, "parent_id"):
                    item.subject = _('comment reply')
                    item.message_style = "comment-reply"
                    parent = parents[item.parent_id]
                    item.parent = parent._fullname
                    item.parent_permalink = parent.make_permalink(link, sr)
                else:
                    item.subject = _('post reply')
                    item.message_style = "post-reply"

        # Run this last
        Printable.add_props(user, wrapped)

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
    def add_props(cls, user, wrapped):
        from r2.lib.db import queries
        #TODO global-ish functions that shouldn't be here?
        #reset msgtime after this request
        msgtime = c.have_messages

        # make sure there is a sr_id set:
        for w in wrapped:
            if not hasattr(w, "sr_id"):
                w.sr_id = None

        # load the to fields if one exists
        to_ids = set(w.to_id for w in wrapped if w.to_id is not None)
        tos = Account._byID(to_ids, True) if to_ids else {}

        # load the subreddit field if one exists:
        sr_ids = set(w.sr_id for w in wrapped if w.sr_id is not None)
        m_subreddits = Subreddit._byID(sr_ids, data=True, return_dict=True)

        # load the links and their subreddits (if comment-as-message)
        links = Link._byID(
            set(l.link_id for l in wrapped if l.was_comment),
            data=True,
            return_dict=True)
        # subreddits of the links (for comment-as-message)
        l_subreddits = Subreddit._byID(
            set(l.sr_id for l in links.values()), data=True, return_dict=True)

        parents = Comment._byID(
            set(l.parent_id for l in wrapped if l.parent_id and l.was_comment),
            data=True,
            return_dict=True)

        # load the unread list to determine message newness
        unread = set(queries.get_unread_inbox(user))

        msg_srs = set(
            m_subreddits[x.sr_id] for x in wrapped
            if x.sr_id is not None and isinstance(x.lookups[0], Message))
        # load the unread mod list for the same reason
        mod_unread = set(
            queries.merge_results(
                *[queries.get_unread_subreddit_messages(sr)
                  for sr in msg_srs]))

        for item in wrapped:
            item.to = tos.get(item.to_id)
            if item.sr_id:
                item.recipient = (item.author_id != c.user._id)
            else:
                item.recipient = (item.to_id == c.user._id)

            # new-ness is stored on the relation
            if item.author_id == c.user._id:
                item.new = False
            elif item._fullname in unread:
                item.new = True
                # wipe new messages if preferences say so, and this isn't a feed
                # and it is in the user's personal inbox
                if (item.new and c.user.pref_mark_messages_read
                        and c.extension not in ("rss", "xml", "api", "json")):
                    queries.set_unread(item.lookups[0], c.user, False)
            else:
                item.new = (item._fullname in mod_unread)

            item.score_fmt = Score.none

            item.message_style = ""
            # comment as message:
            if item.was_comment:
                link = links[item.link_id]
                sr = l_subreddits[link.sr_id]
                item.to_collapse = False
                item.author_collapse = False
                item.link_title = link.title
                item.permalink = item.lookups[0].make_permalink(link, sr=sr)
                item.link_permalink = link.make_permalink(sr)
                if item.parent_id:
                    item.subject = _('comment reply')
                    item.message_style = "comment-reply"
                    parent = parents[item.parent_id]
                    item.parent = parent._fullname
                    item.parent_permalink = parent.make_permalink(link, sr)
                else:
                    item.subject = _('post reply')
                    item.message_style = "post-reply"
            elif item.sr_id is not None:
                item.subreddit = m_subreddits[item.sr_id]

            if c.user.pref_no_profanity:
                item.subject = profanity_filter(item.subject)

            item.is_collapsed = None
            if not item.new:
                if item.recipient:
                    item.is_collapsed = item.to_collapse
                if item.author_id == c.user._id:
                    item.is_collapsed = item.author_collapse
                if c.user.pref_collapse_read_messages:
                    item.is_collapsed = (item.is_collapsed is not False)
#.........这里部分代码省略.........

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
    def _new(cls, author, to, subject, body, ip, parent=None, sr=None):
        m = Message(
            subject=subject, body=body, author_id=author._id, new=True, ip=ip)
        m._spam = author._spam
        sr_id = None
        # check to see if the recipient is a subreddit and swap args accordingly
        if to and isinstance(to, Subreddit):
            to_subreddit = True
            to, sr = None, to
        else:
            to_subreddit = False

        if sr:
            sr_id = sr._id
        if parent:
            m.parent_id = parent._id
            if parent.first_message:
                m.first_message = parent.first_message
            else:
                m.first_message = parent._id
            if parent.sr_id:
                sr_id = parent.sr_id

        if not to and not sr_id:
            raise CreationError, "Message created with neither to nor sr_id"

        m.to_id = to._id if to else None
        if sr_id is not None:
            m.sr_id = sr_id

        m._commit()

        inbox_rel = None
        if sr_id and not sr:
            sr = Subreddit._byID(sr_id)

        inbox_rel = []
        if sr_id:
            # if there is a subreddit id, and it's either a reply or
            # an initial message to an SR, add to the moderator inbox
            # (i.e., don't do it for automated messages from the SR)
            if parent or to_subreddit:
                inbox_rel.append(ModeratorInbox._add(sr, m, 'inbox'))
            if author.name in g.admins:
                m.distinguished = 'admin'
                m._commit()
            elif sr.is_moderator(author):
                m.distinguished = 'yes'
                m._commit()

        # if there is a "to" we may have to create an inbox relation as well
        # also, only global admins can be message spammed.
        if to and (not m._spam or to.name in g.admins):
            # if the current "to" is not a sr moderator,
            # they need to be notified
            if not sr_id or not sr.is_moderator(to):
                inbox_rel.append(Inbox._add(to, m, 'inbox'))
            # find the message originator
            elif sr_id and m.first_message:
                first = Message._byID(m.first_message, True)
                orig = Account._byID(first.author_id, True)
                # if the originator is not a moderator...
                if not sr.is_moderator(orig) and orig._id != author._id:
                    inbox_rel.append(Inbox._add(orig, m, 'inbox'))
        return (m, inbox_rel)

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
    def _new(cls, author, to, subject, body, ip, parent=None, sr=None,
             from_sr=False):
        m = Message(subject=subject, body=body, author_id=author._id, new=True,
                    ip=ip, from_sr=from_sr)
        m._spam = author._spam

        if author._spam:
            g.stats.simple_event('spam.autoremove.message')

        sr_id = None
        # check to see if the recipient is a subreddit and swap args accordingly
        if to and isinstance(to, Subreddit):
            if from_sr:
                raise CreationError("Cannot send from SR to SR")
            to_subreddit = True
            to, sr = None, to
        else:
            to_subreddit = False

        if sr:
            sr_id = sr._id
        if parent:
            m.parent_id = parent._id
            if parent.first_message:
                m.first_message = parent.first_message
            else:
                m.first_message = parent._id
            if parent.sr_id:
                sr_id = parent.sr_id

        if not to and not sr_id:
            raise CreationError("Message created with neither to nor sr_id")
        if from_sr and not sr_id:
            raise CreationError("Message sent from_sr without setting sr")

        m.to_id = to._id if to else None
        if sr_id is not None:
            m.sr_id = sr_id

        m._commit()

        if sr_id and not sr:
            sr = Subreddit._byID(sr_id)

        inbox_rel = []
        if sr_id:
            # if there is a subreddit id, and it's either a reply or
            # an initial message to an SR, add to the moderator inbox
            # (i.e., don't do it for automated messages from the SR)
            if parent or to_subreddit and not from_sr:
                inbox_rel.append(ModeratorInbox._add(sr, m, 'inbox'))
            if author.name in g.admins:
                m.distinguished = 'admin'
                m._commit()
            elif sr.is_moderator(author):
                m.distinguished = 'yes'
                m._commit()

        # if there is a "to" we may have to create an inbox relation as well
        # also, only global admins can be message spammed.
        if to and (not m._spam or to.name in g.admins):
            # if the current "to" is not a sr moderator,
            # they need to be notified
            if not sr_id or not sr.is_moderator(to):
                # Record the inbox relation, but don't give the user
                # an orangered, if they PM themselves.
                # Don't notify on PMs from blocked users, either
                orangered = (to.name != author.name and
                             author._id not in to.enemies)
                inbox_rel.append(Inbox._add(to, m, 'inbox',
                                            orangered=orangered))
            # find the message originator
            elif sr_id and m.first_message:
                first = Message._byID(m.first_message, True)
                orig = Account._byID(first.author_id, True)
                # if the originator is not a moderator...
                if not sr.is_moderator(orig) and orig._id != author._id:
                    inbox_rel.append(Inbox._add(orig, m, 'inbox'))
        return (m, inbox_rel)

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
    def add_props(cls, user, wrapped):
        from r2.lib.template_helpers import add_attr, get_domain
        from r2.lib import promote
        from r2.lib.wrapped import CachedVariable
        from r2.lib.pages import WrappedUser

        #fetch parent links
        links = Link._byID(set(l.link_id for l in wrapped), data = True,
                           return_dict = True, stale=True)

        # fetch authors
        authors = Account._byID(set(l.author_id for l in links.values()), data=True, 
                                return_dict=True, stale=True)

        #get srs for comments that don't have them (old comments)
        for cm in wrapped:
            if not hasattr(cm, 'sr_id'):
                cm.sr_id = links[cm.link_id].sr_id

        subreddits = Subreddit._byID(set(cm.sr_id for cm in wrapped),
                                     data=True, return_dict=False, stale=True)
        cids = dict((w._id, w) for w in wrapped)
        parent_ids = set(cm.parent_id for cm in wrapped
                         if getattr(cm, 'parent_id', None)
                         and cm.parent_id not in cids)
        parents = {}
        if parent_ids:
            parents = Comment._byID(parent_ids, data=True, stale=True)

        can_reply_srs = set(s._id for s in subreddits if s.can_comment(user)) \
                        if c.user_is_loggedin else set()
        can_reply_srs.add(promote.get_promote_srid())

        min_score = user.pref_min_comment_score

        profilepage = c.profilepage
        user_is_admin = c.user_is_admin
        user_is_loggedin = c.user_is_loggedin
        focal_comment = c.focal_comment
        cname = c.cname
        site = c.site

        for item in wrapped:
            # for caching:
            item.profilepage = c.profilepage
            item.link = links.get(item.link_id)

            if (item.link._score <= 1 or item.score < 3 or
                item.link._spam or item._spam or item.author._spam):
                item.nofollow = True
            else:
                item.nofollow = False

            if not hasattr(item, 'subreddit'):
                item.subreddit = item.subreddit_slow
            if item.author_id == item.link.author_id and not item.link._deleted:
                add_attr(item.attribs, 'S',
                         link = item.link.make_permalink(item.subreddit))
            if not hasattr(item, 'target'):
                item.target = "_top" if cname else None
            if item.parent_id:
                if item.parent_id in cids:
                    item.parent_permalink = '#' + utils.to36(item.parent_id)
                else:
                    parent = parents[item.parent_id]
                    item.parent_permalink = parent.make_permalink(item.link, item.subreddit)
            else:
                item.parent_permalink = None

            item.can_reply = False
            if c.can_reply or (item.sr_id in can_reply_srs):
                age = datetime.now(g.tz) - item._date
                if age.days < g.REPLY_AGE_LIMIT:
                    item.can_reply = True


            # not deleted on profile pages,
            # deleted if spam and not author or admin
            item.deleted = (not profilepage and
                           (item._deleted or
                            (item._spam and
                             item.author != user and
                             not item.show_spam)))

            extra_css = ''
            if item.deleted:
                extra_css += "grayed"
                if not user_is_admin:
                    item.author = DeletedUser()
                    item.body = '[deleted]'


            if focal_comment == item._id36:
                extra_css += " border"

            if profilepage:
                item.link_author = WrappedUser(authors[item.link.author_id])

                item.subreddit_path = item.subreddit.path
                if cname:
#.........这里部分代码省略.........

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
    def add_props(cls, user, wrapped):
        from r2.lib.db import queries
        #TODO global-ish functions that shouldn't be here?
        #reset msgtime after this request
        msgtime = c.have_messages

        # make sure there is a sr_id set:
        for w in wrapped:
            if not hasattr(w, "sr_id"):
                w.sr_id = None

        # load the to fields if one exists
        to_ids = set(w.to_id for w in wrapped if w.to_id is not None)
        tos = Account._byID(to_ids, True) if to_ids else {}

        # load the subreddit field if one exists:
        sr_ids = set(w.sr_id for w in wrapped if w.sr_id is not None)
        m_subreddits = Subreddit._byID(sr_ids, data = True, return_dict = True)

        # load the links and their subreddits (if comment-as-message)
        links = Link._byID(set(l.link_id for l in wrapped if l.was_comment),
                           data = True,
                           return_dict = True)
        # subreddits of the links (for comment-as-message)
        l_subreddits = Subreddit._byID(set(l.sr_id for l in links.values()),
                                       data = True, return_dict = True)

        parents = Comment._byID(set(l.parent_id for l in wrapped
                                  if l.parent_id and l.was_comment),
                                data = True, return_dict = True)

        # load the unread list to determine message newness
        unread = set(queries.get_unread_inbox(user))

        msg_srs = set(m_subreddits[x.sr_id]
                      for x in wrapped if x.sr_id is not None
                      and isinstance(x.lookups[0], Message))
        # load the unread mod list for the same reason
        mod_unread = set(queries.get_unread_subreddit_messages_multi(msg_srs))

        for item in wrapped:
            item.to = tos.get(item.to_id)
            if item.sr_id:
                item.recipient = (item.author_id != c.user._id)
            else:
                item.recipient = (item.to_id == c.user._id)
            
            # new-ness is stored on the relation
            if item.author_id == c.user._id:
                item.new = False
            elif item._fullname in unread:
                item.new = True
                # wipe new messages if preferences say so, and this isn't a feed
                # and it is in the user's personal inbox
                if (item.new and c.user.pref_mark_messages_read
                    and c.extension not in ("rss", "xml", "api", "json")):
                    queries.set_unread(item.lookups[0],
                                       c.user, False)
            else:
                item.new = (item._fullname in mod_unread and not item.to_id)

            item.score_fmt = Score.none

            item.message_style = ""
            # comment as message:
            if item.was_comment:
                link = links[item.link_id]
                sr = l_subreddits[link.sr_id]
                item.to_collapse = False
                item.author_collapse = False
                item.link_title = link.title
                item.permalink = item.lookups[0].make_permalink(link, sr=sr)
                item.link_permalink = link.make_permalink(sr)
                if item.parent_id:
                    item.subject = _('comment reply')
                    item.message_style = "comment-reply"
                    parent = parents[item.parent_id]
                    item.parent = parent._fullname
                    item.parent_permalink = parent.make_permalink(link, sr)
                else:
                    item.subject = _('post reply')
                    item.message_style = "post-reply"
            elif item.sr_id is not None:
                item.subreddit = m_subreddits[item.sr_id]
            
            item.hide_author = False
            if getattr(item, "from_sr", False):
                if not (item.subreddit.is_moderator(c.user) or
                        c.user_is_admin):
                    item.author = item.subreddit
                    item.hide_author = True
            
            item.is_collapsed = None
            if not item.new:
                if item.recipient:
                    item.is_collapsed = item.to_collapse
                if item.author_id == c.user._id:
                    item.is_collapsed = item.author_collapse
                if c.user.pref_collapse_read_messages:
                    item.is_collapsed = (item.is_collapsed is not False)
#.........这里部分代码省略.........

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
    def add_props(cls, user, wrapped):
        from r2.lib.db import queries

        # TODO global-ish functions that shouldn't be here?
        # reset msgtime after this request
        msgtime = c.have_messages

        # make sure there is a sr_id set:
        for w in wrapped:
            if not hasattr(w, "sr_id"):
                w.sr_id = None

        # load the to fields if one exists
        to_ids = set(w.to_id for w in wrapped if w.to_id is not None)
        tos = Account._byID(to_ids, True) if to_ids else {}

        # load the subreddit field if one exists:
        sr_ids = set(w.sr_id for w in wrapped if w.sr_id is not None)
        m_subreddits = Subreddit._byID(sr_ids, data=True, return_dict=True)

        # load the links and their subreddits (if comment-as-message)
        links = Link._byID(set(l.link_id for l in wrapped if l.was_comment), data=True, return_dict=True)
        # subreddits of the links (for comment-as-message)
        l_subreddits = Subreddit._byID(set(l.sr_id for l in links.values()), data=True, return_dict=True)

        parents = Comment._byID(
            set(l.parent_id for l in wrapped if l.parent_id and l.was_comment), data=True, return_dict=True
        )

        # load the inbox relations for the messages to determine new-ness
        # TODO: query cache?
        inbox = Inbox._fast_query(c.user, [item.lookups[0] for item in wrapped], ["inbox", "selfreply"])

        # we don't care about the username or the rel name
        inbox = dict((m._fullname, v) for (u, m, n), v in inbox.iteritems() if v)

        msgs = filter(lambda x: isinstance(x.lookups[0], Message), wrapped)

        modinbox = ModeratorInbox._fast_query(m_subreddits.values(), msgs, ["inbox"])

        # best to not have to eager_load the things
        def make_message_fullname(mid):
            return "t%s_%s" % (utils.to36(Message._type_id), utils.to36(mid))

        modinbox = dict((make_message_fullname(v._thing2_id), v) for (u, m, n), v in modinbox.iteritems() if v)

        for item in wrapped:
            item.to = tos.get(item.to_id)
            if item.sr_id:
                item.recipient = item.author_id != c.user._id
            else:
                item.recipient = item.to_id == c.user._id

            # new-ness is stored on the relation
            if item.author_id == c.user._id:
                item.new = False
            elif item._fullname in inbox:
                item.new = getattr(inbox[item._fullname], "new", False)
                # wipe new messages if preferences say so, and this isn't a feed
                # and it is in the user's personal inbox
                if item.new and c.user.pref_mark_messages_read and c.extension not in ("rss", "xml", "api", "json"):
                    queries.set_unread(inbox[item._fullname]._thing2, c.user, False)
            elif item._fullname in modinbox:
                item.new = getattr(modinbox[item._fullname], "new", False)
            else:
                item.new = False

            item.score_fmt = Score.none

            item.message_style = ""
            # comment as message:
            if item.was_comment:
                link = links[item.link_id]
                sr = l_subreddits[link.sr_id]
                item.to_collapse = False
                item.author_collapse = False
                item.link_title = link.title
                item.link_permalink = link.make_permalink(sr)
                if item.parent_id:
                    item.subject = _("comment reply")
                    item.message_style = "comment-reply"
                    parent = parents[item.parent_id]
                    item.parent = parent._fullname
                    item.parent_permalink = parent.make_permalink(link, sr)
                else:
                    item.subject = _("post reply")
                    item.message_style = "post-reply"
            elif item.sr_id is not None:
                item.subreddit = m_subreddits[item.sr_id]

            if c.user.pref_no_profanity:
                item.subject = profanity_filter(item.subject)

            item.is_collapsed = None
            if not item.new:
                if item.recipient:
                    item.is_collapsed = item.to_collapse
                if item.author_id == c.user._id:
                    item.is_collapsed = item.author_collapse
                if c.user.pref_collapse_read_messages:
#.........这里部分代码省略.........

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
def deleted_account_cleanup(data):
    from r2.models import Subreddit
    from r2.models.admin_notes import AdminNotesBySystem
    from r2.models.flair import Flair
    from r2.models.token import OAuth2Client

    for account_id36 in data.itervalues():
        account = Account._byID36(account_id36, data=True)

        if not account._deleted:
            continue

        # wipe the account's password and email address
        account.password = ""
        account.email = ""
        account.email_verified = False

        notes = ""

        # "noisy" rel removals, we'll record all of these in the account's
        # usernotes in case we need the information later
        rel_removal_descriptions = {
            "moderator": "Unmodded",
            "moderator_invite": "Cancelled mod invite",
            "contributor": "Removed as contributor",
            "banned": "Unbanned",
            "wikibanned": "Un-wikibanned",
            "wikicontributor": "Removed as wiki contributor",
        }
        if account.has_subscribed:
            rel_removal_descriptions["subscriber"] = "Unsubscribed"

        for rel_type, description in rel_removal_descriptions.iteritems():
            try:
                ids_fn = getattr(Subreddit, "reverse_%s_ids" % rel_type)
                sr_ids = ids_fn(account)

                sr_names = []
                srs = Subreddit._byID(sr_ids, data=True, return_dict=False)
                for subreddit in srs:
                    remove_fn = getattr(subreddit, "remove_" + rel_type)
                    remove_fn(account)
                    sr_names.append(subreddit.name)

                if description and sr_names:
                    sr_list = ", ".join(sr_names)
                    notes += "* %s from %s\n" % (description, sr_list)
            except Exception as e:
                notes += "* Error cleaning up %s rels: %s\n" % (rel_type, e)

        # silent rel removals, no record left in the usernotes
        rel_classes = {
            "flair": Flair,
            "friend": Friend,
            "enemy": Friend,
        }

        for rel_name, rel_cls in rel_classes.iteritems():
            try:
                rels = rel_cls._query(
                    rel_cls.c._thing2_id == account._id,
                    rel_cls.c._name == rel_name,
                    eager_load=True,
                )
                for rel in rels:
                    remove_fn = getattr(rel._thing1, "remove_" + rel_name)
                    remove_fn(account)
            except Exception as e:
                notes += "* Error cleaning up %s rels: %s\n" % (rel_name, e)

        # add the note with info about the major changes to the account
        if notes:
            AdminNotesBySystem.add(
                system_name="user",
                subject=account.name,
                note="Account deletion cleanup summary:\n\n%s" % notes,
                author="<automated>",
                when=datetime.now(g.tz),
            )

        account._commit()

# 需要导入模块: from subreddit import Subreddit [as 别名]
# 或者: from subreddit.Subreddit import _byID [as 别名]
    def add_props(cls, user, wrapped):
        #fetch parent links
        links = Link._byID(set(l.link_id for l in wrapped), True)


        #get srs for comments that don't have them (old comments)
        for cm in wrapped:
            if not hasattr(cm, 'sr_id'):
                cm.sr_id = links[cm.link_id].sr_id

        subreddits = Subreddit._byID(set(cm.sr_id for cm in wrapped),
                                     data=True,return_dict=False)
        can_reply_srs = set(s._id for s in subreddits if s.can_comment(user))

        if c.user_is_loggedin:
            min_score = c.user.pref_min_comment_score
        else:
            min_score = g.default_min_comment_score

        cids = dict((w._id, w) for w in wrapped)

        for item in wrapped:
            item.link = links.get(item.link_id)
            if not hasattr(item, 'subreddit'):
                item.subreddit = item.subreddit_slow
            if hasattr(item, 'parent_id'):
                parent = Comment._byID(item.parent_id, data=True)
                parent_author = Account._byID(parent.author_id, data=True)
                item.parent_author = parent_author

                if not c.full_comment_listing and cids.has_key(item.parent_id):
                    item.parent_permalink = '#' + utils.to36(item.parent_id)
                else:
                    item.parent_permalink = parent.make_anchored_permalink(item.link, item.subreddit)
            else:
                item.parent_permalink = None
                item.parent_author = None

            item.can_reply = (item.sr_id in can_reply_srs)

            # Don't allow users to vote on their own comments
            # Also require user karma to be >= global threshold as anti-sockpuppet measure
            item.votable = bool(c.user_is_loggedin
                                and c.user != item.author
                                and not item.retracted
                                and c.user.safe_karma >= g.karma_to_vote)

            if item.votable and c.profilepage:
                # Can only vote on profile page under certain conditions
                item.votable = bool((c.user.safe_karma > g.karma_to_vote_in_overview) and (g.karma_percentage_to_be_voted > item.author.percent_up()))

            # not deleted on profile pages,
            # deleted if spam and not author or admin
            item.deleted = (not c.profilepage and
                           (item._deleted or
                            (item._spam and
                             item.author != c.user and
                             not item.show_spam)))

            # don't collapse for admins, on profile pages, or if deleted
            item.collapsed = ((item.score < min_score) and
                             not (c.profilepage or
                                  item.deleted or
                                  c.user_is_admin))

            if not hasattr(item,'editted'):
                item.editted = False
            #will get updated in builder
            item.num_children = 0
            item.score_fmt = Score.points
            item.permalink = item.make_permalink(item.link, item.subreddit)
            item.can_be_deleted = item.can_delete()