def get(cls):
response = github.authorized_response()
if response is None or response.get("access_token") is None:
error_response = {
"error": request.args["error"],
"error_description": request.args["error_description"]
}
return error_response
g.access_token = response["access_token"] #access token is made global
github_user = github.get("user") #user information object
github_username = github_user.data["login"] #get github users username
github_email = github_user.data["email"]
#if UserModel.find_by_username(github_username):
# return {"msg": "User with username exists"}
#add user to database
user = UserModel(username=github_username,
password=GithubAuthorize.generate_sample_password(),
activated=True,
email=github_email)
user.save_to_db()
#create jwt tokens
access_token = create_access_token(identity=user.id, fresh=True)
refresh_token = create_refresh_token(user.id)
return {
"access_token": access_token,
"refresh_token": refresh_token
}, 200
def auth(username, password):
user = UserModel.find_by_username(username)
password = password.encode('utf-8')
print(password)
if UserModel.check_password(username, password):
return user
else:
return None
def post(self):
try:
data = user_schema.load(request.get_json())
except ValidationError as err:
return err.messages,400
username = data.username
passwd = data.password
email = data.email
print(username,passwd,email)
hashed = bcrypt.hashpw(passwd.encode('utf-8'),bcrypt.gensalt())
if UserModel.find_by_username(username):
return {"msg": "user with username exists"}
if UserModel.find_by_email(email):
return {"msg": "user with email id exists"}
user = UserModel(username,hashed,email)
user.save_to_db()
user.generate_mail() #send emails to new users
return {
"msg": "user saved successfully"
}
def post(self) -> object:
data = user_parser.parse_args()
user = UserModel.find_by_username(data["username"])
if user:
return {"message": "User already exists"}, 400
elif len(data["username"]) < 5:
return {"message": "Username must be 5 characters or longer"}, 400
elif len(data["password"]) < 6:
return {
"message": "Password must be more than 6 characters long"
}, 400
else:
user = UserModel(data["username"], data["password"])
user.save_to_db()
return {"message": "User created successfully"}, 201
def get(cls,user_id):
user = UserModel.find_by_id(user_id)
if not user:
return {"msg": "User not found"},404
user.delete_from_db()
return {"msg": "user deleted successfully"}
def post(self):
params = _user_parser.parse_args()
user = UserModel.find_by_username(params['username'])
if user:
return {"msg": f"{user.username} already exists"}, 400
user_model = UserModel(**params)
try:
user_model.save()
except:
return {"msg": f"{params['username']} save fails"}, 400
data = {
'id': user_model.id,
'username': user_model.username,
'room_private': user_model.room_private,
}
return data, 200
def get(self) -> object:
user_id = get_jwt_identity()
user = UserModel.find_by_id(user_id)
if user:
return user.json()
else:
return {"message": "User not found"}, 404
def get(self):
sets = get_online_uids()
if sets is None:
return {}, 200
result = []
for uid in sets:
result.append(UserModel.find_by_id(uid).to_json())
return jsonify(result), 200
def get(self):
params = _user_parser.parse_args()
page = params['page']
per_page = params['per_page']
print('Accounts--get----{}----{}'.format(page, per_page))
items = UserModel.find_paginate(**params).items
result = []
for item in items:
result.append(item.to_json())
return jsonify(result), 200
def on_disconnect():
sid = request.sid
uid = get_uid_with_sid(sid)
remove_online_uids(uid)
user = UserModel.find_by_id(uid)
print('Client disconnected--{}--{}--{}'.format(sid, uid, user.to_json()))
message = Message('disconnect_broadcast', MESSAGE_TYPE.MESSAGE_BROADCAST.value, False,
int(round(time.time() * 1000)), user.room_private, user.room_private, uid, uid)
message.save()
async_emit_msg.delay('disconnect_broadcast', message.to_json(), broadcast=True)
def get(self,token):
try:
serializer = URLSafeTimedSerializer("secrettoken")
email = serializer.loads(token,salt="flask-email-confirmation")["email"]
user = UserModel.find_by_email(email)
if not user:
return "<h1>Invalid User</h1>"
user.activated = True
user.save_to_db()
except:
return "<h1>Token is expired</h1>"
return "<h1>Token Verified</h1>"
def post(self):
try:
data = user_schema.load(request.get_json())
except ValidationError as err:
return err.messages,400
username = data.username
email = data.email
password = data.password
user = UserModel.find_by_username(username)
if user and UserModel.check_password(username,password):
if user.activated:
access_token = create_access_token(identity=user.id,fresh=True)
refresh_token = create_refresh_token(user.id)
return {
"access_token": access_token,
"refresh_token": refresh_token
},200
return {"msg": "User has not yet been activated"},401
return {"msg": "wrong creds"},401
def delete(self):
user = UserModel.find_by_id(get_jwt_identity())
if not user.seller:
return {"msg": "User is not a seller"}, 403
data = request.get_json()
name = data["name"]
store = StoreModel.find_by_name(name)
if store:
store.delete_from_db()
else:
return {"msg": "Store does not exist"}, 400
return {"msg": "Store deleted"}
def post(self) -> object:
data = user_parser.parse_args()
user = UserModel.find_by_username(data["username"])
# this is what the `authenticate()` function did in security.py
if user and argon2.verify(data["password"], user.password):
# identity= is what the identity()
# function did in security.py—now stored in the JWT
access_token = create_access_token(identity=user.id, fresh=True)
refresh_token = create_refresh_token(user.id)
return {
"access_token": access_token,
"refresh_token": refresh_token
}, 200
return {"message": "Invalid Credentials!"}, 401
def post(self):
params = _user_parser.parse_args()
user = UserModel.find_by_username(params['username'])
if user and safe_str_cmp(user.password, params['password']):
access_token = create_access_token(identity=user.id, fresh=True)
refresh_token = create_refresh_token(identity=user.id)
data = {
'access_token': access_token,
'refresh_token': refresh_token,
'id': user.id,
'username': user.username,
'room_private': user.room_private,
}
return data, 200
return {
"msg":
f"{params['username']} with password {params['password']} login fails"
}, 400
def post(self):
user = UserModel.find_by_id(get_jwt_identity())
if not user.seller:
return {"msg": "User is not a seller"}, 403
data = request.get_json()
name = data["name"]
store = StoreModel.find_by_name(name)
if store:
return {"msg": "Store exists already"}, 400
store = StoreModel(name=name)
try:
store.save_to_db()
except:
return {"msg": "Error occured"}, 500
return {"msg": "Added the store"}, 201
def identity(payload):
user_id = payload['identity']
return UserModel.find_by_id(user_id)
def get(cls,user_id):
user = UserModel.find_by_id(user_id)
if not user:
return {"msg": "User not found"},404
return user_schema.dump(user),200
