Esempio n. 1
0
    def _remove(self):
        _redis = self.application.redis
        
        _app = redis_hash_to_dict(_redis, AppInfo, _app_uuid)
        if _app == None:
            self.setErrorCode(API_ERR.NO_APP)
            return

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

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

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

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

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

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

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

        # FIXME: a lot of user db message should be removed
        _row = DeviceUser(uuid=_user_uuid)
        _row.async_delete()
        _row.delete_redis_keys(_redis)
        return True
Esempio n. 3
0
    def _create_data(self, _request):
        from ppmessage.db.models import AppUserData
        _user_uuid = self._user_uuid
        _app_uuid = self._app_uuid

        _row = AppUserData(uuid=str(uuid.uuid1()),
                           app_uuid=_app_uuid,
                           user_uuid=_user_uuid,
                           is_service_user=True,
                           is_owner_user=True,
                           is_portal_user=False)
        _row.create_redis_keys(self.application.redis)
        _insert_into(_row)
        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

        _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
Esempio n. 5
0
 def _create_data(self, _request):
     from ppmessage.db.models import AppUserData
     _user_uuid = self._user_uuid
     _app_uuid = self._app_uuid
     
     _row = AppUserData(
         uuid=str(uuid.uuid1()),
         app_uuid = _app_uuid,
         user_uuid=_user_uuid,
         is_service_user = True,
         is_owner_user = True,
         is_portal_user = False                                    
     )
     _row.create_redis_keys(self.application.redis)
     _row.async_add(self.application.redis)
     return True
Esempio n. 6
0
    def _create(self):
        _redis = self.application.redis
        _request = json.loads(self.request.body)
        _user_uuid = _request.get("user_uuid")
        _app_name = _request.get("app_name")

        if _user_uuid == None or _app_name == None:
            self.setErrorCode(API_ERR.NO_PARA)
            return

        _app_key = str(uuid.uuid1())
        _app_secret = str(uuid.uuid1())
        _app_uuid = str(uuid.uuid1())
        _user_email = _redis.hget(
            DeviceUser.__tablename__ + ".uuid." + _user_uuid, "user_email")
        _company_name = _redis.hget(
            DeviceUser.__tablename__ + ".uuid." + _user_uuid, "user_company")

        _app_values = {
            "uuid": _app_uuid,
            "user_uuid": _user_uuid,
            "app_name": _app_name,
            "app_key": _app_key,
            "app_secret": _app_secret,
            "app_billing_email": _user_email,
            "offline_message": PPCOM_OFFLINE["zh_cn"],
            "welcome_message": PPCOM_WELCOME["zh_cn"],
            "app_route_policy": APP_POLICY.BROADCAST,
            "show_ppcom_hover": SHOW_PPCOM_HOVER.NEVER,
            "ppcom_launcher_style": PPCOM_LAUNCHER_STYLE.DEFAULT,
        }

        if _company_name != None and len(_company_name) > 0:
            _app_values["company_name"] = _company_name

        _row = AppInfo(**_app_values)
        _row.async_add()
        _row.create_redis_keys(_redis)

        _data_uuid = str(uuid.uuid1())
        _data = {
            "uuid": _data_uuid,
            "user_uuid": _user_uuid,
            "app_uuid": _app_uuid,
            "is_owner_user": True,
            "is_service_user": True,
            "is_distributor_user": True,
            "is_portal_user": False
        }
        _row = AppUserData(**_data)
        _row.async_add()
        _row.create_redis_keys(_redis)

        # create api_info
        self._create_kefu_client_apiinfo(_user_uuid, _app_uuid)
        self._create_console_client_apiinfo(_user_uuid, _app_uuid)

        _r = self.getReturnData()
        _r.update(_app_values)
        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
Esempio n. 8
0
    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
Esempio n. 9
0
def _create_bootstrap_team_data(_session, _config):
    _user_config = _config.get("user")
    _team_config = _config.get("team")
    _data = AppUserData(
        uuid=str(uuid.uuid1()),
        user_uuid=_user_config.get("user_uuid"),
        app_uuid=_team_config.get("app_uuid"),
        is_service_user=True,
        is_owner_user=True,
        is_distributor_user=True,
        is_portal_user=False,
    )
    _session.add(_data)
    _session.commit()
    return _config
Esempio n. 10
0
def create_app(_handler, _app_name, _user_uuid):
    _redis = _handler.application.redis

    _app_key = str(uuid.uuid1())
    _app_secret = str(uuid.uuid1())
    _app_uuid = str(uuid.uuid1())
    _user_email = _redis.hget(DeviceUser.__tablename__ + ".uuid." + _user_uuid,
                              "user_email")
    _company_name = _redis.hget(
        DeviceUser.__tablename__ + ".uuid." + _user_uuid, "user_company")

    _app_values = {
        "uuid": _app_uuid,
        "user_uuid": _user_uuid,
        "app_name": _app_name,
        "app_key": _app_key,
        "app_secret": _app_secret,
        "app_billing_email": _user_email,
        "app_route_policy": APP_POLICY.BROADCAST,
    }

    if _company_name != None and len(_company_name) > 0:
        _app_values["company_name"] = _company_name

    _row = AppInfo(**_app_values)
    _row.async_add()
    _row.create_redis_keys(_redis)

    _data_uuid = str(uuid.uuid1())
    _data = {
        "uuid": _data_uuid,
        "user_uuid": _user_uuid,
        "app_uuid": _app_uuid,
        "is_owner_user": True,
        "is_service_user": True,
        "is_distributor_user": True,
        "is_portal_user": False
    }
    _row = AppUserData(**_data)
    _row.async_add()
    _row.create_redis_keys(_redis)

    # create api_info
    _create_kefu_client_apiinfo(_handler, _user_uuid, _app_uuid)
    _create_console_client_apiinfo(_handler, _user_uuid, _app_uuid)
    return _app_values
    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
Esempio n. 12
0
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 _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
Esempio n. 14
0
    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
Esempio n. 15
0
    def _remove(self):
        _redis = self.application.redis

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

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

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

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

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

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

        _row = AppInfo(uuid=_app_uuid)
        _row.async_delete(_redis)
        _row.delete_redis_keys(_redis)
        return
Esempio n. 16
0
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