def _get(self):
        _redis = self.application.redis
        _conv = redis_hash_to_dict(_redis, ConversationInfo, self._conv_uuid)
        if _conv == None:
            logging.error("no such conversation: %s" % self._conv_uuid)
            self.setErrorCode(API_ERR.NO_CONVERSATION)
            return

        _key = (
            ConversationUserData.__tablename__
            + ".app_uuid."
            + self._app_uuid
            + ".user_uuid."
            + self._user_uuid
            + ".conversation_uuid."
            + self._conv_uuid
        )
        _data_uuid = _redis.get(_key)
        if _data_uuid == None:
            logging.error("no such conversation data uuid")
            self.setErrorCode(API_ERR.NO_CONVERSATION)
            return

        _data = redis_hash_to_dict(_redis, ConversationUserData, _data_uuid)
        if _data == None:
            logging.error("no such conversation data hash")
            self.setErrorCode(API_ERR.NO_CONVERSATION)
            return

        _rdata = self.getReturnData()
        for _i in _conv:
            _rdata[_i] = _conv.get(_i)

        _rdata["conversation_data"] = _data
        return
    def _du(self):

        _request = json.loads(self.request.body)

        _user_uuid = _request.get("user_uuid")
        if not _user_uuid:
            self.setErrorCode(API_ERR.NO_PARA)
            return

        _o = redis_hash_to_dict(self.application.redis, DeviceUser, _user_uuid)
        if not _o:
            self.setErrorCode(API_ERR.NO_OBJECT)
            return

        # not return the password default
        return_password = False
        if "return_password" in _request:
            return_password = _request["return_password"]
        if not return_password:
            del _o["user_password"]
        
        _fn = _o.get("user_fullname")
        if _fn != None and not isinstance(_fn, unicode):
            _fn = _fn.decode("utf-8")

        _rdata = self.getReturnData()
        _rdata.update(_o)
        _rdata["pinyinname0"] = "".join(lazy_pinyin(_fn))
        _rdata["pinyinname1"] = "".join(list(itertools.chain.from_iterable(pinyin(_fn, style=pypinyin.INITIALS))))

        _app_uuid = _get_config().get("team").get("app_uuid")
        _o = redis_hash_to_dict(self.application.redis, AppInfo, _app_uuid)
        _rdata.update({"team": _o});
        return
Example #3
0
    def _prepare(self, _task_uuid):
        if not _task_uuid:
            logging.error("Can't find task for task uuid: %s" % (_data["task_uuid"]))
            return None
        
        _redis = self.application.redis
        _task = redis_hash_to_dict(_redis, MessagePushTask, _task_uuid)
        if _task == None:
            logging.error("Can't find task for task uuid: %s" % (_data["task_uuid"]))
            return None
        
        _user = None
        if _task.get("from_type") == YVOBJECT.DU:
            _user = redis_hash_to_dict(_redis, DeviceUser, _task.get("from_uuid"))
            if _user != None:
                del _user["user_password"]

        # conversation maybe None for explicit message SYS LOGOUT
        _conversation = redis_hash_to_dict(_redis, ConversationInfo, _task.get("conversation_uuid"))

        _task["_user"] = _user
        _task["_conversation"] = _conversation
        
        self._task = _task
        return self._task
    def _Task(self):
        super(GetUnackedMessageHandler, self)._Task()

        _uuid = json.loads(self.request.body).get("uuid")
        if _uuid is None:
            self.setErrorCode(API_ERR.NO_PARA)
            return
        _redis = self.application.redis
        _push = redis_hash_to_dict(_redis, MessagePush, _uuid)
        if _push is None:
            self.setErrorCode(API_ERR.NO_PUSH)
            logging.error("Error no push uuid:%s." % (_uuid))
            return

        if _push["status"] == MESSAGE_STATUS.ACKED:
            logging.info("Already acked uuid:%s." % (_uuid))
            self.setErrorCode(API_ERR.NO_ERR)
            return

        _task = redis_hash_to_dict(_redis, MessagePushTask, _push["task_uuid"])
        if _task is None:
            self.setErrorCode(API_ERR.NO_TASK)
            logging.error("Error no task uuid:%s." % (_push["task_uuid"]))
            return

        _rdata = self.getReturnData()
        if isinstance(_task["message_body"], unicode):
            _task["message_body"] = _task["message_body"].encode("utf-8")

        _rdata["message"] = json.loads(_task.message_body)
        return
    def _get(self):
        _redis = self.application.redis
        _conv = redis_hash_to_dict(_redis, ConversationInfo, self._conv_uuid)
        if _conv == None:
            logging.error("no such conversation: %s" % self._conv_uuid)
            self.setErrorCode(API_ERR.NO_CONVERSATION)
            return
        
        _key = ConversationUserData.__tablename__ + \
               ".user_uuid." + self._user_uuid + \
               ".conversation_uuid." + self._conv_uuid
        _data_uuid = _redis.get(_key)
        if _data_uuid == None:
            logging.error("no such conversation data uuid")
            self.setErrorCode(API_ERR.NO_CONVERSATION)
            return

        _data = redis_hash_to_dict(_redis, ConversationUserData, _data_uuid)
        if _data == None:
            logging.error("no such conversation data hash")
            self.setErrorCode(API_ERR.NO_CONVERSATION)
            return
        
        _rdata = self.getReturnData()
        _rdata.update(_conv)
        
        _rdata["conversation_data"] = _data
        _rdata["conversation_icon"] = _data.get("conversation_icon")
        _rdata["conversation_name"] = _data.get("conversation_name")
        return
    def _validate_online_device(self):
        _user = redis_hash_to_dict(self.application.redis, DeviceUser, self._user_uuid)
        if _user == None:
            self.setErrorCode(API_ERR.NO_USER)
            return

        _device = redis_hash_to_dict(self.application.redis, DeviceInfo, self._device_uuid)
        if _device == None or _device.get("user_uuid") != self._user_uuid:
            self.setErrorCode(API_ERR.NO_DEVICE)
            return

        _return_data = self.getReturnData()
        _device_online = _device.get("device_is_online")
        if _device_online == False:
            _return_data["valid"] = False
            return
        
        # Shall we continue validating if _device_online == True ?
        
        # Since mobile_device_uuid != browser_device_uuid, if neither of them matchs
        # self._device_uuid, the request device ought to be offline.
        _mobile_uuid = _user.get("mobile_device_uuid")
        _browser_uuid = _user.get("browser_device_uuid")
        if self._device_uuid != _mobile_uuid and self._device_uuid != _browser_uuid:
            _return_data["valid"] = False
            return

        _return_data["valid"] = True
        return
Example #7
0
    def _get(self):
        _redis = self.application.redis
        _conversations = self._get_app_conversations(_redis)
        _l = []
        for _conversation_uuid in _conversations:
            if _conversation_uuid == None:
                continue

            _data = redis_hash_to_dict(_redis, ConversationInfo,
                                       _conversation_uuid)
            if _data == None or _data.get("latest_task") == None:
                continue

            # we add user_info here for convenient client to use
            _data['create_user'] = self._get_user_info(_redis,
                                                       _data['user_uuid'])

            # we add latest message info here for convenient client to use
            _data['latest_message'] = self._get_latest_message(
                _redis, _data['latest_task'])

            # add message total count
            _data['message_total_count'] = self._get_message_count(
                _redis, _data['uuid'])

            _l.append(_data)

        _r = self.getReturnData()
        _r["list"] = _l
        return
 def _detail(self, _script_uuid):
     _script = redis_hash_to_dict(self.application.redis, PredefinedScript, _script_uuid)
     _group_uuid = _script.get("group_uuid")
     if _group_uuid != None and len(_group_uuid) != 0:
         _key = PredefinedScriptGroup.__tablename__ + ".uuid." + _group_uuid
         _script["group_name"] = self.application.redis.hget(_key, "group_name")
     return
    def _return_conversation(self, _user_uuid, _conversation_uuid):
        _redis = self.application.redis
        _conversation = redis_hash_to_dict(_redis, ConversationInfo,
                                           _conversation_uuid)

        if _conversation == None:
            logging.error("no such conversation info: %s" % _conversation_uuid)
            return None

        _key = ConversationUserData.__tablename__ + \
               ".user_uuid." + _user_uuid + \
               ".conversation_uuid." + _conversation_uuid
        _data_uuid = _redis.get(_key)
        if _data_uuid != None:
            _key = ConversationUserData.__tablename__ + ".uuid." + _data_uuid
            _data = _redis.hmget(_key,
                                 ["conversation_name", "conversation_icon"])
            _conversation["conversation_name"] = _data[0]
            _conversation["conversation_icon"] = _data[1]
        else:
            logging.error("no conversation data for conversation_uuid: %s" %
                          _conversation_uuid)

        _conversation.update({"conversation_uuid": _conversation.get("uuid")})
        return _conversation
    def _create(self, _ppcom_trace_uuid):
        _redis = self.application.redis
        _key = DeviceUser.__tablename__ + ".ppcom_trace_uuid." + _ppcom_trace_uuid
        _uuid = _redis.get(_key)

        if _uuid != None:
            _user = redis_hash_to_dict(_redis, DeviceUser, _uuid)
            if _user != None:
                _rdata = self.getReturnData()
                _rdata["user_uuid"] = _uuid
                _rdata["user_email"] = _user["user_email"]
                _rdata["user_fullname"] = _user["user_fullname"]
                _rdata["user_icon"] = _user["user_icon"]
                _rdata["user_status"] = _user.get("user_status")
                return
        
        _du_uuid = str(uuid.uuid1())
        _user_email = _du_uuid[:6] + "@" + self.app_uuid[:6]
        _user_name = self._unknown_user_name()
        _user_icon = random_identicon(_du_uuid)
        
        _values = {
            "uuid": _du_uuid,
            "ppcom_trace_uuid": _ppcom_trace_uuid,
            "user_status": USER_STATUS.ANONYMOUS,
            "is_anonymous_user": True,
            "user_name": _user_name,
            "user_email": _user_email,
            "user_fullname": _user_name,
            "user_icon": _user_icon
        }
        
        _row = DeviceUser(**_values)
        _row.async_add(self.application.redis)
        _row.create_redis_keys(self.application.redis)

        _data_uuid = str(uuid.uuid1())
        _values = {
            "uuid": _data_uuid,
            "user_uuid": _du_uuid,
            "user_fullname": _user_name,
            "app_uuid": self.app_uuid,
            "is_portal_user": True,
            "is_service_user": False,
            "is_owner_user": False
        }
        _row = AppUserData(**_values)
        _row.async_add(self.application.redis)
        _row.create_redis_keys(self.application.redis)
        
        _rdata = self.getReturnData()
        _rdata["user_uuid"] = _du_uuid
        _rdata["user_fullname"] = _user_name
        _rdata["user_email"] = _user_email
        _rdata["user_name"] = _user_name
        _rdata["user_icon"] = _user_icon

        _ip = self.request.headers.get("X-Real-Ip") or self.request.headers.get("remote_ip") or self.request.remote_ip
        IOLoop.current().spawn_callback(self._create_user_name, user_uuid=_du_uuid, data_uuid=_data_uuid, ip=_ip)
        return
Example #11
0
    def _device(self):
        self._terminal_uuid = self.input_data["terminal"]

        _device = None
        _redis = self.application.redis
        _key = DeviceInfo.__tablename__ + ".terminal_uuid." + self._terminal_uuid
        _device = redis_hash_to_dict(_redis, DeviceInfo, _redis.get(_key))

        if _device == None:
            return self._create_device()

        _old_device_user = _device.get("user_uuid")
        if self.user.get("uuid") != _old_device_user:
            self._reset_device_of_user(_old_device_user)

        _is_development = bool(self.input_data.get("ios_app_development"))
        if _is_development != None and _device.get(
                "is_development") != _is_development:
            self._update_device_with_is_development(_device.get("uuid"),
                                                    _is_development)

        if self.input_data.get(
                "device_ios_token") != None or self.input_data.get(
                    "device_android_gcmtoken") != None or self.input_data.get(
                        "device_android_jpush_registrationid") != None:
            self._update_device_with_token(_device.get("uuid"))

        return _device
 def _get_conversation_list(self, _conversations):
     _redis = self.application.redis
     _conv_list = []
     _d_key_pre = ConversationUserData.__tablename__ + \
                  ".app_uuid." + self._app_uuid + \
                  ".user_uuid." + self._user_uuid + \
                  ".conversation_uuid."
     for _conversation_uuid in _conversations:
         _conversation = redis_hash_to_dict(self.application.redis, ConversationInfo, _conversation_uuid)
         _d_key = _redis.get(_d_key_pre + _conversation_uuid)
         _data = redis_hash_to_dict(self.application.redis, ConversationUserData, _d_key)
         _conversation["conversation_data"] = _data
         _conversation["from_user"] = self._get_from_user(_conversation)
         _conversation["latest_message"] = self._get_latest_message(_conversation)
         _conv_list.append(_conversation)
     return _conv_list
Example #13
0
    def delete_redis_keys(self, _redis):
        _obj = redis_hash_to_dict(_redis, ConversationInfo, self.uuid)
        if _obj == None:
            return
        
        _key = self.__tablename__ + \
               ".app_uuid." + _obj["app_uuid"] + \
               ".user_uuid." + _obj["user_uuid"] + \
               ".conversation_uuid." + _obj["uuid"] + \
               ".conversation_type." + _obj["conversation_type"]
        _redis.delete(_key)

        if _obj["group_uuid"] != None:
            _key = self.__tablename__ + \
                   ".app_uuid." + _obj["app_uuid"] + \
                   ".user_uuid." + _obj["user_uuid"] + \
                   ".group_uuid." + _obj["group_uuid"]
            _redis.delete(_key)

        if _obj["assigned_uuid"] != None:
            _key = self.__tablename__ + \
                   ".app_uuid." + _obj["app_uuid"] + \
                   ".user_uuid." + _obj["user_uuid"] + \
                   ".assigned_uuid." + _obj["assigned_uuid"]
            _redis.delete(_key)

        CommonMixin.delete_redis_keys(self, _redis)
        return
Example #14
0
    def _remove(self):
        _redis = self.application.redis

        _app = redis_hash_to_dict(_redis, AppInfo, _app_uuid)
        if _app == None:
            self.setErrorCode(API_ERR.NO_APP)
            return

        if _app.get("user_uuid") != _user_uuid:
            self.setErrorCode(API_ERR.NOT_OWNER)
            return

        _key = AppUserData.__tablename__ + ".app_uuid." + _app_uuid + ".is_service_user.True"
        _services = _redis.smembers()

        _key = AppUserData.__tablename__ + ".app_uuid." + _app_uuid + ".is_service_user.False"
        _users = _redis.smembers()

        _pi = _redis.pipeline()
        _data_key_pre = AppUserData.__tablename__ + ".app_uuid." + _app_uuid
        for _user_uuid in _sevices:
            _data_key = _data_key_pre + ".user_uuid." + _user_uuid + ".is_service_user.True"
            _pi.get(_data_key)
        _data_uuid_list = _pi.execute()

        for _i in _data_uuid_list:
            _row = AppUserData(uuid=_i)
            _row.async_delete(_redis)
            _row.delete_redis_keys(_redis)

        _row = AppInfo(uuid=_app_uuid)
        _row.async_delete(_redis)
        _row.delete_redis_keys(_redis)
        return
Example #15
0
    def _one(self, _app_uuid, _user_uuid):
        _redis = self.application.redis
        _key = AppUserData.__tablename__ + \
               ".app_uuid." + _app_uuid + \
               ".user_uuid." + _user_uuid + ".is_service_user.True"
        if not _redis.exists(_key):
            self.setErrorCode(API_ERR.NO_USER)
            return False

        _data_uuid = _redis.get(_key)
        _data = redis_hash_to_dict(_redis, AppUserData, _data_uuid)
        if _data == None:
            self.setErrorCode(API_ERR.NO_USER)
            return False

        if _data.get("is_owner_user") == True:
            self.setErrorCode(API_ERR.APP_OWNER)
            return False

        _row = AppUserData(uuid=_data_uuid)
        _row.async_delete(_redis)
        _row.delete_redis_keys(_redis)

        _key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
        if not _redis.exists(_key):
            self.setErrorCode(API_ERR.NO_USER)
            return False

        # FIXME: a lot of user db message should be removed
        _row = DeviceUser(uuid=_user_uuid)
        _row.async_delete(_redis)
        _row.delete_redis_keys(_redis)
        return True
Example #16
0
    def _return(self, _conversation_uuid, _request):
        _redis = self.application.redis
        _app_uuid = _request.get("app_uuid")
        _user_uuid = _request.get("user_uuid")

        _conversation = redis_hash_to_dict(_redis, ConversationInfo,
                                           _conversation_uuid)
        if _conversation == None:
            self.setErrorCode(API_ERR.NO_CONVERSATION)
            return
        _r = self.getReturnData()
        _r.update(_conversation)

        _key = ConversationUserData.__tablename__ + ".app_uuid." + _app_uuid + \
               ".user_uuid." + _user_uuid + ".conversation_uuid." + _conversation_uuid
        _data_uuid = _redis.get(_key)
        if _data_uuid != None:
            _key = ConversationUserData.__tablename__ + ".uuid." + _data_uuid
            logging.info(_redis.hgetall(_key))
            _data = _redis.hmget(_key,
                                 ["conversation_name", "conversation_icon"])
            logging.info("---------%s--------" % str(_data))
            _r["conversation_name"] = _data[0]
            _r["conversation_icon"] = _data[1]
        logging.info(_r)
        return
Example #17
0
    def _user_devices(self, _user_uuid):
        _user = self._users_hash.get(_user_uuid)
        _is_service_user = self._is_service_user.get(_user_uuid)

        if _user == None or _is_service_user == None:
            logging.error("no user or is_service_user in hash: %s" %
                          _user_uuid)
            return

        _user["_online_devices"] = {}
        _device_name = "ppkefu_browser_device_uuid"
        if _is_service_user == False:
            _device_name = "ppcom_browser_device_uuid"

        _device_uuid = self._users_hash[_user_uuid][_device_name]
        if not _device_uuid:
            return

        _device = redis_hash_to_dict(self._redis, DeviceInfo, _device_uuid)
        if not _device:
            return

        self._devices_hash[_device_uuid] = _device
        self._devices.add(_device_uuid)

        if _device.get("device_is_online") == True:
            _user["_online_devices"][_device_uuid] = _device

        if len(_user["_online_devices"]) > 0:
            self._online_users.add(_user_uuid)
        else:
            self._offline_users.add(_user_uuid)
        return
Example #18
0
    def _user_devices(self, _user_uuid):
        _user = self._users_hash.get(_user_uuid)
        _is_service_user = self._is_service_user.get(_user_uuid)
        
        if _user == None or _is_service_user == None:
            logging.error("no user or is_service_user in hash: %s" % _user_uuid)
            return
        
        _user["_online_devices"] = {}
        _device_name = "ppkefu_browser_device_uuid"
        if _is_service_user == False:
            _device_name = "ppcom_browser_device_uuid"
            
        _device_uuid = self._users_hash[_user_uuid][_device_name]
        if not _device_uuid:
            return
         
        _device = redis_hash_to_dict(self._redis, DeviceInfo, _device_uuid)
        if not _device:
            return

        self._devices_hash[_device_uuid] = _device
        self._devices.add(_device_uuid)
            
        if _device.get("device_is_online") == True:
            _user["_online_devices"][_device_uuid] = _device

        if len(_user["_online_devices"]) > 0:
            self._online_users.add(_user_uuid)
        else:
            self._offline_users.add(_user_uuid)
        return
Example #19
0
    def _user_devices(self, _user_uuid):
        _user = self._users_hash.get(_user_uuid)
        _is_service_user = self._is_service_user.get(_user_uuid)
        
        if _user == None or _is_service_user == None:
            logging.error("no user or is_service_user in hash: %s" % _user_uuid)
            return
        
        _user["_online_devices"] = {}
        _device_name = ["mobile_device_uuid", "browser_device_uuid"]
        if _is_service_user == False:
            _device_name = ["ppcom_mobile_device_uuid", "ppcom_browser_device_uuid"]

        for _i in _device_name:
            _device_uuid = self._users_hash[_user_uuid][_i]
            if _device_uuid == None or len(_device_uuid) == 0:
                continue
            _device = redis_hash_to_dict(self._redis, DeviceInfo, _device_uuid)
            if _device == None:
                continue

            self._devices_hash[_device_uuid] = _device
            self._devices.add(_device_uuid)
            
            if _device.get("device_is_online") == True:
                _user["_online_devices"][_device_uuid] = _device

        if len(_user["_online_devices"]) > 0:
            self._online_users.add(_user_uuid)
        else:
            self._offline_users.add(_user_uuid)
        return
Example #20
0
    def delete_redis_keys(self, _redis):
        _obj = redis_hash_to_dict(_redis, AppUserData, self.uuid)
        if _obj == None:
            return
        _key = self.__tablename__ + \
               ".app_uuid." + _obj["app_uuid"] + \
               ".user_uuid." + _obj["user_uuid"] + \
               ".is_service_user." + str(_obj["is_service_user"])
        _redis.delete(_key)

        _key = self.__tablename__ + \
               ".app_uuid." + _obj["app_uuid"] + \
               ".user_uuid." + _obj["user_uuid"]
        _redis.delete(_key)

        _key = self.__tablename__ + \
               ".user_uuid." + _obj["user_uuid"] + \
               ".is_service_user." + str(_obj["is_service_user"])
        _redis.delete(_key)
        
        _key = self.__tablename__ + \
               ".app_uuid." + _obj["app_uuid"] + \
               ".is_service_user." + str(_obj["is_service_user"])
        _redis.srem(_key, _obj["user_uuid"])
        
        CommonMixin.delete_redis_keys(self, _redis)
        return
Example #21
0
    def _du(self, _request, _rdata):
        if "user_uuid" not in _request:
            self.setErrorCode(API_ERR.NO_PARA)
            logging.error("Error for no para: %s.", (str(_request)))
            return

        _o = redis_hash_to_dict(self.application.redis, DeviceUser,
                                _request["user_uuid"])

        if _o == None:
            self.setErrorCode(API_ERR.NO_OBJECT)
            logging.error("Error for no user uuid: %s." %
                          (_request["user_uuid"]))
            return

        # not return the password default
        return_password = False
        if "return_password" in _request:
            return_password = _request["return_password"]
        if not return_password:
            del _o["user_password"]

        _fn = _o.get("user_fullname")
        if not isinstance(_fn, unicode):
            _fn = _fn.decode("utf-8")

        _rdata.update(_o)
        _rdata["pinyinname0"] = "".join(lazy_pinyin(_fn))
        _rdata["pinyinname1"] = "".join(
            list(
                itertools.chain.from_iterable(
                    pinyin(_fn, style=pypinyin.INITIALS))))

        return
 def _get_latest_message(self, conv):
     _task_uuid = conv.get("latest_task")
     if _task_uuid is None:
         return None
     
     _task = redis_hash_to_dict(self.application.redis, MessagePushTask, _task_uuid)
     return _task
    def _get(self):
        _redis = self.application.redis
        _conversations = self._get_app_conversations(_redis)
        _l = []
        for _conversation_uuid in _conversations:
            if _conversation_uuid == None:
                continue
            
            _data = redis_hash_to_dict(_redis, ConversationInfo, _conversation_uuid)
            if _data == None or _data.get("latest_task") == None:
                continue

            # we add user_info here for convenient client to use
            _data['create_user'] = self._get_user_info(_redis, _data['user_uuid'])

            # we add latest message info here for convenient client to use
            _data['latest_message'] = self._get_latest_message(_redis, _data['latest_task'])

            # add message total count
            _data['message_total_count'] = self._get_message_count(_redis, _data['uuid'])
                
            _l.append(_data)

        _r = self.getReturnData()
        _r["list"] = _l
        return
    def _get(self, _app_uuid, _group_uuid, _body):
        _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

        _group = redis_hash_to_dict(_redis, OrgGroup, _group_uuid)
        if _group == None:
            self.setErrorCode(API_ERR.NO_ORG_GROUP)
            return
        del _body["group_uuid"]
        del _body["app_uuid"]
        
        for _i in _body:
            if _i not in _group:
                logging.error("can not set: %s" % _i)
                continue
            _group[_i] = _body[_i]
            
        _r = self.getReturnData()
        for _i in _group:
            _r[_i] = _group[_i]
        _r["group_uuid"] = _group["uuid"]

        del _group["createtime"]
        del _group["updatetime"]

        _row = OrgGroup(**_group)
        _row.async_update()
        _row.update_redis_keys(_redis)
        return
 def _get_latest_message(self, conv):
     _task_uuid = conv.get("latest_task")
     if _task_uuid is None:
         return None
     
     _task = redis_hash_to_dict(self.application.redis, MessagePushTask, _task_uuid)
     return _task
Example #26
0
    def _user_devices(self, _user_uuid):
        _user = self._users_hash.get(_user_uuid)
        _is_service_user = self._is_service_user.get(_user_uuid)
        
        if _user == None or _is_service_user == None:
            logging.error("no user or is_service_user in hash: %s" % _user_uuid)
            return
        
        _user["_online_devices"] = {}
        _device_name = ["mobile_device_uuid", "browser_device_uuid"]
        if _is_service_user == False:
            _device_name = ["ppcom_mobile_device_uuid", "ppcom_browser_device_uuid"]

        for _i in _device_name:
            _device_uuid = self._users_hash[_user_uuid][_i]
            if _device_uuid == None or len(_device_uuid) == 0:
                continue
            _device = redis_hash_to_dict(self._redis, DeviceInfo, _device_uuid)
            if _device == None:
                continue

            self._devices_hash[_device_uuid] = _device
            self._devices.add(_device_uuid)
            
            if _device.get("device_is_online") == True:
                _user["_online_devices"][_device_uuid] = _device

        if len(_user["_online_devices"]) > 0:
            self._online_users.add(_user_uuid)
        else:
            self._offline_users.add(_user_uuid)
        return
    def _du(self, _request, _rdata):
        if "user_uuid" not in _request:
            self.setErrorCode(API_ERR.NO_PARA)
            logging.error("Error for no para: %s.", (str(_request)))
            return

        _o = redis_hash_to_dict(self.application.redis, DeviceUser, _request["user_uuid"])

        logging.info(_o)
        
        if _o == None:
            self.setErrorCode(API_ERR.NO_OBJECT)
            logging.error("Error for no user uuid: %s." % (_request["user_uuid"]))
            return

        # not return the password default
        return_password = False
        if "return_password" in _request:
            return_password = _request["return_password"]
        if not return_password:
            del _o["user_password"]
        
        _fn = _o.get("user_fullname")
        if _fn != None and not isinstance(_fn, unicode):
            _fn = _fn.decode("utf-8")

        _rdata.update(_o)
        _rdata["pinyinname0"] = "".join(lazy_pinyin(_fn))
        _rdata["pinyinname1"] = "".join(list(itertools.chain.from_iterable(pinyin(_fn, style=pypinyin.INITIALS))))
        
        return
    def _remove(self):
        _redis = self.application.redis
        
        _app = redis_hash_to_dict(_redis, AppInfo, _app_uuid)
        if _app == None:
            self.setErrorCode(API_ERR.NO_APP)
            return

        if _app.get("user_uuid") != _user_uuid:
            self.setErrorCode(API_ERR.NOT_OWNER)
            return

        _key = AppUserData.__tablename__ + ".app_uuid." + _app_uuid + ".is_service_user.True"
        _services = _redis.smembers()

        _key = AppUserData.__tablename__ + ".app_uuid." + _app_uuid + ".is_service_user.False"
        _users = _redis.smembers()

        _pi = _redis.pipeline()
        _data_key_pre = AppUserData.__tablename__ + ".app_uuid." + _app_uuid
        for _user_uuid in _sevices:
            _data_key = _data_key_pre + ".user_uuid." + _user_uuid + ".is_service_user.True"
            _pi.get(_data_key)
        _data_uuid_list = _pi.execute()
        
        for _i in _data_uuid_list:
            _row = AppUserData(uuid=_i)
            _row.async_delete()
            _row.delete_redis_keys(_redis)

        _row = AppInfo(uuid=_app_uuid)
        _row.async_delete()
        _row.delete_redis_keys(_redis)
        return
Example #29
0
    def delete_redis_keys(self, _redis):
        _obj = redis_hash_to_dict(_redis, ConversationUserData, self.uuid)
        if _obj == None:
            return
        _key = self.__tablename__ + \
               + ".user_uuid." + _obj["user_uuid"] + \
               ".conversation_uuid." + _obj["conversation_uuid"]
        _redis.delete(_key)
        
        _key = self.__tablename__ + \
               ".user_uuid." + _obj["user_uuid"]
        _redis.srem(_key, _obj["conversation_uuid"])

        _key = self.__tablename__ + \
               ".user_uuid." + _obj["user_uuid"] + \
               ".conversation_status." + _obj["conversation_status"]
        _redis.zrem(_key, _obj["conversation_uuid"])

        _key = self.__tablename__ + ".conversation_uuid." + _obj["conversation_uuid"]
        _redis.srem(_key, _obj["user_uuid"])

        _key = self.__tablename__ + ".conversation_uuid." + _obj["conversation_uuid"] + ".datas"
        _redis.srem(_key, self.uuid)

        CommonMixin.delete_redis_keys(self, _redis)
        return
Example #30
0
 def _pcsocket(self, _device_uuid):
     _key = PCSocketDeviceData.__tablename__ + ".device_uuid." + _device_uuid
     _pcsocket_uuid = self.redis.get(_key)
     if _pcsocket_uuid == None:
         return None
     _pcsocket_dict = redis_hash_to_dict(self.redis, PCSocketInfo, _pcsocket_uuid)
     return _pcsocket_dict
Example #31
0
    def _one(self, _app_uuid, _user_uuid):
        _redis = self.application.redis
        _key = AppUserData.__tablename__ + \
               ".app_uuid." + _app_uuid + \
               ".user_uuid." + _user_uuid + ".is_service_user.True"
        if not _redis.exists(_key):
            self.setErrorCode(API_ERR.NO_USER)
            return False

        _data_uuid = _redis.get(_key)
        _data = redis_hash_to_dict(_redis, AppUserData, _data_uuid)
        if _data == None:
            self.setErrorCode(API_ERR.NO_USER)
            return False
        
        if _data.get("is_owner_user") == True:
            self.setErrorCode(API_ERR.APP_OWNER)
            return False
        
        _row = AppUserData(uuid=_data_uuid)
        _row.async_delete()
        _row.delete_redis_keys(_redis)

        _key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
        if not _redis.exists(_key):
            self.setErrorCode(API_ERR.NO_USER)
            return False

        # FIXME: a lot of user db message should be removed
        _row = DeviceUser(uuid=_user_uuid)
        _row.async_delete()
        _row.delete_redis_keys(_redis)
        return True
Example #32
0
    def update_redis_keys(self, _redis, *args, **kwargs):
        CommonMixin.update_redis_keys(self, _redis, *args, **kwargs)
        _obj = redis_hash_to_dict(_redis, ConversationUserData, self.uuid)
        if _obj == None:
            return

        # REMOVE IT then ADD IT
        _statuses=[CONVERSATION_STATUS.NEW, CONVERSATION_STATUS.OPEN, CONVERSATION_STATUS.CLOSE]
        for _status in _statuses:
            _key = self.__tablename__ + \
                   ".user_uuid." + _obj["user_uuid"] + \
                   ".conversation_status." + _status
            _redis.zrem(_key, _obj["conversation_uuid"])

            _key = self.__tablename__ + ".conversation_status." + _status
            _redis.zrem(_key, _obj["conversation_uuid"])

        # user's conversations
        _key = self.__tablename__ + \
               ".user_uuid." + _obj["user_uuid"] + \
               ".conversation_status." + _obj["conversation_status"]
        _redis.zadd(_key, _obj["conversation_uuid"], time.time()*1000*1000)

        # app's conversations
        _key = self.__tablename__ + \
               ".conversation_status." + _obj["conversation_status"]
        _redis.zadd(_key, _obj["conversation_uuid"], time.time()*1000*1000)

        return
    def _get(self, _app_uuid):
        _redis = self.application.redis
        _key = AppUserData.__tablename__ + \
                   ".app_uuid." + _app_uuid + \
                   ".is_service_user.True"
        _user_list = _redis.smembers(_key)
        _users = []
        for _user_uuid in _user_list:
            _user = redis_hash_to_dict(_redis, DeviceUser, _user_uuid)
            if _user == None:
                continue
            _user = single_user(_redis, _user)

            _key = AppUserData.__tablename__ + \
                   ".app_uuid." + _app_uuid + \
                   ".user_uuid." + _user_uuid
            _data_string = _redis.get(_key)
            if _data_string == None:
                continue
            _data_json = json.loads(_data_string)
            _user.update(_data_json)
            _users.append(_user)
            
        _r = self.getReturnData()
        _r["list"] = _users
        return
Example #34
0
    def _search(self):
        _request = json.loads(self.request.body.decode("utf-8"))
        _table = _request.get("table")
        _search = _request.get("search")
        _size = _request.get("size")

        _redis = self.application.redis
        
        if _table == None or _search == None:
            self.setErrorCode(API_ERR.NO_PARA)
            return

        _cls = _class(_table)
        if _cls == None:
            self.setErrorCode(API_ERR.NO_TABLE)
            logging.info("no such table class: %s" % _table)
            return
        
        if _size == None:
            _size = 12

        _uuid_list = search_redis_index(_redis, _table, _search)
        _uuid_list = _uuid_list[:_size]

        _list = []
        for _uuid in _uuid_list:
            _list.append(redis_hash_to_dict(_redis, _cls, _uuid))

        _return = self.getReturnData()
        _return["list"] = _list
        return
    def _Task(self):
        super(GetAppVersionHandler, self)._Task()
        _request = json.loads(self.request.body)
        _app_distinct_name = _request.get("app_distinct_name")
        _app_platform = _request.get("app_platform")
                
        if _app_distinct_name == None or _app_platform == None:
            logging.error("Error for app_distinct_name or app_platform is not in request.")
            self.setErrorCode(API_ERR.NO_PARA)
            return

        _redis = self.application.redis
        _key = AppPackageInfo.__tablename__ + \
               ".app_platform." + _app_platform + \
               ".app_distinct_name." + _app_distinct_name

        _app_uuid = _redis.get(_key)
        if _app_uuid == None:
            logging.error("no such app")
            self.setErrorCode(API_ERR.NO_APP)
            return

        _app = redis_hash_to_dict(_redis, AppPackageInfo, _app_uuid)
        if _app == None:
            logging.error("no such app")
            self.setErrorCode(API_ERR.NO_APP)
            return

        _rdata = self.getReturnData()
        for _k in _app:
            _rdata[_k] = _app[_k]
            
        #logging.info("GETAPPVERSION return " + str(_rdata))
        return
Example #36
0
 def delete_redis_keys(self, _redis):
     _obj = redis_hash_to_dict(_redis, OrgGroup, self.uuid)
     if _obj == None or _obj["app_uuid"] == None:
         return
     _key = self.__tablename__ + ".app_uuid." + _obj["app_uuid"]
     _redis.srem(_key, _obj["uuid"])
     CommonMixin.delete_redis_keys(self, _redis)
     return
Example #37
0
 def delete_redis_keys(self, _redis):
     _obj = redis_hash_to_dict(_redis, FileInfo, self.uuid)
     if _obj == None:
         return
     _key = self.__tablename__ + ".file_hash." + _obj["file_hash"]
     _redis.delete(_key)
     CommonMixin.delete_redis_keys(self, _redis)
     return
Example #38
0
 def delete_redis_keys(self, _redis):
     _obj = redis_hash_to_dict(_redis, MessagePush, self.uuid)
     if _obj == None or _obj["task_uuid"] == None or _obj["user_uuid"] == None:
         return
     _key = self.__tablename__ + ".user_uuid." + _obj["user_uuid"]
     _redis.zrem(_key, self.uuid)
     CommonMixin.delete_redis_keys(self, _redis)
     return
Example #39
0
    def post(self, *args, **kwargs):
        _redis = self.application.redis
        logging.info(self.request.body)
        _user_email = self.get_body_argument("user_email")
        _user_password = self.get_body_argument("user_password")
        _token_data_uuid = self.get_body_argument("token_data_uuid")
        _redirect_uri = self.get_body_argument("redirect_uri")
        _state = self.get_body_argument("state")
        _key = DeviceUser.__tablename__ + ".user_email." + _user_email

        if not _redis.exists(_key):
            logging.info("no such user %s" % _user_email)
            self.send_error(500)
            # self.setErrorCode(API_ERR.NO_USER)
            return

        _user_uuid = _redis.get(_key)
        _user = redis_hash_to_dict(_redis, DeviceUser, _user_uuid)

        if _user == None:
            logging.info("no such user %s" % _user_email)
            self.send_error(500)
            # self.setErrorCode(API_ERR.NO_USER)
            return

        _pass = hashlib.sha1(_user_password).hexdigest()
        if _pass != _user.get("user_password"):
            logging.info("password not match %s" % _user_email)
            self.send_error(500)
            # self.setErrorCode(API_ERR.MIS_ERR)
            return

        _row = ApiTokenData(**{
            "uuid": _token_data_uuid,
            "is_code_authorized": True
        })
        _row.async_update()
        _row.update_redis_keys(_redis)

        _token_data = redis_hash_to_dict(_redis, ApiTokenData,
                                         _token_data_uuid)
        _code = _token_data.get("api_code")
        _redirect_target = _redirect_uri + "?code=" + _code + "&state=" + _state
        logging.info(_redirect_target)
        self.redirect(_redirect_target, permanent=True, status=301)
        return
Example #40
0
 def delete_redis_keys(self, _redis):
     _obj = redis_hash_to_dict(_redis, OrgGroup, self.uuid)
     if _obj == None or _obj["app_uuid"] == None:
         return
     _key = self.__tablename__ + ".app_uuid." + _obj["app_uuid"]
     _redis.srem(_key, _obj["uuid"])
     CommonMixin.delete_redis_keys(self, _redis)
     return
Example #41
0
    def _post(self, _request):
        _redis = self.application.redis

        _user_uuid = _request.get("user_uuid")
        if _user_uuid == None:
            logging.error("no user_uuid")
            self.setErrorCode(API_ERR.NO_PARA)
            return

        _user = redis_hash_to_dict(_redis, DeviceUser, _user_uuid)
        if _user is None:
            logging.error("No user %s." % _user_uuid)
            self.setErrorCode(API_ERR.NO_USER)
            return

        _values = {"uuid": _user_uuid}

        _email = _request.get("email")
        _icon = _request.get("icon")
        _password = _request.get("password")
        _fullname = _request.get("fullname")

        if _email is not None:
            _values["user_email"] = _email

        if _password is not None:
            _values["user_password"] = _password

        if _fullname is not None:
            _values["user_fullname"] = _fullname

        if _icon is not None:
            _file = redis_hash_to_dict(_redis, FileInfo, _icon)
            if _file is not None:
                _values["user_icon"] = _file.get("uuid")
            else:
                logging.error("No file: %s." % _icon)
                self.setErrorCode(API_ERR.NO_FILE)
                return

        if len(_values) > 1:
            _row = DeviceUser(**_values)
            _row.update_redis_keys(_redis)
            _row.async_update()

        return
    def _post(self, _request):
        _redis = self.application.redis

        _user_uuid = _request.get("user_uuid")
        if _user_uuid == None:
            logging.error("no user_uuid")
            self.setErrorCode(API_ERR.NO_PARA)
            return
        
        _user = redis_hash_to_dict(_redis, DeviceUser, _user_uuid)
        if _user is None:
            logging.error("No user %s." % _user_uuid)
            self.setErrorCode(API_ERR.NO_USER)
            return

        _values = {"uuid": _user_uuid}

        _email = _request.get("email")
        _icon = _request.get("icon")
        _password = _request.get("password")
        _fullname = _request.get("fullname")
        
        if _email is not None:
            _values["user_email"] = _email
            
        if _password is not None:
            _values["user_password"] = _password

        if _fullname is not None:
            _values["user_fullname"] = _fullname

        if _icon is not None:
            _file = redis_hash_to_dict(_redis, FileInfo, _icon)
            if _file is not None:
                _values["user_icon"] = _file.get("uuid")
            else:
                logging.error("No file: %s." % _icon)
                self.setErrorCode(API_ERR.NO_FILE)
                return
            
        if len(_values) > 1:
            _row = DeviceUser(**_values)
            _row.update_redis_keys(_redis)
            _row.async_update()

        return
 def _return(self, _conversation_uuid):
     _conversation = redis_hash_to_dict(self.application.redis, ConversationInfo, _conversation_uuid)
     if _conversation == None:
         self.setErrorCode(API_ERR.NO_CONVERSATION)
         return
     _r = self.getReturnData()
     _r.update(_conversation)
     return
Example #44
0
 def delete_redis_keys(self, _redis):
     _obj = redis_hash_to_dict(_redis, FileInfo, self.uuid)
     if _obj == None:
         return
     _key = self.__tablename__ + ".file_hash." + _obj["file_hash"]
     _redis.delete(_key)
     CommonMixin.delete_redis_keys(self, _redis)
     return
 def _return(self, _conversation_uuid):
     _conversation = redis_hash_to_dict(self.application.redis, ConversationInfo, _conversation_uuid)
     if _conversation == None:
         self.setErrorCode(API_ERR.NO_CONVERSATION)
         return
     _r = self.getReturnData()
     _r.update(_conversation)
     return
Example #46
0
 def _pcsocket(self, _device_uuid):
     _key = PCSocketDeviceData.__tablename__ + ".device_uuid." + _device_uuid
     _pcsocket_uuid = self.redis.get(_key)
     if _pcsocket_uuid == None:
         return None
     _pcsocket_dict = redis_hash_to_dict(self.redis, PCSocketInfo,
                                         _pcsocket_uuid)
     return _pcsocket_dict
    def _create(self, _ppcom_trace_uuid):
        _redis = self.application.redis
        _key = DeviceUser.__tablename__ + ".ppcom_trace_uuid." + _ppcom_trace_uuid
        _uuid = _redis.get(_key)

        if _uuid != None:
            _user = redis_hash_to_dict(_redis, DeviceUser, _uuid)
            if _user != None:
                _rdata = self.getReturnData()
                _rdata["user_uuid"] = _uuid
                _rdata["user_email"] = _user["user_email"]
                _rdata["user_fullname"] = _user["user_fullname"]
                _rdata["user_icon"] = _user["user_icon"]
                return
        
        _du_uuid = str(uuid.uuid1())
        _user_email = _du_uuid[:6] + "@" + self.app_uuid[:6]
        _user_name = self._unknown_user_name()
        
        _values = {
            "uuid": _du_uuid,
            "ppcom_trace_uuid": _ppcom_trace_uuid,
            "user_status": USER_STATUS.ANONYMOUS,
            "is_anonymous_user": True,
            "user_name": _user_name,
            "user_email": _user_email,
            "user_fullname": _user_name,
            "user_icon": create_user_icon(_du_uuid),
        }
        
        _row = DeviceUser(**_values)
        _row.async_add(self.application.redis)
        _row.create_redis_keys(self.application.redis)

        _data_uuid = str(uuid.uuid1())
        _values = {
            "uuid": _data_uuid,
            "user_uuid": _du_uuid,
            "app_uuid": self.app_uuid,
            "is_portal_user": True,
            "is_service_user": False,
            "is_owner_user": False
        }
        _row = AppUserData(**_values)
        _row.async_add(self.application.redis)
        _row.create_redis_keys(self.application.redis)
        
        _rdata = self.getReturnData()
        _rdata["user_uuid"] = _du_uuid
        _rdata["user_fullname"] = _user_name
        _rdata["user_email"] = _user_email
        _rdata["user_name"] = _user_name

        _ip = self.request.headers.get("X-Real-Ip") or self.request.headers.get("remote_ip") or self.request.remote_ip
        logging.info(str(self.request.headers))
        logging.info("create anonymous ip: %s" % _ip)
        IOLoop.instance().spawn_callback(self._create_user_name, user_uuid=_du_uuid, ip=_ip)
        return
Example #48
0
    def _Task(self):
        super(PPSelectUsersByGroupAlgorithmHandler, self)._Task()
        _request = json.loads(self.request.body)

        _app_uuid = _request.get("app_uuid")
        _group_uuid = _request.get("group_uuid")
        _conversation_uuid = _request.get("conversation_uuid")

        if _conversation_uuid == None or \
           _app_uuid == None or \
           _group_uuid == None:
            logging.error("no conversation_uuid/app_uuid/group_uuid")
            self.setErrorCode(API_ERR.NO_PARA)
            return

        _redis = self.application.redis
        _conv = redis_hash_to_dict(_redis, ConversationInfo,
                                   _conversation_uuid)
        if _conv == None:
            logging.error("no such conversation for uuid: %s" %
                          _conversation_uuid)
            self.setErrorCode(API_ERR.NO_CONVERSATION)
            return

        if _conv.get("conversation_type") != CONVERSATION_TYPE.P2S and \
           _conv.get("conversation_type") != CONVERSATION_TYPE.S2P:
            self.setErrorCode(API_ERR.CONVERSATION_TYPE)
            return

        if _conv.get("group_uuid") == _group_uuid:
            self.setErrorCode(API_ERR.EX_GROUP_USER)
            return

        _group = redis_hash_to_dict(_redis, OrgGroup, _group_uuid)
        if _group == None:
            self.setErrorCode(API_ERR.NO_ORG_GROUP)
            return None

        _cls = AbstractAlgorithm.get_algorithm_cls_by_name(
            _group["group_route_algorithm"])
        _best = _cls.best(_app_uuid, _group_uuid, _redis)
        _r = self.getReturnData()
        logging.info(_best)
        _r["list"] = list(_best)
        return
Example #49
0
 def delete_redis_keys(self, _redis):
     _obj = redis_hash_to_dict(_redis, PredefinedScriptGroup, self.uuid)
     if _obj == None:
         return
     _key = PredefinedScriptGroup.__tablename__ + ".app_uuid." + _obj[
         "app_uuid"]
     _redis.srem(_key, self.uuid)
     CommonMixin.delete_redis_keys(self, _redis)
     return
 def _get(self, _user_uuid):
     _redis = self.application.redis
     _user = redis_hash_to_dict(_redis, DeviceUser, _user_uuid)
     if _user is None:
         self.setErrorCode(API_ERR.NO_USER)
         return
     _r = self.getReturnData()
     _r.update(_user)
     return
 def _detail(self, _script_uuid):
     _script = redis_hash_to_dict(self.application.redis, PredefinedScript,
                                  _script_uuid)
     _group_uuid = _script.get("group_uuid")
     if _group_uuid != None and len(_group_uuid) != 0:
         _key = PredefinedScriptGroup.__tablename__ + ".uuid." + _group_uuid
         _script["group_name"] = self.application.redis.hget(
             _key, "group_name")
     return
Example #52
0
 def update_redis_keys(self, _redis):
     CommonMixin.update_redis_keys(self, _redis)
     _obj = redis_hash_to_dict(_redis, PredefinedScript, self.uuid)
     if _obj == None:
         return
     _key = self.__tablename__ + ".group_uuid." + str(
         _obj.get("group_uuid"))
     _redis.sadd(_key, self.uuid)
     return
Example #53
0
 def delete_redis_keys(self, _redis):
     _obj = redis_hash_to_dict(_redis, MaterialRefInfo, self.uuid)
     if _obj == None:
         return
     _key = self.__tablename__ + \
            ".user_uuid." + _obj["user_uuid"] + \
            ".material_uuid." + _obj["material_uuid"]
     _redis.delete(_key)
     CommonMixin.delete_redis_keys(self, _redis)
     return
Example #54
0
def get_message_info(redis, task_uuid):
    '''
    return the message info which task_uuid is `task_uuid`
    '''

    # illegal params
    if redis is None or task_uuid is None:
        return None

    return redis_hash_to_dict(redis, MessagePushTask, task_uuid)
Example #55
0
    def _users_devices(self):
        for _i in self._users:
            self._users_hash[_i] = redis_hash_to_dict(self._redis, DeviceUser, _i)

        for _i in self._users:
            self._user_devices(_i)

        logging.info("online : %d, %s" % (len(self._online_users), self._online_users))
        logging.info("offline : %d, %s" % (len(self._offline_users), self._offline_users))
        return
Example #56
0
    def _update_device(self):
        _values = {"uuid": self.device_uuid, "device_is_online": False}
        _row = DeviceInfo(**_values)
        _row.update_redis_keys(self.application.redis)
        _row.async_update()

        _d = redis_hash_to_dict(self.application.redis, DeviceInfo,
                                self.device_uuid)
        logging.info(_d)
        return
Example #57
0
 def delete_redis_keys(self, _redis):
     _obj = redis_hash_to_dict(_redis, PCSocketInfo, self.uuid)
     if _obj == None:
         return
     _key = self.__tablename__ \
            + ".host." + _obj["host"] \
            + ".port." + _obj["port"]
     _redis.delete(_key)
     CommonMixin.delete_redis_keys(self, _redis)
     return
Example #58
0
    def _parseImage(self, _body):
        _image = json.loads(_body)

        _fid = _image.get("fid")
        _mime = _image.get("mime")

        if _fid == None or _mime == None:
            logging.error("Error for message body of image message")
            return None
        
        _mime = _mime.lower()
        if _mime not in ["image/jpg", "image/jpeg", "image/png", "image/gif"]:
            logging.error("Error for not supported mime=%s." % (_mime))
            return None

        _file = redis_hash_to_dict(self._redis, FileInfo, _fid)
        if _file == None:
            logging.error("Error for no file in redis: %s" % _fid)
            return None

        _image = None
        try:
            # raise IOError when file not image
            _image = Image.open(_file["file_path"])
        except:
            pass
        finally:
            if _image == None:
                logging.error("PIL can not identify the file_id=%s, not image." % (_fid))
                return None

        _image_width, _image_height = _image.size
        _thum_width = _image_width
        _thum_height = _image_height
        
        if _image.format == "GIF":
            return {"thum":_fid, "orig":_fid, "mime":"image/gif", "orig_width": _image_width, "orig_height": _image_height, "thum_width": _thum_width, "thum_height": _thum_height}
        
        _thum_format = "JPEG"
        if _image.format == "PNG":
            _thum_format = "PNG"

        _thum_image_info = ImageConverter.thumbnailByKeepImage(_image, _thum_format)
        _thum_data = _thum_image_info["data"]
        _thum_image = _thum_image_info["image"]
        if _thum_data == None:
            logging.error("Error for thumbnail image")
            return None

        _thum_id = create_file_with_data(self._redis, _thum_data, _mime, self._from_uuid)

        _thum_width, _thum_height = _thum_image.size

        # where assume the _thum must be jpeg
        return {"thum":_thum_id, "orig":_fid, "mime":_mime, "orig_width": _image_width, "orig_height": _image_height, "thum_width": _thum_width, "thum_height": _thum_height}