def _get(self, _app_uuid, _group_uuid):
        _redis = self.application.redis
        _key = OrgGroup.__tablename__ + ".app_uuid." + _app_uuid
        _is = _redis.sismember(_key, _group_uuid)
        if _is != True:
            self.setErrorCode(API_ERR.NO_ORG_GROUP)
            return

        _r = self.getReturnData()
        _r["list"] = []
        
        _key = OrgGroupUserData.__tablename__ + ".group_uuid." + _group_uuid
        _users = _redis.smembers(_key)
        if _users == None or len(_users) == 0:
            return
        
        _users = self._get_users(_users)
        for _user in _users:
            _updatetime = string_to_datetime(_user["updatetime"], "extra")
            _user["updatetime"] = datetime_to_timestamp(_updatetime)

        _sorted = sorted(_users, key=itemgetter("updatetime"), reverse=True)

        _shrinked_users = []
        for _user in _sorted:
            _shrinked_users.append(single_user(_redis, _user))

        _r["list"] = _shrinked_users
        return
    def _return_by_min(self, _conversation_uuid, _min_uuid, _page_size):
        _rdata = self.getReturnData()
        _rdata["return_count"] = 0
        _rdata["min_uuid"] = _min_uuid
        _rdata["list"] = []

        _redis = self.application.redis
        _key = MessagePushTask.__tablename__ + ".conversation_uuid." + _conversation_uuid
        _min_createtime = _redis.zscore(_key, _min_uuid)
        if _min_createtime == None:
            logging.error("no such task for min_uuid: %s" % _min_uuid)
            return

        _max_item = _redis.zrevrange(_key, 0, 0)[0]
        _key = MessagePushTask.__tablename__ + ".uuid." + _max_item
        _createtime = _redis.hget(_key, "createtime")
        _createtime = string_to_datetime(_createtime, "extra")
        _createtime = time.mktime(_createtime.timetuple())*1000*1000 + _createtime.microsecond

        if _createtime <  _min_createtime:
            logging.info("no newer task for than min_uuid: %s" % _min_uuid)
            return

        _key = MessagePushTask.__tablename__ + ".conversation_uuid." + _conversation_uuid
        _tasks = _redis.zrangebyscore(_key, _min_createtime, -1, start=0, num=_page_size)
        if _tasks == None or len(_tasks) == 0:
            return
        
        _tasks.remove(_min_uuid)
        self._return_tasks(_tasks)
        return
def _single(_redis, _user):
    _is_mobile_online = False
    _is_browser_online = False
    _device_uuid = _user.get("mobile_device_uuid")
    if _device_uuid != None:
        _is_mobile_online = _online(_redis, _device_uuid)
    _device_uuid = _user.get("browser_device_uuid")
    if _device_uuid != None:
        _is_browser_online = _online(_redis, _device_uuid)
    _d = {}
    _d["is_browser_online"] = _is_browser_online
    _d["is_mobile_online"] = _is_mobile_online
    _d["group"] = _group(_redis, _user.get("uuid"))

    _fields = [
        "uuid",
        "user_icon",
        "user_email",
        "user_fullname",
        "user_signature",
        "updatetime",
    ]
    for _i in _fields:
        _d[_i] = _user.get(_i)
    if isinstance(_d["updatetime"], str):
        _updatetime = string_to_datetime(_d["updatetime"])
        _d["updatetime"] = datetime_to_timestamp(_updatetime)
    return _d
Example #4
0
    def _return_by_max(self, _conversation_uuid, _max_uuid, _page_size):
        _rdata = self.getReturnData()
        _rdata["return_count"] = 0
        _rdata["max_uuid"] = _max_uuid
        _rdata["list"] = []

        _redis = self.application.redis
        _key = MessagePushTask.__tablename__ + ".conversation_uuid." + _conversation_uuid
        _max_createtime = _redis.zscore(_key, _max_uuid)
        if _max_createtime == None:
            logging.error("no such task for max_uuid: %s" % _max_uuid)
            return

        _redis = self.application.redis
        _min_item = _redis.zrange(_key, 0, 0)[0]
        _key = MessagePushTask.__tablename__ + ".uuid." + _min_item
        _createtime = _redis.hget(_key, "createtime")
        _createtime = string_to_datetime(_createtime, "extra")
        _createtime = time.mktime(
            _createtime.timetuple()) * 1000 * 1000 + _createtime.microsecond

        if _createtime > _max_createtime:
            logging.info("no more task for less than max_uuid: %s" % _max_uuid)
            return

        _key = MessagePushTask.__tablename__ + ".conversation_uuid." + _conversation_uuid
        _tasks = _redis.zrevrangebyscore(_key,
                                         _max_createtime,
                                         0,
                                         start=0,
                                         num=_page_size)
        if _tasks == None or len(_tasks) == 0:
            return

        _tasks.remove(_max_uuid)
        self._return_tasks(_tasks)
        return