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
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
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
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
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
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
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
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
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
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 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
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 _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
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
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 _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
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
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
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
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 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
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
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
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
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
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
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
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
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)
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
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
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
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}