예제 #1
0
 def delete_model(self):
     ret = super(ActivityComment, self).delete_model()
     if ret:
         key = self.ACTIVITY_COMMENT_IDS % ({'aid': str(self.activity)})
         try:
             Redis.zrem(key, str(self._id))
         except exceptions.ResponseError:
             Redis.delete(key)
     return ret
예제 #2
0
    def delete_model(self):
        ret = super(UserPopularGame, self).delete_model()
        if ret:
            key = self.POP_GAME_IDS % ({'uid': str(self.source)})
            try:
                Redis.zrem(key, str(self.target))
            except exceptions.ResponseError:
                Redis.delete(key)

        return ret
예제 #3
0
    def delete_model(self):
        ret = super(DaTangVideo, self).delete_model()
        if ret:
            key = self.USER_GAME_VIDEO_IDS % ({'uid': str(self.author), 'gid': str(self.game)})
            try:
                Redis.zrem(key, str(self._id))
            except exceptions.ResponseError:
                Redis.delete(key)

        return ret
예제 #4
0
    def delete_model(self):
        ret = super(Comment, self).delete_model()
        if ret:
            # 更新视频评论数
            from wanx.models.video import Video
            video = Video.get_one(str(self.video), check_online=False)
            video.update_model({'$inc': {'comment_count': -1}})

            key = self.VIDEO_COMMENT_IDS % ({'vid': str(self.video)})
            try:
                Redis.zrem(key, str(self._id))
            except exceptions.ResponseError:
                Redis.delete(key)
            # 删除全部回复
            Reply.delete_comment_replies(str(self._id))
        return ret
예제 #5
0
    def delete_model(self):
        ret = super(Reply, self).delete_model()
        self.collection.update({"reply": self._id}, {"$set": {"reply": None}})
        if ret:
            # 更新评论回复数
            comment = Comment.get_one(str(self.comment), check_online=False)
            comment.update_model({'$inc': {'reply': -1}})
            # 更新回复的回复数
            if self.reply:
                _reply = Reply.get_one(str(self.reply), check_online=False)
                _reply.update_model({'$inc': {'reply_count': -1}})

            key = self.COMMENT_REPLY_IDS % ({'cid': str(self.comment)})
            try:
                Redis.zrem(key, str(self._id))
            except exceptions.ResponseError:
                Redis.delete(key)
        return ret
예제 #6
0
    def delete_model(self):
        ret = super(UserSubGame, self).delete_model()
        if ret:
            # 更新游戏订阅人数
            game = Game.get_one(str(self.target), check_online=False)
            game.update_model({'$inc': {'sub_count': -1}})

            # 更新用户订阅游戏数量
            from wanx.models.user import User
            user = User.get_one(str(self.source), check_online=False)
            user.update_model({'$inc': {'subscription_count': -1}})

            key = self.SUB_GAME_IDS % ({'uid': str(self.source)})
            try:
                Redis.zrem(key, str(self.target))
            except exceptions.ResponseError:
                Redis.delete(key)

        return ret
예제 #7
0
    def delete_model(self):
        ret = super(ActivityVideo, self).delete_model()
        if ret:
            key = self.LATEST_VIDEO_IDS % ({'aid': str(self.activity_id)})
            try:
                Redis.zrem(key, str(self._id))
            except exceptions.ResponseError:
                Redis.delete(key)

            Redis.delete(self.TOP_COMPETE_VIDEO_IDS % ({'aid': str(self.activity_id)}))

            Redis.delete(self.TOP_VIDEO_END % ({'aid': str(self.activity_id)}))
            Redis.delete(self.TOP_MANUAL_TOP % ({'aid': str(self.activity_id)}))
            from wanx.models.video import Video
            video = Video.get_one(str(self.video_id))
            if video:
                video.update_model({'$set': {'activity_ids': []}})
            # 删除所有投票
            vote_ids = VoteVideo.get_by_target(self.video_id)
            for _id in vote_ids:
                vote = VoteVideo.get_one(str(_id))
                vote.delete_model()

        return ret