def _create_conversation(self, _request, _rule, _target_services):
_rule_uuid = None
if _rule != None:
_rule_uuid = _rule.get("uuid")
_app_uuid = _request.get("app_uuid")
_user_uuid = _request.get("user_uuid")
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
_portal_user_name = self.redis.hget(_key, "user_fullname")
_portal_user_icon = self.redis.hget(_key, "user_icon")
_group_icon = create_group_icon(self.redis, _target_services)
_assigned_uuid = None
if len(_target_services) == 1:
_assigned_uuid = _target_services[0]
_conversation_uuid = str(uuid.uuid1())
_row = ConversationInfo(uuid=_conversation_uuid,
app_uuid=_app_uuid,
user_uuid=_user_uuid,
assigned_uuid=_assigned_uuid,
rule_uuid=_rule_uuid,
status=CONVERSATION_STATUS.NEW,
conversation_type=CONVERSATION_TYPE.P2S)
_row.async_add(self.redis)
_row.create_redis_keys(self.redis)
_conversation_name = []
for _user in _target_services:
_key = DeviceUser.__tablename__ + ".uuid." + _user
_conversation_name.append(self.redis.hget(_key, "user_fullname"))
_conversation_name = ",".join(_conversation_name)
_row = ConversationUserData(
uuid=str(uuid.uuid1()),
app_uuid=_app_uuid,
user_uuid=_user_uuid,
conversation_uuid=_conversation_uuid,
conversation_name=_conversation_name,
conversation_icon=_group_icon,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add(self.redis)
_row.create_redis_keys(self.redis)
for _user in _target_services:
_row = ConversationUserData(
uuid=str(uuid.uuid1()),
app_uuid=_app_uuid,
user_uuid=_user,
conversation_uuid=_conversation_uuid,
conversation_name=_portal_user_name,
conversation_icon=_portal_user_icon,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add(self.redis)
_row.create_redis_keys(self.redis)
return
def _new_conversation(self):
_service_users = DeviceUser.__tablename__ + ".is_service_user.True"
_service_users = self.application.redis.smembers(_service_users)
if not _service_users:
logging.error("no service user ???????")
return
_service_users = list(_service_users)
_peer_uuid = _service_users[0]
if len(_service_users) != 1:
_peer_uuid = None
_key = DeviceUser.__tablename__ + ".uuid." + self._user_uuid
_portal_user_name = self.application.redis.hget(_key, "user_fullname")
_portal_user_icon = self.application.redis.hget(_key, "user_icon")
_conversation_uuid = str(uuid.uuid1())
_row = ConversationInfo(
uuid=_conversation_uuid,
user_uuid=self._user_uuid
)
_row.async_add(self.application.redis)
_row.create_redis_keys(self.application.redis)
_conversation_name = []
for _user in _service_users:
_key = DeviceUser.__tablename__ + ".uuid." + _user
_name = self.application.redis.hget(_key, "user_fullname")
if not _name:
continue
_conversation_name.append(_name)
_conversation_name = ",".join(_conversation_name)
_row = ConversationUserData(uuid=str(uuid.uuid1()),
user_uuid=self._user_uuid,
peer_uuid=_peer_uuid,
conversation_uuid=_conversation_uuid,
conversation_name=_conversation_name,
conversation_type=CONVERSATION_TYPE.P2S,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add(self.application.redis)
_row.create_redis_keys(self.application.redis)
for _user in _service_users:
_row = ConversationUserData(uuid=str(uuid.uuid1()),
user_uuid=_user,
peer_uuid=self._user_uuid,
conversation_uuid=_conversation_uuid,
conversation_name=_portal_user_name,
conversation_icon=_portal_user_icon,
conversation_type=CONVERSATION_TYPE.S2P,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add(self.application.redis)
_row.create_redis_keys(self.application.redis)
return
def _all(self, _app_uuid, _user_uuid, _device_uuid):
_key = AppUserData.__tablename__ + ".app_uuid." + _app_uuid + \
".is_service_user.True"
_allocated_users = self.redis.smembers(_key)
if _allocated_users == None or len(_allocated_users) == 0:
self._ack_error(_device_uuid)
return
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
_portal_user_name = self.redis.hget(_key, "user_fullname")
_portal_user_icon = self.redis.hget(_key, "user_icon")
_group_icon = create_group_icon(self.redis, _allocated_users)
_conversation_uuid = str(uuid.uuid1())
_row = CoversationInfo(uuid=_conversation_uuid,
app_uuid=_app_uuid,
user_uuid=_user_uuid,
status=CONVESATION_STATUS.NEW,
conversation_type=CONVERSATION_TYPE.P2S)
_row.async_add()
_row.create_redis_keys(self.redis)
_conversation_name = []
for _user in _allocated_users:
_key = DeviceUser.__tablename__ + ".uuid." + _user
_conversation_name.append(self.redis.hget(_key, "user_fullname"))
_conversation_name = ",".join(_conversation_name)
_row = ConversationUserData(
uuid=str(uuid.uuid1()),
app_uuid=_app_uuid,
user_uuid=_user_uuid,
conversation_uuid=_conversation_uuid,
conversation_name=_conversation_name,
conversation_icon=_group_icon,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add()
_row.create_redis_keys(self.redis)
for _user in _allocated_users:
_row = ConversationUserData(
uuid=str(uuid.uuid1()),
app_uuid=_app_uuid,
user_uuid=_user,
conversation_uuid=_conversation_uuid,
conversation_name=_portal_user_name,
conversation_icon=_portal_user_icon,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add()
_row.create_redis_keys(self.redis)
self._ack_success(_device_uuid, _conversation_uuid)
return
def _create(self, _member_uuid, _request):
_app_uuid = _request.get("app_uuid")
_user_uuid = _request.get("user_uuid")
_redis = self.application.redis
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
_portal_user_name = _redis.hget(_key, "user_name")
_portal_user_icon = _redis.hget(_key, "user_icon")
_key = DeviceUser.__tablename__ + ".uuid." + _member_uuid
_member_user_name = _redis.hget(_key, "user_name")
_member_user_icon = _redis.hget(_key, "user_icon")
_conversation_uuid = str(uuid.uuid1())
_values = {
"uuid": _conversation_uuid,
"app_uuid": _app_uuid,
"user_uuid": _user_uuid,
"assigned_uuid": _member_uuid,
"conversation_type": CONVERSATION_TYPE.P2S,
"status": CONVERSATION_STATUS.NEW,
}
# create it
_row = ConversationInfo(**_values)
_row.async_add()
_row.create_redis_keys(_redis)
_row = ConversationUserData(
uuid=str(uuid.uuid1()),
app_uuid=_app_uuid,
user_uuid=_user_uuid,
conversation_uuid=_conversation_uuid,
conversation_type=CONVERSATION_TYPE.P2S,
conversation_name=_member_user_name,
conversation_icon=_member_user_icon,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add()
_row.create_redis_keys(_redis)
_row = ConversationUserData(
uuid=str(uuid.uuid1()),
app_uuid=_app_uuid,
user_uuid=_member_uuid,
conversation_uuid=_conversation_uuid,
conversation_type=CONVERSATION_TYPE.P2S,
conversation_name=_portal_user_name,
conversation_icon=_portal_user_icon,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add()
_row.create_redis_keys(_redis)
self._return(_conversation_uuid, _request)
return
def _close(self, _conversation_uuid, _user_uuid):
_redis = self.application.redis
_key = ConversationUserData.__tablename__ + \
".user_uuid." + _user_uuid + \
".conversation_uuid." + _conversation_uuid
_uuid = _redis.get(_key)
if _uuid == None:
logging.error("no such conversation data: %s" % _key)
self.setErrorCode(API_ERR.NO_CONVERSATION)
return
_row = ConversationUserData(uuid=_uuid, conversation_status=CONVERSATION_STATUS.CLOSE)
_row.async_update(_redis)
_row.update_redis_keys(_redis)
return
def _open(self, _user_uuid, _conversation_uuid):
_redis = self.application.redis
_key = ConversationUserData.__tablename__ + \
".user_uuid." + _user_uuid + \
".conversation_uuid." + _conversation_uuid
_data_uuid = _redis.get(_key)
if _data_uuid == None:
self.setErrorCode(API_ERR.NO_CONVERSATION)
return
_row = ConversationUserData(uuid=_data_uuid, conversation_status=CONVERSATION_STATUS.OPEN)
_row.async_update(_redis)
_row.update_redis_keys(_redis)
return
def _remove(self):
_redis = self.application.redis
for _user_uuid in self._member_list:
key = ConversationUserData.__tablename__ + \
".app_uuid." + self._app_uuid + \
".user_uuid." + _user_uuid + \
".conversation_uuid." + self._conv_uuid
_uuid = _redis.get(key)
if _uuid == None:
continue
_row = ConversationUserData(uuid=_uuid)
_row.async_delete()
_row.delete_redis_keys(_redis)
return
def _datarow(self, _user_uuid, _user_name, _conversation_type, _conversation_uuid, _conversation_name, _conversation_icon):
_values = {
"uuid": str(uuid.uuid1()),
"user_uuid": _user_uuid,
"user_name": _user_name,
"conversation_type": _conversation_type,
"conversation_uuid": _conversation_uuid,
"conversation_name": _conversation_name,
"conversation_icon": _conversation_icon,
"conversation_status": CONVERSATION_STATUS.NEW,
}
_row = ConversationUserData(**_values)
_row.async_add(self._redis)
_row.create_redis_keys(self._redis)
return
def _create(self, _member_uuid, _request):
_user_uuid = _request.get("user_uuid")
_redis = self.application.redis
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
_portal_user_name = _redis.hget(_key, "user_fullname")
_portal_user_icon = _redis.hget(_key, "user_icon")
_key = DeviceUser.__tablename__ + ".uuid." + _member_uuid
_member_user_name = _redis.hget(_key, "user_fullname")
_member_user_icon = _redis.hget(_key, "user_icon")
_conversation_uuid = str(uuid.uuid1())
_values = {
"uuid": _conversation_uuid,
"user_uuid": _user_uuid
}
# create it
_row = ConversationInfo(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
_row = ConversationUserData(uuid=str(uuid.uuid1()),
user_uuid=_user_uuid,
peer_uuid=_member_uuid,
conversation_uuid=_conversation_uuid,
conversation_type=CONVERSATION_TYPE.P2S,
conversation_name=_member_user_name,
conversation_icon=_member_user_icon,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
_row = ConversationUserData(uuid=str(uuid.uuid1()),
user_uuid=_member_uuid,
peer_uuid=_user_uuid,
conversation_uuid=_conversation_uuid,
conversation_type=CONVERSATION_TYPE.S2P,
conversation_name=_portal_user_name,
conversation_icon=_portal_user_icon,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
logging.info("return from new")
return self._return(_conversation_uuid, _request)
def _add(self):
_redis = self.application.redis
for _user_uuid in self._member_list:
key = ConversationUserData.__tablename__ + \
".app_uuid." + self._app_uuid + \
".user_uuid." + _user_uuid + \
".conversation_uuid." + self._conv_uuid
if _redis.exists(key):
continue
_values = {
"uuid": str(uuid.uuid1()),
"user_uuid": _user_uuid,
"app_uuid": self._app_uuid,
"conversation_uuid": self._conv_uuid,
"conversation_status": CONVERSATION_STATUS.OPEN,
"conversation_type": self._conv["conversation_type"],
}
_row = ConversationUserData(**_values)
_row.async_add()
_row.create_redis_keys(_redis)
return
def _remove(self):
_redis = self.application.redis
for _user_uuid in self._member_list:
key = ConversationUserData.__tablename__ + \
".user_uuid." + _user_uuid + \
".conversation_uuid." + self._conv_uuid
_uuid = _redis.get(key)
if _uuid == None:
continue
_row = ConversationUserData(uuid=_uuid)
_row.async_delete(_redis)
_row.delete_redis_keys(_redis)
return
def _datarow(self, _user_uuid, _user_name, _conversation_type, _conversation_uuid, _conversation_name, _conversation_icon):
_values = {
"uuid": str(uuid.uuid1()),
"user_uuid": _user_uuid,
"user_name": _user_name,
"conversation_type": _conversation_type,
"conversation_uuid": _conversation_uuid,
"conversation_name": _conversation_name,
"conversation_icon": _conversation_icon,
"conversation_status": CONVERSATION_STATUS.NEW,
}
_row = ConversationUserData(**_values)
_row.async_add(self._redis)
_row.create_redis_keys(self._redis)
return
def _open(self, _user_uuid, _conversation_uuid):
_redis = self.application.redis
_key = ConversationUserData.__tablename__ + \
".user_uuid." + _user_uuid + \
".conversation_uuid." + _conversation_uuid
_data_uuid = _redis.get(_key)
if _data_uuid == None:
self.setErrorCode(API_ERR.NO_CONVERSATION)
return
_row = ConversationUserData(
uuid=_data_uuid, conversation_status=CONVERSATION_STATUS.OPEN)
_row.async_update(_redis)
_row.update_redis_keys(_redis)
return
def _close(self, _conversation_uuid, _user_uuid):
_redis = self.application.redis
_key = ConversationUserData.__tablename__ + \
".user_uuid." + _user_uuid + \
".conversation_uuid." + _conversation_uuid
_uuid = _redis.get(_key)
if _uuid == None:
logging.error("no such conversation data: %s" % _key)
self.setErrorCode(API_ERR.NO_CONVERSATION)
return
_row = ConversationUserData(
uuid=_uuid, conversation_status=CONVERSATION_STATUS.CLOSE)
_row.async_update(_redis)
_row.update_redis_keys(_redis)
return
def save(self):
_task = {
"uuid": self._uuid,
"app_uuid": self._app_uuid,
"conversation_uuid": self._conversation_uuid,
"conversation_type": self._conversation_type,
"message_type": self._message_type,
"message_subtype": self._message_subtype,
"from_uuid": self._from_uuid,
"from_type": self._from_type,
"from_device_uuid": self._from_device_uuid,
"to_uuid": self._to_uuid,
"to_type": self._to_type,
"body": self._message_body,
"task_status": TASK_STATUS.PENDING,
}
_row = MessagePushTask(**_task)
_row.async_add()
_row.create_redis_keys(self._redis)
_row = ConversationInfo(uuid=self._conversation_uuid,
status=CONVERSATION_STATUS.OPEN,
latest_task=self._uuid)
_row.async_update()
_row.update_redis_keys(self._redis)
_m = {"task_uuid": self._uuid}
self._redis.rpush(REDIS_DISPATCHER_NOTIFICATION_KEY, json.dumps(_m))
_key = ConversationUserData.__tablename__ + ".conversation_uuid." + self._conversation_uuid + ".datas"
_datas = self._redis.smembers(_key)
for _data_uuid in _datas:
_row = ConversationUserData(
uuid=_data_uuid, conversation_status=CONVERSATION_STATUS.OPEN)
_row.async_update()
_row.update_redis_keys(self._redis)
# for message routing algorithm
self._user_latest_send_message_time()
return
def _add(self):
_redis = self.application.redis
for _user_uuid in self._member_list:
key = ConversationUserData.__tablename__ + \
".user_uuid." + _user_uuid + \
".conversation_uuid." + self._conv_uuid
if _redis.exists(key):
continue
_values = {
"uuid": str(uuid.uuid1()),
"user_uuid": _user_uuid,
"conversation_uuid": self._conv_uuid,
"conversation_status": CONVERSATION_STATUS.OPEN,
"conversation_type": self._conv["conversation_type"],
}
_row = ConversationUserData(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
return
def _smart(self, _app_uuid, _user_uuid, _device_uuid):
_key = AppUserData.__tablename__ + ".app_uuid." + _app_uuid + \
".is_service_user.True"
_service_users = self.redis.smembers(_key)
if _service_users == None or len(_service_users) == 0:
self._ack_error(_device_uuid)
return
_user_hashs = {}
for _user in _service_users:
_user_hashs[_user] = redis_hash_to_dict(self.redis, DeviceUser,
_user)
_device_names = ["mobile_device_uuid", "browser_device_uuid"]
_online_users = []
for _user in _service_users:
_user_hash = _user_hashs[_user]
_online_devices = []
for _device_name in _device_names:
_user_device_uuid = _user_hash[_device_name]
if _user_device_uuid == None or len(_user_device_uuid) == 0:
continue
_key = DeviceInfo.__tablename__ + ".uuid." + _user_device_uuid
if self.redis.hget(_key, "device_is_online") == "True":
_online_devices.append(_device)
if len(_online_devices) > 0:
_online_users.append(_user)
if len(_online_users) == 0:
return self._group(_app_uuid, _user_uuid, _device_uuid)
_allocated_user = random.randint(0, len(_online_users) - 1)
_allocated_user = _online_users[_allocated_user]
_key = DeviceUser.__tablename__ + ".uuid." + _allocated_user
_allocated_user_name = _user_hashs[_allocated_user]["user_fullname"]
_allocated_user_icon = _user_hashs[_allocated_user]["user_icon"]
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
_portal_user_name = self.redis.hget(_key, "user_fullname")
_portal_user_icon = self.redis.hget(_key, "user_icon")
_conversation_uuid = str(uuid.uuid1())
_row = CoversationInfo(uuid=_conversation_uuid,
app_uuid=_app_uuid,
user_uuid=_user_uuid,
status=CONVESATION_STATUS.NEW,
conversation_type=CONVERSATION_TYPE.P2S)
_row.async_add()
_row.create_redis_keys(self.redis)
_row = ConversationUserData(
uuid=str(uuid.uuid1()),
app_uuid=_app_uuid,
user_uuid=_user_uuid,
conversation_uuid=_conversation_uuid,
conversation_name=_allocated_user_name,
conversation_icon=_allocated_user_icon,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add()
_row.create_redis_keys(self.redis)
_row = ConversationUserData(
uuid=str(uuid.uuid1()),
app_uuid=_app_uuid,
user_uuid=_allocated_user,
conversation_uuid=_conversation_uuid,
conversation_name=_portal_user_name,
conversation_icon=_portal_user_icon,
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add()
_row.create_redis_keys(self.redis)
self._ack_success(_device_uuid, _conversation_uuid)
return
def _group(self, _app_uuid, _user_uuid, _device_uuid, _group_uuid):
if _group_uuid == None:
# find the primary group
_key = OrgGroup.__tablename__ + ".app_uuid." + _app_uuid + \
".is_distributor.True"
_group_uuid = self.redis.get(_key)
if _group_uuid == None:
logging.error("no distributor group in app: %s" % _app_uuid)
self._ack_error(_device_uuid)
return True
_key = OrgUserGroupData.__tablename__ + ".group_uuid." + _group_uuid
_users = self.reids.smembers(_key)
if _users == None or len(_users) == 0:
logging.error("no service user in group: %s" % _group_uuid)
self._ack_error(_device_uuid)
return True
_ready_users = []
for _user in _users:
_key = DeviceUser.__tablename__ + ".uuid." + _user
_service_user_status = self.redis.hget(_key, "service_user_status")
if _service_user_status == SERVICE_USER_STATUS.READY:
_ready_users.append(_user)
if len(_ready_users) == 0:
logging.info("waiting group user ready: %s" % _group_uuid)
self._ack_waiting(_device_uuid)
self._back_to_queue(_app_uuid, _user_uuid, _device_uuid,
_group_uuid)
return False
_allocated_user = random.randint(0, len(_ready_users) - 1)
_allocated_user = _users[_allocated_user]
_allocated_user_dict = redis_hash_to_dict(self.redis, DeviceUser,
_allocated_user)
_portal_user_dict = redis_hash_to_dict(self.redis, DeviceUser,
_user_uuid)
_conversation_uuid = str(uuid.uuid1())
_row = CoversationInfo(uuid=_conversation_uuid,
app_uuid=_app_uuid,
group_uuid=_group_uuid,
user_uuid=_user_uuid,
assigned_uuid=_allocated_user,
status=CONVESATION_STATUS.NEW,
conversation_type=CONVERSATION_TYPE.P2S)
_row.async_add()
_row.create_redis_keys(self.redis)
_row = ConversationUserData(
uuid=str(uuid.uuid1()),
app_uuid=_app_uuid,
user_uuid=_user_uuid,
conversation_uuid=_conversation_uuid,
conversation_name=_allocated_user_dict["user_fullname"],
conversation_icon=_allocated_user_dict["user_icon"],
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add()
_row.create_redis_keys(self.redis)
_row = ConversationUserData(
uuid=str(uuid.uuid1()),
app_uuid=_app_uuid,
user_uuid=_allocated_user,
conversation_uuid=_conversation_uuid,
conversation_name=_portal_user_dict["user_fullname"],
conversation_icon=_portal_user_dict["user_icon"],
conversation_status=CONVERSATION_STATUS.NEW)
_row.async_add()
_row.create_redis_keys(self.redis)
self._ack_success(_device_uuid, _conversation_uuid)
return True
