def get_user():
if request.method == 'POST':
data = request.get_json()
username = data['username']
password = data['password']
payload = {"username": username, "password": password}
response = requests.post('http://users:5000/login', json=payload)
if response.status_code == 200:
access_token = create_access_token(identity=username)
try:
new_token = TokenModel(username=username, token=access_token)
new_token.save_to_db()
except:
return {
'message': "An error occured inserting the token."
}, 500
return jsonify(access_token=access_token), 200
else:
return response.json(), 400
return "ss"
def delete(self, id):
if is_authentified()!=True:
return {'message': 'Unauthorized'}, 401
result = UserModel.get_user_by_id(id)
if result and is_user_connected(id):
TokenModel.delete_all_token_by_user_id(id)
UserModel.delete_user_by_id(id)
return {}, 204
elif result:
return {'message': 'Forbidden'}, 403
else:
return {'message': 'Not found'}, 404
def get(self):
"""get function of token
get all information of all token in db
:return information of request
"""
return TokenModel.return_all()
def patch(self):
"""patch function of token
Change the revoked status of a token in db
:return information of request
"""
data = parser_token_find.parse_args()
jti = data['jti']
if TokenModel.switch_revoked(jti):
update_token_in_memory()
return format_response(f'token with ${jti} changed', True)
return format_response('something went wrong', False)
def check_token():
token = None
if 'x-access-token' in request.headers:
token = request.headers['x-access-token']
if not token:
return jsonify({'message': 'Token is missing'}), 401
current_token = TokenModel.find_by_token(
token=request.headers.get('x-access-token'))
if current_token:
return current_token.get_token(), 200
return jsonify({'message': 'Token is invalid'}), 401
def delete(self):
"""delete function of token
delete a token in db
:return information of request
"""
data = parser_token_find.parse_args()
jti = data['jti']
if TokenModel.delete_by_jti(jti):
update_token_in_memory()
return format_response(f'token with ${jti} deleted', True)
return format_response('something went wrong', False)
def post(self):
"""post function of token
Create a new token
:return information of request
"""
data = parser_token_create.parse_args()
identity = data['identity']
date = data['date']
mode = data['mode']
if TokenModel.find_by_identity(identity):
return format_response('Token {} already exists'.format(identity), False)
# create model
new_token = TokenModel(
identity=escape(identity),
mode=mode,
revoked=False,
date=date
)
try:
# create token with request information
access_token = create_access_token(identity=new_token.identity,
expires_delta=datetime.timedelta(days=get_days(date)),
user_claims={'mode': new_token.mode})
# get information of token to put in the model
new_token.token = access_token
decode = decode_token(access_token)
new_token.jti = decode['jti']
# save model in db
new_token.save_to_db()
# update token in memory
update_token_in_memory()
return {
'message': 'Token {} was created'.format(identity),
'access_token': access_token,
'state': True
}
except Exception as e:
print(e)
return format_response('Something went wrong', False)
def create_user(email, password, group):
user = User.objects.create_user(
username=email,
email=email,
password=password,
)
country = Country.objects.first()
if group.pk == GroupEnum.DEVELOPER:
information = DeveloperInformation(
country=country,
developer=user
)
information.save()
user.groups.add(group)
token = TokenModel.create(user=user)
token.save()
return user, token
token_train_loader = torch.utils.data.DataLoader(
dataset=TokenDataset(df_train),
batch_size=config.batch_size,
shuffle=True,
num_workers=2,
drop_last=True)
token_val_loader = torch.utils.data.DataLoader(
dataset=TokenDataset(df_val),
batch_size=config.batch_size,
num_workers=2,
drop_last=True)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
token_model = TokenModel()
token_model.to(device)
dataloaders_dict = {
'train': token_train_loader,
'val': token_val_loader
}
optimizer = optim.AdamW(token_model.parameters(),
lr=config.token_lr,
betas=(0.9, 0.999))
criterion = loss_fn
print('Training Roberta for fold ' + str(fold))
train_token_model(token_model, device, dataloaders_dict, criterion,
optimizer, fold)
# Token model has been trained. Now we will use the best model to proceed for the character model.
def authenticate(username, password):
user = TokenModel.find_by_username(username)
if user and check_password_hash(user.password, password):
return user
def identity(payload):
token = payload['identity']
return TokenModel.find_by_token(token)