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", {}))
