def _create_user(self, _request):
from ppmessage.db.models import DeviceUser
_user_email = _request.get("user_email")
_user_fullname = _request.get("user_fullname")
_user_password = _request.get("user_password")
_user_icon = random_identicon(_user_email)
IOLoop.current().spawn_callback(download_random_identicon, _user_icon)
_row = DeviceUser(
uuid=self._user_uuid,
user_email=_user_email,
user_icon=_user_icon,
user_status=USER_STATUS.OWNER_2,
user_fullname=_user_fullname,
user_password=_user_password,
is_removed_user=False,
is_owner_user=True,
is_service_user=True,
is_anonymous_user=False
)
_row.create_redis_keys(self.application.redis)
_insert_into(_row)
self._user_fullname = _user_fullname
return True
def _create_third_party(self, _user_email, _user_fullname, _user_icon):
_redis = self.application.redis
_du_uuid = str(uuid.uuid1())
_values = {
"uuid": _du_uuid,
"user_status": USER_STATUS.THIRDPARTY,
"user_name": _user_email,
"user_email": _user_email,
"user_fullname": _user_fullname,
"is_anonymous_user": False,
}
if _user_icon != None:
_values["user_icon"] = _user_icon
_row = DeviceUser(**_values)
_row.async_add()
_row.create_redis_keys(_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,
"is_distributor_user": False,
}
_row = AppUserData(**_values)
_row.async_add()
_row.create_redis_keys(_redis)
_r = self.getReturnData()
_r["user_uuid"] = _du_uuid
return
def _exist_user(self, _request, _user_uuid):
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
if not self.application.redis.exists(_key):
logging.error("CHECK CODE")
self.setErrorCode(API_ERR.SYS_ERR)
return
_is_service_user = self.application.redis.hget(_key, "is_service_user")
if "True" == _is_service_user:
logging.error("user is service user who can not help himself ^_^.")
self.setErrorCode(API_ERR.NOT_PORTAL)
return
_user_fullname = self.application.redis.hget(_key, "user_fullname")
if _user_fullname != _request.get("ent_user_fullname"):
_row = DeviceUser(uuid=_user_uuid, user_fullname=_request.get("ent_user_fullname"))
_row.update_redis_keys(self.application.redis)
_row.async_update(self.application.redis)
_r = self.getReturnData()
_r["user_fullname"] = _user_fullname
_r["user_uuid"] = _user_uuid
_r["uuid"] = _user_uuid
return
def _update_user_with_device(self, _user_uuid, _device_uuid):
_values = {"uuid": _user_uuid}
_values["ppkefu_browser_device_uuid"] = _device_uuid
_row = DeviceUser(**_values)
_row.async_update(self.application.redis)
_row.update_redis_keys(self.application.redis)
return
def _create_user(self, _request):
from ppmessage.db.models import DeviceUser
_user_email = _request.get("user_email")
_user_fullname = _request.get("user_fullname")
_user_password = _request.get("user_password")
_user_icon = random_identicon(_user_email)
_row = DeviceUser(
uuid=self._user_uuid,
user_email=_user_email,
user_icon=_user_icon,
user_status=USER_STATUS.OWNER_2,
user_fullname=_user_fullname,
user_password=_user_password,
is_removed_user=False,
is_owner_user=True,
is_service_user=True,
is_anonymous_user=False
)
_row.create_redis_keys(_redis)
_insert_into(_row)
self._user_fullname = _user_fullname
return True
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 _create_user(self, _request):
from ppmessage.db.models import DeviceUser
_user_email = _request.get("user_email")
_user_fullname = _request.get("user_fullname")
_user_password = _request.get("user_password")
_user_language = _get_config().get("server").get("language").get(
"locale")
_user_icon = random_identicon(_user_email)
IOLoop.current().spawn_callback(download_random_identicon, _user_icon)
_row = DeviceUser(uuid=self._user_uuid,
app_uuid=self._app_uuid,
user_email=_user_email,
user_icon=_user_icon,
user_status=USER_STATUS.OWNER_2,
user_fullname=_user_fullname,
user_password=_user_password,
user_language=_user_language)
_row.create_redis_keys(self.application.redis)
_insert_into(_row)
self._user_fullname = _user_fullname
return True
def _create_user(self, _request):
from ppmessage.db.models import DeviceUser
_user_email = _request.get("user_email")
_user_fullname = _request.get("user_fullname")
_user_password = _request.get("user_password")
_user_language = _get_config().get("server").get("language").get("locale")
_user_icon = random_identicon(_user_email)
IOLoop.current().spawn_callback(download_random_identicon, _user_icon)
_user_uuid = str(uuid.uuid1())
_row = DeviceUser(uuid=_user_uuid,
user_email=_user_email,
user_icon=_user_icon,
user_status=USER_STATUS.OWNER_2,
user_fullname=_user_fullname,
user_password=_user_password,
user_language=_user_language)
_row.create_redis_keys(self.application.redis)
_insert_into(_row)
self._user_uuid = _user_uuid
self._user_fullname = _user_fullname
return True
def _create_user_name(self, user_uuid=None, data_uuid=None, ip=None):
logging.info("create anonymous user_uuid: %s, ip: %s" % (user_uuid, ip))
if user_uuid == None or ip == None or data_uuid == None:
return
url = "http://123.57.154.168:8099/IP2GEO/"
http_headers = {"Content-Type" : "application/json"}
http_body = {
"ip": ip,
"language": _get_config().get("server").get("language").get("locale"),
"team_uuid": _get_config().get("team").get("app_uuid"),
"team_name": _get_config().get("team").get("name")
}
http_request = HTTPRequest(
url, method='POST',
headers=http_headers,
validate_cert=False,
body=json.dumps(http_body)
)
http_client = AsyncHTTPClient()
response = yield http_client.fetch(http_request)
logging.info("geoservice return: %s" % response.body)
_body = json.loads(response.body)
if _body == None or _body.get("error_code") != 0:
logging.error("cant get user name by ip: %s" % ip)
return
_country = _body.get("country")
_state = _body.get("state")
_city = _body.get("city")
_location_user = []
if _country != None and len(_country) != 0:
_location_user.append(_country)
if _state != None and len(_state) != 0:
_location_user.append(_state)
if _city != None and len(_city) != 0:
_location_user.append(_city)
if len(_location_user) == 0:
return
_user_name = ".".join(_location_user)
_row = DeviceUser(uuid=user_uuid, user_name=_user_name, user_fullname=_user_name)
_row.update_redis_keys(self.application.redis)
_row.async_update(self.application.redis)
_row = AppUserData(uuid=data_uuid, user_fullname=_user_name)
_row.update_redis_keys(self.application.redis)
_row.async_update(self.application.redis)
return
def _update_user_status(self):
_values = {
"uuid": self.user_uuid,
"service_user_status": SERVICE_USER_STATUS.NULL
}
_row = DeviceUser(**_values)
_row.async_update(self.application.redis)
_row.update_redis_keys(self.application.redis)
return
def create_device_user(redis, request):
_uuid = request.get("uuid")
if not _uuid:
logging.error("no uuid provided. %s" % request)
return None
_is_service_user = bool(request.get("is_service_user"))
_is_anonymous_user = bool(request.get("is_anonymous_user"))
_is_owner_user = bool(request.get("is_owner_user"))
_user_email = request.get("user_email")
if not _user_email:
import strgen
_user_email = strgen.StringGenerator("[\d\w]{10}").render() + "@" + strgen.StringGenerator("[\d\w]{10}").render()
_user_icon = request.get("user_icon")
if not _user_icon:
_user_icon = random_identicon(_user_email)
_user_name = request.get("user_name")
_user_mobile = request.get("user_mobile")
_user_fullname = request.get("user_fullname")
_user_password = request.get("user_password")
_user_language = request.get("user_language") or "cn"
_ent_user_uuid = request.get("ent_user_uuid")
_ent_user_createtime = request.get("ent_user_createtime")
import pypinyin
if not isinstance(_user_fullname, unicode):
_user_fullname = _user_fullname.decode("utf-8")
_user_pinyin = "".join(pypinyin.lazy_pinyin(_user_fullname))
_user_py = "".join(pypinyin.lazy_pinyin(_user_fullname, style=pypinyin.FIRST_LETTER))
_values = {
"uuid": _uuid,
"is_service_user": _is_service_user,
"is_owner_user": _is_owner_user,
"is_ppmessage_user": _is_ppmessage_user,
"is_anonymous_user": _is_anonymous_user,
"user_name": _user_name,
"user_mobile": _user_mobile,
"user_email": _user_email,
"user_icon": _user_icon,
"user_fullname": _user_fullname,
"user_password": _user_password,
"user_pinyin": _user_pinyin,
"user_py": _user_py,
"ent_user_uuid": _ent_user_uuid,
"ent_user_createtime": _ent_user_createtime
}
_row = DeviceUser(**_values)
_row.async_add(redis)
_row.create_redis_keys(redis)
return _values
def _user(self, _device_uuid):
_v = {"ppcom_mobile_device_uuid": _device_uuid}
if self._is_browser == True:
_v = {"ppcom_browser_device_uuid": _device_uuid}
_v["uuid"] = self._user_uuid
_row = DeviceUser(**_v)
_row.async_update(self.application.redis)
_row.update_redis_keys(self.application.redis)
return
def _reset_device_of_user(self, _user_uuid):
_v = {"uuid": _user_uuid}
if self.device_is_browser == True:
_v["browser_device_uuid"] = ""
else:
_v["mobile_device_uuid"] = ""
_row = DeviceUser(**_v)
_row.async_update()
_row.update_redis_keys(self.application.redis)
return
def _update_user_with_device(self, _user_uuid, _device_uuid):
_values = {"uuid": _user_uuid}
if self.device_is_browser == True:
_values["browser_device_uuid"] = _device_uuid
else:
_values["mobile_device_uuid"] = _device_uuid
_row = DeviceUser(**_values)
_row.async_update()
_row.update_redis_keys(self.application.redis)
return
def _create(self, _ppcom_trace_uuid):
_redis = self.application.redis
_key = DeviceUser.__tablename__ + ".ppcom_trace_uuid." + _ppcom_trace_uuid
_uuid = _redis.get(_key)
logging.info(_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._create_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,
"is_distributor_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
return
def _update_user_status(self, _user_uuid):
_values = {"uuid": _user_uuid}
_user_status = self.input_data.get("user_status")
# NULL, READY, BUSY, REST
if _user_status in SERVICE_USER_STATUS:
_values["service_user_status"] = _user_status
else:
_values["service_user_status"] = SERVICE_USER_STATUS.READY
_row = DeviceUser(**_values)
_row.async_update(self.application.redis)
_row.update_redis_keys(self.application.redis)
return
def create_user(_redis, _request):
_user_email = _request.get("user_email")
_user_status = _request.get("user_status")
_user_fullname = _request.get("user_fullname")
_user_language = _request.get("user_language")
_user_password = _request.get("user_password")
_is_service_user = _request.get("is_service_user")
if not all([_user_email, _user_fullname]):
return None
_key = DeviceUser.__tablename__ + ".user_email." + _user_email
if _redis.exists(_key):
return None
if _is_service_user == None:
_is_service_user = False
if _user_status == None:
_user_status = USER_STATUS.THIRDPARTY
_user_icon = random_identicon(_user_email)
IOLoop.current().spawn_callback(download_random_identicon, _user_icon)
_du_uuid = str(uuid.uuid1())
_values = {
"uuid": _du_uuid,
"user_status": _user_status,
"user_name": _user_email,
"user_email": _user_email,
"user_icon": _user_icon,
"user_language": _user_language,
"user_fullname": _user_fullname,
"user_password": _user_password,
"is_removed_user": False,
"is_anonymous_user": False,
"is_service_user": _is_service_user,
"is_owner_user": False
}
_row = DeviceUser(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
_user_values = _values
return _user_values
def _create_user_name(self, user_uuid=None, ip=None):
logging.info("create anonymous user_uuid: %s, ip: %s" % (user_uuid, ip))
if user_uuid == None or ip == None:
return
url = "http://ipinfo.io/" + ip + "/json"
http_headers = {"Content-Type" : "application/json"}
http_request = HTTPRequest(
url, method='GET',
headers=http_headers
)
http_client = AsyncHTTPClient()
response = yield http_client.fetch(http_request)
logging.info("geoservice return: %s" % response.body)
_body = json.loads(response.body)
if not _body:
logging.error("cant get user name by ip: %s" % ip)
return
_country = _body.get("country")
_state = _body.get("state")
_city = _body.get("city")
_location_user = []
if _country != None and len(_country) != 0:
_location_user.append(_country)
if _state != None and len(_state) != 0:
_location_user.append(_state)
if _city != None and len(_city) != 0:
_location_user.append(_city)
if len(_location_user) == 0:
return
_user_name = ".".join(_location_user)
_row = DeviceUser(uuid=user_uuid,
user_name=_user_name,
user_fullname=_user_name)
_row.update_redis_keys(self.application.redis)
_row.async_update(self.application.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()
_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 _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 _send(self, _user_uuid, _user_email, _user_fullname):
_new_password = StringGenerator("[a-zA-Z0-9_\[\]\{\}\(\)\|\&\$\-]{8}").render()
_hash_password = hashlib.sha1(_new_password).hexdigest()
_row = DeviceUser(uuid=_user_uuid, user_password=_hash_password)
_row.update_redis_keys(self.application.redis)
_row.async_update(self.application.redis)
_subject = "[PPMessage]: renew password"
_text = "Dear %s,\n Your password has been reset to %s\n Yours Sincerely,\n PPMessage\n" % (_user_fullname, _new_password)
_html = "<html><body>Dear %s, <br><br> <p> <strong>%s</strong> is your new password. Login <a href='https://ppmessage.com/user/#/app/signup-md/signin'> PPMessage </a> with your new password. </p> <br><br> <p>Yours Sincerely,</p> <p>PPMessage</p></body></html>" % (_user_fullname, _new_password)
_key = REDIS_EMAIL_KEY
_request = {
"to": [_user_email],
"subject": _subject,
"text": _text,
"html": _html
}
self.application.redis.rpush(_key, json.dumps(_request))
return
def _create_user(self, _request):
from ppmessage.db.models import DeviceUser
_user_email = _request.get("user_email")
_user_fullname = _request.get("user_fullname")
_user_password = _request.get("user_password")
_user_language = _request.get("user_language")
_user_uuid = str(uuid.uuid1())
_row = DeviceUser(uuid=_user_uuid,
user_email=_user_email,
user_password=_user_password,
user_language=_user_language)
_row.create_redis_keys(self.application.redis)
_row.async_add(self.application.redis)
self._user_uuid = _user_uuid
return True
def _create_user(self, _request):
from ppmessage.db.models import DeviceUser
_user_email = _request.get("user_email")
_user_fullname = _request.get("user_fullname")
_user_password = _request.get("user_password")
_user_language = _get_config().get("server").get("language").get("locale")
_user_uuid = str(uuid.uuid1())
_row = DeviceUser(uuid=_user_uuid,
user_email=_user_email,
user_status=USER_STATUS.OWNER_2,
user_fullname=_user_fullname,
user_password=_user_password,
user_language=_user_language)
_row.create_redis_keys(self.application.redis)
_insert_into(_row)
self._user_uuid = _user_uuid
return True
def _create_third_party(self, _app_uuid, _user_email, _user_fullname, _user_icon):
_redis = self.application.redis
_du_uuid = str(uuid.uuid1())
_values = {
"uuid": _du_uuid,
"user_status": USER_STATUS.THIRDPARTY,
"user_name": _user_email,
"user_email": _user_email,
"user_fullname": _user_fullname,
"is_anonymous_user": False,
}
if _user_icon != None:
_values["user_icon"] = _user_icon
IOLoop.current().spawn_callback(download_random_identicon, _user_icon)
else:
_user_icon = random_identicon(_user_email)
_values["user_icon"] = _user_icon
IOLoop.current().spawn_callback(download_random_identicon, _user_icon)
_row = DeviceUser(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
_data_uuid = str(uuid.uuid1())
_values = {
"uuid": _data_uuid,
"user_uuid": _du_uuid,
"app_uuid": _app_uuid,
"user_fullname": _user_fullname,
"is_portal_user": True,
"is_service_user": False,
"is_owner_user": False
}
_row = AppUserData(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
_r = self.getReturnData()
_r["user_uuid"] = _du_uuid
return
def _create_user(self, _request):
from ppmessage.db.models import DeviceUser
_user_email = _request.get("user_email")
_user_fullname = _request.get("user_fullname")
_user_password = _request.get("user_password")
_user_language = _get_config().get("server").get("language").get(
"locale")
_user_uuid = str(uuid.uuid1())
_row = DeviceUser(uuid=_user_uuid,
user_email=_user_email,
user_status=USER_STATUS.OWNER_2,
user_fullname=_user_fullname,
user_password=_user_password,
user_language=_user_language)
_row.create_redis_keys(self.application.redis)
_insert_into(_row)
self._user_uuid = _user_uuid
return True
def _exist_user(self, _request, _user_uuid):
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
if not self.application.redis.exists(_key):
logging.error("CHECK CODE")
self.setErrorCode(API_ERR.SYS_ERR)
return
_is_service_user = self.application.redis.hget(_key, "is_service_user")
_user_app_uuid = self.application.redis.hget(_key, "app_uuid")
if "True" == _is_service_user and _request.get("app_uuid") == _user_app_uuid:
logging.error("user is service user who can not help himself ^_^.")
self.setErrorCode(API_ERR.NOT_PORTAL)
return
_user_fullname = self.application.redis.hget(_key, "user_fullname")
if _user_fullname != _request.get("ent_user_fullname"):
_row = DeviceUser(uuid=_user_uuid, user_fullname=_request.get("ent_user_fullname"))
_row.update_redis_keys(self.application.redis)
_row.async_update(self.application.redis)
_r = self.getReturnData()
_r["user_fullname"] = _user_fullname
_r["user_uuid"] = _user_uuid
_r["uuid"] = _user_uuid
return
def _update_user_with_device(self, _user_uuid, _device_uuid):
_values = {"uuid": _user_uuid}
_values["ppkefu_browser_device_uuid"] = _device_uuid
_row = DeviceUser(**_values)
_row.async_update(self.application.redis)
_row.update_redis_keys(self.application.redis)
return
def create_device_user(redis, request):
_uuid = request.get("uuid")
if not _uuid:
logging.error("no uuid provided. %s" % request)
return None
_is_service_user = bool(request.get("is_service_user"))
_is_anonymous_user = bool(request.get("is_anonymous_user"))
_is_owner_user = bool(request.get("is_owner_user"))
_user_email = request.get("user_email")
if not _user_email:
import strgen
_user_email = strgen.StringGenerator("[\d\w]{10}").render(
) + "@" + strgen.StringGenerator("[\d\w]{10}").render()
_user_icon = request.get("user_icon")
if not _user_icon:
_user_icon = random_identicon(_user_email)
_user_name = request.get("user_name")
_user_mobile = request.get("user_mobile")
_user_fullname = request.get("user_fullname")
_user_password = request.get("user_password")
_user_language = request.get("user_language") or "cn"
_ent_user_uuid = request.get("ent_user_uuid")
_ent_user_createtime = request.get("ent_user_createtime")
import pypinyin
if not isinstance(_user_fullname, unicode):
_user_fullname = _user_fullname.decode("utf-8")
_user_pinyin = "".join(pypinyin.lazy_pinyin(_user_fullname))
_user_py = "".join(
pypinyin.lazy_pinyin(_user_fullname, style=pypinyin.FIRST_LETTER))
_values = {
"uuid": _uuid,
"is_service_user": _is_service_user,
"is_owner_user": _is_owner_user,
"is_ppmessage_user": _is_ppmessage_user,
"is_anonymous_user": _is_anonymous_user,
"user_name": _user_name,
"user_mobile": _user_mobile,
"user_email": _user_email,
"user_icon": _user_icon,
"user_fullname": _user_fullname,
"user_password": _user_password,
"user_pinyin": _user_pinyin,
"user_py": _user_py,
"ent_user_uuid": _ent_user_uuid,
"ent_user_createtime": _ent_user_createtime
}
_row = DeviceUser(**_values)
_row.async_add(redis)
_row.create_redis_keys(redis)
return _values
def _create_user_name(self, user_uuid=None, ip=None):
logging.info("create anonymous user_uuid: %s, ip: %s" %
(user_uuid, ip))
if user_uuid == None or ip == None:
return
url = "http://123.57.154.168:8099/IP2GEO/"
http_headers = {"Content-Type": "application/json"}
http_body = {
"ip": ip,
"language":
_get_config().get("server").get("language").get("locale"),
"team_uuid": _get_config().get("team").get("app_uuid"),
"team_name": _get_config().get("team").get("name")
}
http_request = HTTPRequest(url,
method='POST',
headers=http_headers,
validate_cert=False,
body=json.dumps(http_body))
http_client = AsyncHTTPClient()
response = yield http_client.fetch(http_request)
logging.info(response.body)
_body = json.loads(response.body)
if _body == None or _body.get("error_code") != 0:
logging.error("cant get user name by ip: %s" % ip)
return
_country = _body.get("country")
_state = _body.get("state")
_city = _body.get("city")
_location_user = []
if _country != None and len(_country) != 0:
_location_user.append(_country)
if _state != None and len(_state) != 0:
_location_user.append(_state)
if _city != None and len(_city) != 0:
_location_user.append(_city)
if len(_location_user) == 0:
return
_user_name = ".".join(_location_user)
_row = DeviceUser(uuid=user_uuid,
user_name=_user_name,
user_fullname=_user_name)
_row.update_redis_keys(self.application.redis)
_row.async_update(self.applicataion.redis)
return
def _update_user_status(self):
_values = {
"uuid": self.user_uuid,
"service_user_status": SERVICE_USER_STATUS.NULL
}
_row = DeviceUser(**_values)
_row.async_update()
_row.update_redis_keys(self.application.redis)
return
def _remove(self, _user_uuid, _user_password):
_redis = self.application.redis
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
if not _redis.exists(_key):
self.setErrorCode(API_ERR.NO_USER)
return
_pass_hash = _redis.hget(_key, "user_password")
_pass_hash = hashlib.sha1(_pass_hash).hexdigest()
if _pass_hash != _user_password:
self.setErrorCode(API_ERR.ERR_MIS)
return
_key = AppInfo.__tablename__ + ".user_uuid." + _user_uuid
if _redis.exists(_key):
self.setErrorCode(API_ERR.APP_OWNER)
return
# FIXME: other org group data
# conversation data / app user data etc.
_row = DeviceUser(uuid=_user_uuid)
_row.async_delete(_redis)
_row.delete_redis_keys(_redis)
return
def _reset_device_of_user(self, _user_uuid):
_v = {"uuid": _user_uuid}
if self.device_is_browser == True:
_v["browser_device_uuid"] = ""
else:
_v["mobile_device_uuid"] = ""
_row = DeviceUser(**_v)
_row.async_update(self.application.redis)
_row.update_redis_keys(self.application.redis)
return
def _update_user_with_device(self, _user_uuid, _device_uuid):
_values = {"uuid": _user_uuid}
if self.device_is_browser == True:
_values["browser_device_uuid"] = _device_uuid
else:
_values["mobile_device_uuid"] = _device_uuid
_row = DeviceUser(**_values)
_row.async_update(self.application.redis)
_row.update_redis_keys(self.application.redis)
return
def _user(self, _device_uuid):
_v = {"ppcom_mobile_device_uuid": _device_uuid}
if self._is_browser == True:
_v = {"ppcom_browser_device_uuid": _device_uuid}
_v["uuid"] = self._user_uuid
_row = DeviceUser(**_v)
_row.async_update()
_row.update_redis_keys(self.application.redis)
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"]
_rdata["user_status"] = _user.get("user_status")
return
_app_uuid = _get_config().get("team").get("app_uuid")
_du_uuid = str(uuid.uuid1())
_user_email = _du_uuid + "@" + _app_uuid
_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,
"is_service_user": False,
"is_owner_user": False,
"is_removed_user": False,
"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)
_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,
ip=_ip)
return
def _update_user_status(self, _user_uuid):
_values = {"uuid": _user_uuid}
_user_status = self.input_data.get("user_status")
# NULL, READY, BUSY, REST
if _user_status in SERVICE_USER_STATUS:
_values["service_user_status"] = _user_status
else:
_values["service_user_status"] = SERVICE_USER_STATUS.READY
_row = DeviceUser(**_values)
_row.async_update(self.application.redis)
_row.update_redis_keys(self.application.redis)
return
def _create_bootstrap_first_user(_session, _config):
_user_config = _config.get("user")
_user = DeviceUser(
createtime=datetime.datetime.now(),
updatetime=datetime.datetime.now(),
uuid=str(uuid.uuid1()),
user_email=_user_config.get("user_email"),
user_password=hashlib.sha1(_user_config.get("user_password")).hexdigest(),
user_fullname=_user_config.get("user_fullname"),
user_firstname=_user_config.get("user_firstname"),
user_lastname=_user_config.get("user_lastname"),
user_language=_user_config.get("user_language"),
user_status=USER_STATUS.ADMIN,
is_anonymous_user=False,
)
_session.add(_user)
_session.commit()
_user_config["user_uuid"] = _user.uuid
return _config
def create_user(_redis, _request):
_user_email = _request.get("user_email")
_user_status = _request.get("user_status")
_user_fullname = _request.get("user_fullname")
_user_language = _request.get("user_language")
_user_password = _request.get("user_password")
_is_service_user = _request.get("is_service_user")
if not all([_user_email, _user_fullname]):
return None
_key = DeviceUser.__tablename__ + ".user_email." + _user_email
if _redis.exists(_key):
return None
if _is_service_user == None:
_is_service_user = False
if _user_status == None:
_user_status = USER_STATUS.THIRDPARTY
_user_icon = random_identicon(_user_email)
IOLoop.current().spawn_callback(download_random_identicon, _user_icon)
_du_uuid = str(uuid.uuid1())
_values = {
"uuid": _du_uuid,
"user_status": _user_status,
"user_name": _user_email,
"user_email": _user_email,
"user_icon": _user_icon,
"user_language": _user_language,
"user_fullname": _user_fullname,
"user_password": _user_password,
"is_removed_user": False,
"is_anonymous_user": False,
"is_service_user": _is_service_user,
"is_owner_user": False
}
_row = DeviceUser(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
_user_values = _values
return _user_values
def _create_user_name(self, user_uuid=None, ip=None):
logging.info("create anonymous user_uuid: %s, ip: %s" %
(user_uuid, ip))
if user_uuid == None or ip == None:
return
url = "http://ipinfo.io/" + ip + "/json"
http_headers = {"Content-Type": "application/json"}
http_request = HTTPRequest(url, method='GET', headers=http_headers)
http_client = AsyncHTTPClient()
response = yield http_client.fetch(http_request)
logging.info("geoservice return: %s" % response.body)
_body = json.loads(response.body)
if not _body:
logging.error("cant get user name by ip: %s" % ip)
return
_country = _body.get("country")
_state = _body.get("state")
_city = _body.get("city")
_location_user = []
if _country != None and len(_country) != 0:
_location_user.append(_country)
if _state != None and len(_state) != 0:
_location_user.append(_state)
if _city != None and len(_city) != 0:
_location_user.append(_city)
if len(_location_user) == 0:
return
_user_name = ".".join(_location_user)
_row = DeviceUser(uuid=user_uuid,
user_name=_user_name,
user_fullname=_user_name)
_row.update_redis_keys(self.application.redis)
_row.async_update(self.application.redis)
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 _set(self):
_request = json.loads(self.request.body)
_user_uuid = _request.get("user_uuid")
if _user_uuid == None or len(_user_uuid) == 0:
self.setErrorCode(API_ERR.NO_PARA)
return
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
if not self.application.redis.exists(_key):
self.setErrorCode(API_ERR.NO_USER)
return
_user = DeviceUser(uuid=_user_uuid, service_user_status=SERVICE_USER_STATUS.REST)
_user.async_update(self.application.redis)
_user.update_redis_keys(self.application.redis)
return
def _send(self, _user_uuid, _user_email, _user_fullname):
_new_password = StringGenerator("[a-zA-Z0-9_\[\]\{\}\(\)\|\&\$\-]{8}").render()
_hash_password = hashlib.sha1(_new_password).hexdigest()
_row = DeviceUser(uuid=_user_uuid, user_password=_hash_password)
_row.update_redis_keys(self.application.redis)
_row.async_update()
_subject = "[PPMessage]: renew password"
_text = "Dear %s,\n Your password has been reset to %s\n Yours Sincerely,\n PPMessage\n" % (_user_fullname, _new_password)
_html = "<html><body>Dear %s, <br><br> <p>Your password has been changed to <strong>%s</strong>.</p> <p>Yours Sincerely,</p> <p>PPMessage</p></body></html>" % (_user_fullname, _new_password)
_key = REDIS_EMAIL_KEY
_request = {
"to": [_user_email],
"subject": _subject,
"text": _text,
"html": _html
}
self.application.redis.rpush(_key, json.dumps(_request))
return
def _create_user(self, _request):
from ppmessage.db.models import DeviceUser
_user_email = _request.get("user_email")
_user_fullname = _request.get("user_fullname")
_user_password = _request.get("user_password")
_user_language = _request.get("user_language")
_user_uuid = str(uuid.uuid1())
_row = DeviceUser(uuid=_user_uuid,
user_email=_user_email,
user_password=_user_password,
user_language=_user_language)
_row.create_redis_keys(self.application.redis)
_row.async_add(self.application.redis)
self._user_uuid = _user_uuid
return True
def _exist_user(self, _user_uuid):
_update = {"uuid": _user_uuid}
if self._user_email:
_update.update({"user_email": self._user_email})
if self._user_icon:
_update.update({"user_icon": self._user_icon})
if self._user_mobile:
_update.update({"user_mobile": self._user_mobile})
if self._user_name:
_update.update({"user_fullname": self._user_fullname})
if _update:
_row = DeviceUser(**_update)
_row.update_redis_keys(self.application.redis)
_row.async_update(self.application.redis)
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
_r = self.getReturnData()
_r.update(self.application.redis.hgetall(_key))
return
def _remove(self, _user_uuid, _user_password):
_redis = self.application.redis
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
if not _redis.exists(_key):
self.setErrorCode(API_ERR.NO_USER)
return
_pass_hash = _redis.hget(_key, "user_password")
_pass_hash = hashlib.sha1(_pass_hash).hexdigest()
if _pass_hash != _user_password:
self.setErrorCode(API_ERR.ERR_MIS)
return
_key = AppInfo.__tablename__ + ".user_uuid." + _user_uuid
if _redis.exists(_key):
self.setErrorCode(API_ERR.APP_OWNER)
return
# FIXME: other org group data
# conversation data / app user data etc.
_row = DeviceUser(uuid=_user_uuid)
_row.async_delete()
_row.delete_redis_keys(_redis)
return
def create_user(_redis, _request):
'''
@param _redis
@param _request a dictionary contains create user's related param
@return user dict
'''
_app_uuid = _request.get("app_uuid")
_user_email = _request.get("user_email")
_user_status = _request.get("user_status")
_user_fullname = _request.get("user_fullname")
_user_language = _request.get("user_language")
_user_password = _request.get("user_password")
_is_service_user = _request.get("is_service_user")
if _user_email == None or _app_uuid == None or _user_fullname == None:
return None
_key = DeviceUser.__tablename__ + ".user_email." + _user_email
if _redis.exists(_key):
return None
if _is_service_user != None:
_is_portal_user = not _is_service_user
else:
_is_service_user = False
_is_portal_user = not _is_service_user
if _user_status == None:
_user_status = USER_STATUS.THIRDPARTY
_user_icon = random_identicon(_user_email)
IOLoop.current().spawn_callback(download_random_identicon, _user_icon)
_du_uuid = str(uuid.uuid1())
_values = {
"uuid": _du_uuid,
"user_status": _user_status,
"user_name": _user_email,
"user_email": _user_email,
"user_icon": _user_icon,
"user_language": _user_language,
"user_fullname": _user_fullname,
"user_password": _user_password,
"is_anonymous_user": False,
}
_row = DeviceUser(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
_user_values = _values
_data_uuid = str(uuid.uuid1())
_values = {
"uuid": _data_uuid,
"user_uuid": _du_uuid,
"app_uuid": _app_uuid,
"user_fullname": _user_values["user_fullname"],
"is_portal_user": _is_portal_user,
"is_service_user": _is_service_user,
"is_owner_user": False
}
_row = AppUserData(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
return _user_values
def create_user(_redis, _request):
'''
@param _redis
@param _request a dictionary contains create user's related param
@return user dict
'''
_app_uuid = _request.get("app_uuid")
_user_email = _request.get("user_email")
_user_status = _request.get("user_status")
_user_fullname = _request.get("user_fullname")
_user_language = _request.get("user_language")
_user_password = _request.get("user_password")
_is_service_user = _request.get("is_service_user")
if _user_email == None or _app_uuid == None or _user_fullname == None:
return None
_key = DeviceUser.__tablename__ + ".user_email." + _user_email
if _redis.exists(_key):
return None
if _is_service_user != None:
_is_portal_user = not _is_service_user
_is_distributor_user = _is_service_user
else:
_is_service_user = False
_is_portal_user = not _is_service_user
_is_distributor_user = _is_service_user
if _user_status == None:
_user_status = USER_STATUS.THIRDPARTY
_du_uuid = str(uuid.uuid1())
_values = {
"uuid": _du_uuid,
"user_status": _user_status,
"user_name": _user_email,
"user_email": _user_email,
"user_language": _user_language,
"user_fullname": _user_fullname,
"user_password": _user_password,
"is_anonymous_user": False,
}
_row = DeviceUser(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
_user_values = _values
_data_uuid = str(uuid.uuid1())
_values = {
"uuid": _data_uuid,
"user_uuid": _du_uuid,
"app_uuid": _app_uuid,
"is_portal_user": _is_portal_user,
"is_service_user": _is_service_user,
"is_distributor_user": _is_distributor_user,
"is_owner_user": False,
}
_row = AppUserData(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
return _user_values
def _create(self, _ppcom_trace_uuid):
_redis = self.application.redis
_key = DeviceUser.__tablename__ + ".ppcom_trace_uuid." + _ppcom_trace_uuid
_uuid = _redis.get(_key)
logging.info(_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._create_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()
_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,
"is_distributor_user": False,
}
_row = AppUserData(**_values)
_row.async_add()
_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
return
def create_user(redis, _request):
'''
@param redis
@param _request a dictionary contains create user's related param
@return {
'error_code': xx,
'xxx': xx,
'yyy': xx,
...
}
'''
_return_data = {
"error_code": API_ERR.NO_ERR
}
_app_uuid = _request.get("app_uuid")
_user_email = _request.get("user_email")
_user_firstname = _request.get("user_firstname")
_user_lastname = _request.get("user_lastname")
_user_fullname = _request.get("user_fullname")
_user_language = _request.get("user_language")
_user_company = _request.get("user_company")
_is_service_user = _request.get("is_service_user")
_user_status = _request.get("user_status")
_user_password = _request.get("user_password")
if _user_email == None or _app_uuid == None:
_return_data["error_code"] = API_ERR.NO_PARA
return _return_data
if _user_fullname == None and _user_firstname == None and _user_lastname == None:
_return_data["error_code"] = API_ERR.NO_PARA
return _return_data
_redis = redis
_key = DeviceUser.__tablename__ + ".user_email." + _user_email
if _redis.exists(_key):
logging.error("user %s existed." % _user_email)
_return_data["error_code"] = API_ERR.EX_USER
_return_data["user_uuid"] = _redis.get(_key)
return _return_data
if _user_firstname != None and _user_lastname != None:
_user_fullname = _user_firstname + " " + _user_lastname
if _is_service_user != None:
_is_portal_user = not _is_service_user
_is_distributor_user = _is_service_user
else:
_is_service_user = False
_is_portal_user = not _is_service_user
_is_distributor_user = _is_service_user
if _user_status == None:
_user_status = USER_STATUS.THIRDPARTY
_du_uuid = str(uuid.uuid1())
_values = {
"uuid": _du_uuid,
"user_status": _user_status,
"user_name": _user_email,
"user_email": _user_email,
"user_fullname": _user_fullname,
"user_firstname": _user_firstname,
"user_lastname": _user_lastname,
"user_company": _user_company,
"user_password": _user_password,
"is_anonymous_user": False,
}
_row = DeviceUser(**_values)
_row.async_add()
_row.create_redis_keys(_redis)
_user_values = _values
# if _app_uuid != PPMESSAGE_APP["uuid"]:
# _data_uuid = str(uuid.uuid1())
# _values = {
# "uuid": _data_uuid,
# "user_uuid": _du_uuid,
# "app_uuid": PPMESSAGE_APP["uuid"],
# "is_portal_user": True,
# "is_service_user": False,
# "is_distributor_user": False,
# "is_owner_user": False,
# }
# _row = AppUserData(**_values)
# _row.async_add()
# _row.create_redis_keys(_redis)
_data_uuid = str(uuid.uuid1())
_values = {
"uuid": _data_uuid,
"user_uuid": _du_uuid,
"app_uuid": _app_uuid,
"is_portal_user": _is_portal_user,
"is_service_user": _is_service_user,
"is_distributor_user": _is_distributor_user,
"is_owner_user": False,
}
_row = AppUserData(**_values)
_row.async_add()
_row.create_redis_keys(_redis)
_rdata = _return_data
_rdata.update(_user_values)
return _rdata
def _create_third_party(self, _app_uuid, _user_email, _user_fullname,
_user_icon):
_redis = self.application.redis
_du_uuid = str(uuid.uuid1())
_values = {
"uuid": _du_uuid,
"user_status": USER_STATUS.THIRDPARTY,
"user_name": _user_email,
"user_email": _user_email,
"user_fullname": _user_fullname,
"is_anonymous_user": False,
}
if _user_icon != None:
_values["user_icon"] = _user_icon
IOLoop.current().spawn_callback(download_random_identicon,
_user_icon)
else:
_user_icon = random_identicon(_user_email)
_values["user_icon"] = _user_icon
IOLoop.current().spawn_callback(download_random_identicon,
_user_icon)
_row = DeviceUser(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
_data_uuid = str(uuid.uuid1())
_values = {
"uuid": _data_uuid,
"user_uuid": _du_uuid,
"app_uuid": _app_uuid,
"user_fullname": _user_fullname,
"is_portal_user": True,
"is_service_user": False,
"is_owner_user": False
}
_row = AppUserData(**_values)
_row.async_add(_redis)
_row.create_redis_keys(_redis)
_r = self.getReturnData()
_r["user_uuid"] = _du_uuid
return
def _update(self):
_redis = self.application.redis
_request = json.loads(self.request.body)
_user_uuid = _request.get("user_uuid")
_user_icon = _request.get("user_icon")
_user_mobile = _request.get("user_mobile")
_user_email = _request.get("user_email")
if _user_uuid == None :
self.setErrorCode(API_ERR.NO_PARA)
return
_old_password = _request.get("old_password")
_user_password = _request.get("user_password")
if _old_password != None and _user_password != None:
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
_ex_password = _redis.hget(_key, "user_password")
if _ex_password != _old_password:
self.setErrorCode(API_ERR.MIS_ERR)
return
# remove not table fields
_data = copy.deepcopy(_request)
del _data["user_uuid"]
if _old_password != None:
del _data["old_password"]
if _user_icon != None:
if _user_icon.startswith("http"):
IOLoop.current().spawn_callback(download_random_identicon, _user_icon)
else:
_generic_store = get_config_server_generic_store()
_abs = _generic_store + os.path.sep + _user_icon
_dest = get_config_server_identicon_store()
shutil.copy(_abs, _dest)
if os.path.exists(_abs):
IOLoop.current().spawn_callback(upload_random_identicon, _abs)
_data["user_icon"] = get_random_identicon_url(_user_icon)
if len(_data) > 0:
_updated = generic_update(_redis, DeviceUser, _user_uuid, _data)
if not _updated:
self.setErrorCode(API_ERR.GENERIC_UPDATE)
return
if _user_mobile:
import phonenumbers
_p = phonenumbers.parse(_user_mobile, None)
if not phonenumbers.is_valid_number(_p):
self.setErrorCode(API_ERR.INVALID_PHONENUMBER)
return
_row = DeviceUser(uuid=_user_uuid,
user_mobile=_user_mobile)
_row.update_redis_keys(_redis)
_row.async_update(_redis)
if _user_email:
_key = DeviceUser.__tablename__ + ".user_email." + _user_email
if _redis.exists(_key):
self.setErrorCode(API_ERR.EX_USER)
return
_key = DeviceUser.__tablename__ + ".uuid." + _user_uuid
_old_email = _redis.hget(_key, "user_email")
if _old_email:
_key = DeviceUser.__tablename__ + ".user_email." + _old_email
_redis.delete(_key)
_row = DeviceUser(uuid=_user_uuid,
user_email=_user_email)
_row.update_redis_keys(_redis)
_row.async_update(_redis)
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 _user_latest_send_message_time(self):
_now = datetime.datetime.now()
_row = DeviceUser(uuid=self._from_uuid, latest_send_message_time=_now)
_row.async_update(self._redis)
return
def Csv2Mysql(csv_file):
dbsession_class = getDatabaseInstance().dbsession_class
db_session = dbsession_class()
csv_data = csv.reader(file(csv_file))
flag = 0
for i in csv_data:
flag += 1
if flag != 1:
row = []
for item in i:
row.append(encodeToUtf8(item, code_str))
try:
user_id = isUserExists(db_session, row[0])
if not user_id:
deviceuser = DeviceUser()
deviceuser.user_name = row[0]
deviceuser.user_fullname = row[1]
deviceuser.user_email = row[2]
deviceuser.user_type = row[3]
deviceuser.user_status = row[4]
deviceuser.user_icon = "/static/yvertical/assets/img/user1.png"
deviceuser.user_gender = row[5]
deviceuser.user_dob = row[6]
deviceuser.user_doj = row[7]
deviceuser.user_rid = row[8]
deviceuser.user_iid = row[9]
is_byod = isByod(row[12])
deviceuser.user_is_byod = is_byod
deviceuser.user_is_enod = not is_byod
db_session.add(deviceuser)
db_session.commit()
user_id = deviceuser.id
except:
dbsession_class.remove()
traceback.print_exc()
break
try:
group_id = isGroupExists(db_session, row[11])
if not group_id:
orggroup = OrgGroup()
orggroup.group_name = row[11]
orggroup.group_icon = "/static/yvertical/assets/img/group.jpg"
db_session.add(orggroup)
db_session.commit()
group_id = orggroup.id
except:
dbsession_class.remove()
traceback.print_exc()
try:
user_data_id = isUserDataExists(db_session, user_id, group_id)
if not user_data_id:
user_data = OrgGroupUserData()
user_data.group_id = group_id
user_data.user_id = user_id
user_data.is_leader = isLeader(row[10])
db_session.add(user_data)
db_session.commit()
except:
dbsession_class.remove()
traceback.print_exc()
else:
if isinstance(i[0], unicode):
code_str = None
else:
code_str = chardet.detect(i[0])["encoding"]
def _create_third_party(self, _app_uuid, _user_email, _user_fullname, _user_icon):
_redis = self.application.redis
_du_uuid = str(uuid.uuid1())
_values = {
"uuid": _du_uuid,
"user_status": USER_STATUS.THIRDPARTY,
"user_name": _user_email,
"user_email": _user_email,
"user_fullname": _user_fullname,
"is_anonymous_user": False,
}
if _user_icon != None:
_values["user_icon"] = _user_icon
_row = DeviceUser(**_values)
_row.async_add()
_row.create_redis_keys(_redis)
_data_uuid = str(uuid.uuid1())
_values = {
"uuid": _data_uuid,
"user_uuid": _du_uuid,
"app_uuid": _app_uuid,
"is_portal_user": True,
"is_service_user": False,
"is_owner_user": False,
"is_distributor_user": False,
}
_row = AppUserData(**_values)
_row.async_add()
_row.create_redis_keys(_redis)
_r = self.getReturnData()
_r["user_uuid"] = _du_uuid
return
