async def patch(self, request): try: user_id = await get_user_id_by_request(request) data = request.json new_data = {} for k, v in data.items(): if k not in self.fields: continue new_data[k] = v for k, v in new_data.items(): if k in self.unique: res = await self.user_model.check_unique_simple_field(k, v) if res is False: raise InvalidUsage("{} 已被使用".format(v)) # name need update to follow and friend collection doc = await self.user_model.update_by_id(user_id, new_data) if not doc: return response.json(response_package("500", {"error_id": str(user_id)})) for k, v in new_data.items(): if k in self.update_to_friend_follow: await update_server.update_name(k, v, user_id, self.follower_model, self.friends_model, app, self.user_model) data = await UserReadModel(data=doc, status="").to_dict() return response.json(response_package("200", data)) except TimeoutError as e: return response.json(response_package("999", {"e": str(e)}))
async def post(self, request): try: user_id = await get_user_id_by_request(request) new_password = request.json.get("new_password", None) old_password = request.json.get("old_password", None) print(request.json) assert old_password, "原始密码未填写" assert new_password, "新密码未填写" doc = await check_server.is_user(user_id, self.user_model) assert doc["password"] == gen_password(old_password), "原始密码不对" await self.user_model.update_password(user_id, gen_password(new_password)) return response.json(response_package("200", {})) except TimeoutError as e: return response.json(response_package("999", {"e": str(e)}))
async def get(self, request): """ get followers following friend user list :param request: :return: search_type = """ # print(dir(request)) # print(dir(request.get)) login_user_id = await get_user_id_by_request(request) data = parameter_check.search_user_check(request.raw_args) model = self.MAPPING[data["type"]] schema = self.SchemaMapping[data["type"]] data_list = await search_service.search_user(model, data) # if data["type"] == "user": res_data = schema(many=True).dump(data_list).data for tmp in res_data: print(data["user_id"], str(tmp["user_id"])) tmp["is_i_follow_him"] = await self.follower_model.check_user1_is_following_user2( login_user_id, str(tmp["user_id"])) tmp["is_friend"] = await self.follower_model.check_is_mutual_follow( login_user_id, str(tmp["user_id"])) tmp = await head_portrait_change_change_change( tmp, "user_head_portrait") print("data_list is ", data_list) print("res_data is ", res_data) # data_list, need serializers return response.json(response_package("200", {"data_info": res_data})) pass
async def check_registered_phone(self, registered_phone): res = await self.user_model.find_by_registered_phone( registered_phone=registered_phone) if res is not False: raise exceptions.AuthenticationFailed("手机号已被注册") else: return json(response_package("200", "手机号未被注册"))
async def post(self, request, *args, **kwargs): """ generate two tokes depending on the login device. :param request: :param args: :param kwargs: :return: """ request, args, kwargs = await self.do_incoming(request, args, kwargs) config = self.config user = await utils.call(self.instance.auth.authenticate, request, *args, **kwargs) user_id = await utils.call(self.instance.auth._get_user_id, user) print("user_id ", user_id) login_device = await get_login_device(request) print("login device ", login_device) token = await app.redis.get("{}_{}".format(login_device, user_id)) if token: await product_server.send_someone_else_logged_to_message( app, user_id) access_token, output = await self.responses.get_access_token_output( request, user, self.config, self.instance) await app.redis.set("{}_{}".format(login_device, user_id), access_token, expire=EXPIRATION_DELTA) if config.refresh_token_enabled(): refresh_token = await utils.call( self.instance.auth.generate_refresh_token, request, user) output.update({config.refresh_token_name(): refresh_token}) else: refresh_token = None output.update( self.responses.extend_authenticate( request, user=user, access_token=access_token, refresh_token=refresh_token, )) output = await self.do_output(output) output.update({"user_info": user}) output = response_package("200", output) print("output is ", output) logger.info(output, await get_extra(request)) resp = self.responses.get_token_reponse( request, access_token, output, refresh_token=refresh_token, config=self.config, ) resp.cookies["user_id"] = user.get("user_id", None) await send_kafka_server.send_to(app, "user", "login", user) # await self.send_login_info_to_kafka(user) return await self.do_response(resp)
async def process_exception(request, exception): status_code = str(getattr(exception, "status_code", "500")) # return json(response_package(status_code, exception.args)) print(exception.args) message = format_res(exception.args) return response.json( response_package(str(status_code), results=str(exception.args), message=message))
async def post(self, request, *args, **kwargs): # check captcha captcha_key = request.json.get("captcha_mark", None) captcha_num = request.json.get("captcha", None) assert captcha_key, "验证码未填写" await self.check_captcha(captcha_key, captcha_num) registered_phone = request.json.get('registered_phone', None) password = request.json.get('password', None) print("request ---------------------") # # print(dir(request)) print(request.cookies) helper = MyCustomUserAuthHelper() user = await helper.register_new_user( registered_phone=registered_phone, password=password) await send_kafka_server.send_to(app=app, topic="user", message_type="register", body=user) init_redis = InitRedis(app.redis, UserModel(app.mongo["account_center"].user)) await init_redis.init_registered_info_to_redis(user) access_token, output = await self.responses.get_access_token_output( request, user, self.config, self.instance) refresh_token = await self.instance.auth.generate_refresh_token( request, user) output.update({self.config.refresh_token_name(): refresh_token}) user_id = user.get("user_id", None) key = "refresh_token_{user_id}".format(user_id=user_id) res = await app.redis.set(key, refresh_token) login_device = await get_login_device(request) await app.redis.set("{}_{}".format(login_device, user_id), access_token, expire=EXPIRATION_DELTA) output.clear() output.update( response_package( "200", { "access_token": access_token, "refresh_token": refresh_token, "user_info": user }), ) response = self.responses.get_token_reponse( request, access_token, output, refresh_token=refresh_token, config=self.config) # print(response.headers) # print(response) return response
async def post(self, request, *args, **kwargs): request, args, kwargs = await self.do_incoming(request, args, kwargs) # TODO: # - Add more exceptions payload = self.instance.auth.extract_payload(request, verify=False) user = await utils.call(self.instance.auth.retrieve_user, request, payload=payload, only_user=True) user_id = await self.instance.auth._get_user_id(user) refresh_token = await utils.call( self.instance.auth.retrieve_refresh_token, request=request, user_id=user_id, ) if isinstance(refresh_token, bytes): refresh_token = refresh_token.decode("utf-8") purported_token = await self.instance.auth.retrieve_refresh_token_from_request( request) if refresh_token != purported_token: raise exceptions.AuthenticationFailed() access_token, output = await self.responses.get_access_token_output( request, user, self.config, self.instance) output = response_package("200", output) output.update( self.responses.extend_refresh( request, user=user, access_token=access_token, refresh_token=refresh_token, purported_token=purported_token, payload=payload, )) output = await self.do_output(output) # in this time, You need to refresh device token login_device = await get_login_device(request) await app.redis.set("{}_{}".format(login_device, user_id), access_token, expire=EXPIRATION_DELTA) resp = self.responses.get_token_reponse(request, access_token, output, config=self.config) return await self.do_response(resp)
async def get(self, request, user_id): try: login_user_id = await get_user_id_by_request(request) except MissingAuthorizationHeader as e: login_user_id = False doc = await check_server.is_user(user_id, self.user_model) data = await UserReadModel(data=doc, status="").to_dict() if login_user_id: is_friend = await self.follower_model.check_is_mutual_follow(login_user_id, user_id) is_i_following_him = await self.follower_model.check_user1_is_following_user2(login_user_id, user_id) data["is_friend"] = is_friend data["is_i_following_him"] = is_i_following_him else: data["is_friend"] = False data["is_i_following_him"] = False return response.json(response_package("200", data))
async def post(self, request): """ add logging user following follow_user_id data = {"following_user_id": ""} :param request: :return: """ # param check # print(" user_id ", user.user_id) login_user_id = await get_user_id_by_request(request) if not login_user_id: raise AuthenticationFailed() # assert login_user_id, following_user_id = request.json.get("following_user_id", None) assert following_user_id, "参数不能为空" assert login_user_id != following_user_id, ( "关注错误,自己不能关注自己", "login_user_id {}, following_user_id {}".format(login_user_id, following_user_id)) # 1 check user id is real user await check_server.is_user(following_user_id, self.user_model) # 2 update or created follow relationship in mongo # count = self.follower_model.update_or_created_follow_relationship() # write follower collection server await write_model_server.write_follower_relationship(app, self.follower_model, self.user_model, self.friends_model, login_user_id, following_user_id) # res = await self.follower_model.update_or_created_follow_relationship_by_data(login_user_id, following_user_id) # if res is not "existed": # # if login id have not follow relationship. then inc following and followers count # # 3 a->b check, a is <- b, then add friend relationship # if await self.follower_model.check_is_mutual_follow(login_user_id, following_user_id): # await self.friends_model.add(login_user_id, following_user_id) # await app.redis.sadd("{}_{}".format(login_user_id, "friends"), following_user_id) # await app.redis.sadd("{}_{}".format(following_user_id, "friends"), login_user_id) # # # 4 update or created follow redis # await self.user_model.add_follow_count(login_user_id, following_user_id) # if isinstance(following_user_id, bytes): # following_user_id = following_user_id.decode() # await app.redis.sadd("{}_{}".format(login_user_id, "follower"), following_user_id) return json(response_package("200", {}))
async def get(self, request): # return captcha address, and set a redis k-v, and set k to redis , theme = request.raw_args.get("theme", "dark") uuid = random_str(32) x = CreateCaptcha(theme) image = x.gene_code() buffer = BytesIO() image.save(buffer, format='png') img_str = base64.b64encode(buffer.getvalue()) await app.redis.set(str(uuid), str(x.text), expire=CAPTCHA_TIMEOUT) response = json( response_package("200", { "image_b64data": img_str, "captcha": uuid })) # response.cookies["captcha"] = str(uuid) return response
async def get(self, request): """ :param request: :return: """ print("begin logout ") payload = self.instance.auth.extract_payload(request, verify=False) # user = await utils.call( # self.instance.auth.retrieve_user, request, payload=payload # ) user_id = payload.get("user_id", None) # user_id = await self.instance.auth._get_user_id(user) logout_result = await utils.call( self.instance.auth.logout, request=request, user_id=user_id, ) login_device = await get_login_device(request) await app.redis.delete("{}_{}".format(login_device, str(user_id))) return response.json(response_package("200", {}))
async def post(self, request): """ add logging user following follow_user_id data = {"following_user_id": ""} :param request: :return: """ # param check login_user_id = await get_user_id_by_request(request) assert login_user_id, "当前没有用户登录" following_user_id = request.json.get("un_following_user_id", None) assert following_user_id, "参数不能为空" assert login_user_id != following_user_id, ( "取消关注错误,自己不能对自己操作", "login_user_id {}, following_user_id {}".format(login_user_id, following_user_id)) # 1 check user id is real user await check_server.is_user(following_user_id, self.user_model) # 2 update or created follow relationship in mongo # count = self.follower_model.update_or_created_follow_relationship() await write_model_server.write_unfollower_relationship(app, self.follower_model, self.user_model, self.friends_model, login_user_id, following_user_id) # res = await self.follower_model.update_or_created_follow_relationship(login_user_id, following_user_id) # await self.follower_model.delete_follow_relationship(login_user_id, following_user_id) # if res is not "is_null": # # if login id have not follow relationship. then inc following and followers count # # 3 delete friend relationship # await self.friends_model.remove(login_user_id, following_user_id) # await app.redis.srem("{}_{}".format(login_user_id, "friends"), following_user_id) # await app.redis.srem("{}_{}".format(following_user_id, "friends"), login_user_id) # # # 4 update or created redis # await self.user_model.sub_follow_count(login_user_id, following_user_id) # await app.redis.srem("{}_{}".format(login_user_id, "follower"), count=1, value=following_user_id) return json(response_package("200", {}))