Example #1
0
    def random_private_library_offset(library_type, user_id, refresh=False):
        if not user_id:
            return 1

        cache_key = private_library_cache_key + str(library_type) + ":" + str(
            user_id)
        # 从集合中随机取一个值
        rand_id = redis.srandmember(cache_key)
        # Redis随机取值失败或者需要刷新
        if not rand_id or refresh:
            # 读取数据库数据
            if library_type == 11:
                model_list = ImageModel.query.filter_by(user_id=user_id,
                                                        type=11,
                                                        status=1).all()
                cache_id_list = array_column(model_list, "image_id")
            else:
                model_list = VideoModel.query.filter_by(user_id=user_id,
                                                        type=31,
                                                        status=1).all()
                cache_id_list = array_column(model_list, "video_id")
            # 更新Redis并返回随机值
            redis.delete(cache_key)
            if cache_id_list:
                redis.sadd(cache_key, *cache_id_list)
                return random.choice(cache_id_list)
            else:
                return 1
        else:
            return rand_id
Example #2
0
def azz_net_job(username):
    latest_pic_url = get_first_page_urls(username)[0]
    # 判断最新一张是否在历史中,如果不在说明为新的作品
    if not redis.sismember(key(username), latest_pic_url):
        # 发现新的作品,推送:
        logger.info('检测到 {} 有新的作品发布'.format(username))
        for user_id in models.get_all_user_id():
            content = '{} 发布了新的作品,图片链接为: \n{}'.format(username, latest_pic_url)
            bot.send_message(chat_id=user_id, text=content)
        redis.sadd(key(username), latest_pic_url)
Example #3
0
 def addIPAddress(self, ip_address):
     """
     Add an IP address to the IP address list
     """
     self._data['ip_addresses'].add(ip_address)
     keyExists = True
     if redis.exists(f'session::{self.id}::ip_addresses') == 0:
         keyExists = False
     redis.sadd(f'session::{self.id}::ip_addresses', ip_address)
     if not keyExists:
         redis.expire(f'session::{self.id}::ip_addresses',
                      self.timeToEnd().seconds + (500))
Example #4
0
    def save(self):
        """
        Save the current alert to database.
        """
        email_sha = sha1(self.email).hexdigest()

        saved = bool(
            redis.sadd("sl:alert:ids", self.sha) and
            redis.sadd("sl:account:{}:alerts".format(email_sha), self.sha) and
            redis.hmset("sl:alert:{}".format(self.sha), self.to_dict())
        )

        if not saved:
            raise SleekException("Could not save current alert.")
Example #5
0
def join(message):
    room_id = message['room_id']
    if 'manager_id' in session:
        if room_id not in session:
            session[room_id] = u"管理员"
        if 'uid' not in session:
            session['uid'] = str(session['manager_id'])
    

    uid = session['uid']
    join_room(room_id)
    redis.sadd(room_id, room_id + ':' + uid)
    emit('user update', {'flag': 'join', 'uid': uid, 'nick_name': session[room_id]}, room=room_id)

    emit('system message', {'content': session[room_id] + u'加入了房间' + message['room_id']}, room=room_id)
Example #6
0
 def add_karma(self, sha):
     if redis.sadd("karma:{}".format(self.sha), sha):
         self.karma += 1
         redis.zincrby("trending", self.sha, self.score / self.karma)
         redis.zremrangebyrank("trending", 0, -100)
         return self.update()
     return False
Example #7
0
    def register(self):
        """
        Register and save the current user to database.
        """
        try:
            sha = sha1(self.email).hexdigest()
        except TypeError:
            raise SleekException("Could not register user.", 401)

        if not redis.sadd("sl:account:ids", sha):
            raise SleekException("Could not register new user.", 401)
        self.save(register=True)
Example #8
0
def join(message):
    room_id = message['room_id']
    if 'manager_id' in session:
        if room_id not in session:
            session[room_id] = u"管理员"
        if 'uid' not in session:
            session['uid'] = str(session['manager_id'])

    uid = session['uid']
    join_room(room_id)
    redis.sadd(room_id, room_id + ':' + uid)
    emit('user update', {
        'flag': 'join',
        'uid': uid,
        'nick_name': session[room_id]
    },
         room=room_id)

    emit('system message',
         {'content': session[room_id] + u'加入了房间' + message['room_id']},
         room=room_id)
Example #9
0
def cache_user_rsvp_response(response, event_id, previous_event=False):
    """
    1. Get the response dictionary.
    2. JSONIFY (serialize it so that it can be saved in redis cache)
    3. Insert the response into the list
    """
    # in case of previous_event we dont need to convert tag name
    # prvious event means if manually cache the response to run job
    if not previous_event:
        tag_ques_response = modify_reponse_of_user(response)
        response[tag_ques_response[0]] = tag_ques_response[1]
    # concate reponse
    for key, value in response.iteritems():
        if isinstance(value, list):
            response[key] = ','.join(value)
        else:
            response[key] = value
    from utils_helper import Util_Helpers
    key = Util_Helpers.cache_key_creation(["event", event_id, "response"])
    response = json.dumps(response)
    redis.sadd(key, response)
Example #10
0
    def addEmail(self, email):
        """
        Add email to email list, emails on this list will be sent a message with the final results
        """
        # Don't allow modifications to data after the session has ended
        if self.isEnded():
            raise Exception('This session has ended.')

        # Force emails to lowercase
        email = email.lower()

        # Add email address to this session's email set
        self._data['emails'].add(email)

        # Save to redis
        keyExists = True
        if redis.exists(f'session::{self.id}::emails') == 0:
            keyExists = False
        redis.sadd(f'session::{self.id}::emails', email)
        ## set ttl on the key if it was just created
        if not keyExists:
            redis.expire(f'session::{self.id}::emails',
                         self.timeToEnd().seconds + (500))
Example #11
0
def scrap(data):
    scraping = get_scraping(data['type'])
    key = data['email']
    json_data = json.dumps(data)
    r.sadd(key, json_data)
    return scraping.scrap(data)
Example #12
0
def add_online(user_id):
    if not user_id:
        return
    when = int(time.time()) / PERIOD * PERIOD
    key = KEY.format(when)
    redis.sadd(key, user_id)
Example #13
0
 def save(self):
     if redis.sadd("messages", self.sha) and redis.set("message:{}".format(self.sha), self.to_dict()):
         redis.zincrby("new", self.sha, dt2ts(self.date))
         redis.zremrangebyrank("new", 0, -100)
         return True
     return False
Example #14
0
def init_azz_net(username):
    for url in get_first_page_urls(username):
        redis.sadd(key(username), url)
Example #15
0
 def push_list(key, value):
     redis.sadd(key, value)
Example #16
0
 def save(self):
     return (redis.sadd("tokens", self.sha) and
             redis.set("token:{}".format(self.sha), self.to_dict()))