def show(id):
users = User.query.filter_by(id=id).first()
if not users:
raise NotFoundException("user with id {} not found".format(id))
data = singleTransform(users)
return responses.ok(data, "user found")
def index():
current_user = get_jwt_identity()
users = User.query
page = 1
per_page = 50
if request.args.get('page') is not None:
page = int(request.args.get('page'))
if request.args.get('per_page') is not None:
per_page = int(request.args.get('per_page'))
if request.args.get('name') is not None:
users = users.filter(
User.name.like("%{}%".format(request.args.get('name'))))
if request.args.get('username') is not None:
users = users.filter(
User.username.like("%{}%".format(request.args.get('username'))))
if request.args.get('email') is not None:
users = users.filter(
User.email.like("%{}%".format(request.args.get('email'))))
users = users.paginate(page, per_page, error_out=False)
if len(users.items) < 1 == True:
raise NotFoundException("user not found")
data = transform(users)
return responses.ok(data, 'success')
def show(id):
datasets = Dataset.query.filter_by(id=id).first()
if not datasets:
raise NotFoundException("dataset with id {} not found".format(id))
data = singleTransform(datasets)
return responses.ok(data, "dataset found")
def index():
current_dataset = get_jwt_identity()
datasets = Dataset.query
page = 1
per_page = 50
if request.args.get('page') is not None:
page = int(request.args.get('page'))
if request.args.get('per_page') is not None:
per_page = int(request.args.get('per_page'))
if request.args.get('context') is not None:
datasets = datasets.filter(
Dataset.context.like("%{}%".format(request.args.get('context'))))
if request.args.get('intent') is not None:
datasets = datasets.filter(
Dataset.intent.like("%{}%".format(request.args.get('intent'))))
if request.args.get('paragraph') is not None:
datasets = datasets.filter(
Dataset.paragraph.like("%{}%".format(
request.args.get('paragraph'))))
datasets = datasets.paginate(page, per_page, error_out=False)
if len(datasets.items) < 1 == True:
raise NotFoundException("dataset not found")
data = transform(datasets)
return responses.ok(data, 'success')
def show(id):
api = Apikey.query.filter_by(id=id).first()
if not api:
raise NotFoundException("api key with id {} is not found".format(id))
data = singleTransform(api)
return responses.ok(data, "api key found")
def refresh():
user = get_jwt_identity()
expires_refresh = datetime.timedelta(days=3)
new_token = create_access_token(identity=user, fresh=False)
refresh_token = create_refresh_token(user, expires_delta=expires_refresh)
return responses.ok({
"access_token": new_token
}, "successfully update access token")
def delete(id):
dataset = Dataset.query.filter_by(id=id).first()
if not dataset:
raise NotFoundException("dataset with id {} not found".format(id))
db.session.delete(dataset)
db.session.commit()
data = singleTransform(dataset)
return responses.ok(data, 'Successfully delete data!')
def delete(id):
api = Apikey.query.filter_by(id=id).first()
if not api:
raise NotFoundException("api key with id {} is not exist".format(id))
db.session.delete(api)
db.session.commit()
data = singleTransform(api)
return responses.ok(data, 'Successfully delete data!')
def delete(id):
user = User.query.filter_by(id=id).first()
if not user:
raise NotFoundException("user with id {} not found".format(id))
db.session.delete(user)
db.session.commit()
data = singleTransform(user)
return responses.ok(data, 'Successfully delete data!')
def update(id):
api = Apikey.query.filter_by(id=id).first()
if not api:
raise NotFoundException("api key with id {} is not found".format(id))
api.generateKey()
db.session.commit()
data = singleTransform(api)
return responses.ok(data, 'Successfully update data!')
def index(sentence):
result = {}
result = predict.predict(sentence)
if result is None:
result['intent'] = 'unknown'
response = Response.query.filter(Response.intent == result['intent']).all()
if not response:
result['response'] = 'Maaf jawaban belum tersedia'
else:
result['response'] = random.choice(response).response
data = singleTransform(result)
return res.ok(data, 'success')
def update(id):
dataset = Dataset.query.filter_by(id=id).first()
if not dataset:
raise NotFoundException("dataset with id {} not found".format(id))
if 'context' in request.json:
dataset.context = request.json['context']
if 'intent' in request.json:
dataset.intent = request.json['intent']
if 'paragraph' in request.json:
dataset.paragraph = request.json['paragraph']
db.session.commit()
data = singleTransform(dataset)
return responses.ok(data, 'Successfully update data!')
def update(id):
user = User.query.filter_by(id=id).first()
if not user:
raise NotFoundException("user with id {} not found".format(id))
if 'email' in request.json:
user.email = request.json['email']
if 'name' in request.json:
user.name = request.json['name']
if 'password' in request.json:
user.setPassword(request.json['password'])
db.session.commit()
data = singleTransform(user)
return responses.ok(data, 'Successfully update data!')
def index():
current_user = get_jwt_identity()
page = 1
per_page = 50
apis = Apikey.query
if request.args.get('page') is not None:
page = int(request.args.get('page'))
if request.args.get('per_page') is not None:
per_page = int(request.args.get('per_page'))
if (current_user['id'] is not None):
apis = apis.filter(Apikey.user_id == current_user['id'])
apis = apis.paginate(page, per_page, error_out=False)
if len(apis.items) < 1 == True:
raise NotFoundException("api key not found")
data = transform(apis)
return responses.ok(data, 'success')
def login():
username = request.json['username']
password = request.json['password']
user = User.query.filter_by(username=username).first()
if not user:
raise NotFoundException("username {} not exists".format(username))
if not user.checkPassword(password):
raise PasswordNotMatch("password didn't match")
data = singleTransform(user)
expires = datetime.timedelta(days=1)
print(expires, file=sys.stdout)
expires_refresh = datetime.timedelta(days=3)
access_token = create_access_token(
data, fresh=False, expires_delta=expires)
refresh_token = create_refresh_token(data, expires_delta=expires_refresh)
return responses.ok({
'data': data,
'access_token': access_token,
'refresh_token': refresh_token
}, "successfully logged in")
def delete(image_id, user):
"""
:param image_id:
:param user:
:return:
"""
original_image = OriginalImage.query.filter_by(id=image_id).one()
if not original_image:
# Check if the image exists
return not_found()
elif original_image.user_id != user.id:
# Check if the user has access to the image
return forbidden()
# Remove entry in EnhancedImage if it exists
enhanced_image = EnhancedImage.query.filter_by(original_id=image_id).one()
if enhanced_image:
EnhancedImage.remove_image(enhanced_image.id)
# Remove entry in OriginalImage
OriginalImage.remove_image(original_image.id)
return ok()
def getCategory():
category = Dataset.query.with_entities(Dataset.intent).distinct().all()
category = [row[0] for row in category]
return responses.ok(category, 'Successfully get dataset category')
def index():
training = TrainModel()
result = training.result
return res.ok(result, 'success')
