async def check_exercise(user_result: int, user=Depends(get_user)):
exercise: Exercises = db.query(Exercises).filter(Exercises.user_id == user.id).first()
if exercise is None:
return {
'status': 400,
'message': 'Exercise does not exists'
}
duration = 1 # TODO Measure Duration in the backend
points = 1 if exercise.result == user_result else 0 # TODO Calculate Points with the Duration
evaluation = db.query(Evaluation).filter(Evaluation.user_id == 0,
Evaluation.factor1 == exercise.factor1,
Evaluation.factor2 == exercise.factor2).first()
if evaluation is None:
user = db.query(User).filter(User.id == user.id).first()
evaluation = Evaluation(user, exercise.factor1, exercise.factor2, points)
db.add(evaluation)
db.commit()
else:
db.query(Evaluation).filter(Evaluation.id == evaluation.id).update({
Evaluation.points: evaluation.points + points,
Evaluation.count: evaluation.count + 1,
})
db.commit()
return {
'status': 200,
'result': exercise.result == user_result
}
async def rank_get(user=Depends(get_user)):
users_db = db.query(User).all()
ranklist = []
for user in users_db:
evaluations = db.query(Evaluation).filter(
Evaluation.user_id == user.id).all()
ranklist.append({
'username': user.username,
'points': calculatePoints(evaluations)
})
return ranklist
async def generate_exercise(user=Depends(get_user)):
factor1, factor2 = (await generateExercise(user.id)).values()
if db.query(Exercises).filter(Exercises.user_id == user.id).first() is None:
user_db = db.query(User).filter(User.id == user.id).first()
db.add(Exercises(user_db, factor1, factor2))
else:
db.query(Exercises).filter(Exercises.user_id == user.id).update({Exercises.factor1: factor1,
Exercises.factor2: factor2,
Exercises.result: factor1 * factor2})
db.commit()
return {
'factor1': factor1,
'factor2': factor2
}
def staty_plan_edit():
messages = ""
category = ""
form = request.form
try:
user = db.query(StudyPlan).get(form.get('id'))
# user.one()
user.name = form.get('name')
user.start_date = form.get('start_date')
db.commit()
messages = "La informacion fue editada exitosamente!"
category = "success"
except ValueError as e:
raise e
messages = "Ha ocurrido un error desconocido!"
category = "error"
finally:
flash(messages, category)
return redirect(url_for('users.plan_de_estudio'))
async def signup(body: RequestBody, response: Response):
username = body.username
name = body.name
password_hash = hashlib.sha256(str.encode(body.password)).hexdigest()
# Check if username already exists
exists = db.query(User).filter_by(username=username).first()
if exists:
response.status_code = status.HTTP_409_CONFLICT
return {"result": "fail", "reason": "Username already taken"}
user = User(username=username, name=name, password_hash=password_hash)
db.add(user)
db.commit()
payload = {
"exp": datetime.utcnow() + timedelta(days=0, hours=24),
"iat": datetime.utcnow(),
"iss": username,
}
token = jwt.encode(payload, ACCESS_TOKEN_KEY, algorithm="HS256")
content = {"result": "ok"}
response = JSONResponse(content=content)
response.headers["X-AUTH-TOKEN"] = f"{token}"
return response
def study_plan_goals(id):
args = request.args.get('goals')
find = "all"
get_goals = db.query(StudyPlanGoals).\
join(StudyPlan, StudyPlanGoals.plan_id == StudyPlan.id).\
filter(StudyPlanGoals.state == 1).\
filter(StudyPlan.id == id).\
filter(StudyPlan.state == 1).\
filter(StudyPlan.user_id == current_user.id)
if args == 'all':
goals = get_goals.all()
elif args == 'finished':
find = 1
goals = get_goals.filter(StudyPlanGoals.done == 1)
elif args == 'pending':
find = 0
goals = get_goals.filter(StudyPlanGoals.done == 0)
else:
goals = get_goals.all()
return render_template('user/stady_plan_goals.html.j2',
title='Studies plan goals -',
goals=goals,
plan_id=id,
find=find)
def get(self):
libraries = db.query(Library).all()
for library in libraries:
library.province = library.location_road[0:2]
return libraries
def get_or_404(model_clazz, pk):
instance = db.query(model_clazz).filter_by(_id=pk).first()
if instance is None:
raise DataNotFoundError("{} {} Not found".format(
model_clazz.__name__, pk))
return instance
async def register_user(username: str, password: str):
if db.query(User).filter(User.username == username).first():
raise HTTPException(status_code=409, detail='Username already exists')
user = User(username, pwd_context.hash(password))
db.add(user)
db.commit()
return Response('Created User.', 201)
def study_plan(value, **kwargs):
get_plan = db.query(StudyPlan).\
filter(StudyPlan.user_id == current_user.id).\
filter(StudyPlan.state == 1)
progress = 0
if 'done' in kwargs:
if kwargs.get('done') == 1:
return get_plan.filter(StudyPlan.done == 1).count()
elif kwargs.get('done') == 0:
return get_plan.filter(StudyPlan.done == 0).count()
else:
return get_plan.count()
if 'progress' in kwargs:
if kwargs.get('progress') == 1:
done = get_plan.filter(StudyPlan.done == 1).count()
total = get_plan.count()
try:
progress = (done * 100) / total
except ZeroDivisionError as e:
raise e
finally:
return progress
else:
return ValueError('Error in the key word')
return get_plan.count()
async def get_list(start_date: datetime,
end_date: datetime,
current_user: UserModel = Depends(get_current_active_user)):
query = db.query(Bill).filter(Bill.date.between(start_date,
end_date)).all()
print(query)
return {"list": query}
def add_qualification():
form = QualificationForm()
if form.validate_on_submit():
id = form.id.data
try:
qualification = db.query(Courses).filter(Courses.id == id)
new = qualification.one()
new.qualification = request.form['calificacion']
db.commit()
messages = 'La operacion se realizo con exito!'
category = 'success'
except ValueError as e:
messages = 'No fue posible completar la operacion!'
category = 'error'
raise e
flash(messages, category)
return redirect(url_for('users.subjects_finished'))
def courses(value, **kwargs):
filtro = db.query(Courses).\
filter(Courses.user_id == current_user.id).\
filter(Courses.state == 1)
progress = 0
if 'finished' in kwargs:
if kwargs.get('finished') == 0:
return filtro.filter(Courses.finished == 0).count()
if kwargs.get('finished') == 1:
return filtro.filter(Courses.finished == 1).count()
else:
return filtro.count()
if 'progress' in kwargs:
if kwargs.get('progress') == 1:
total = filtro.count()
finished = filtro.filter(Courses.finished == 1).count()
try:
progress = (finished * 100) / total
except ZeroDivisionError as e:
raise e
finally:
return progress
else:
return 0
def study_plan_goals(id, **kwargs):
get_goals = db.query(StudyPlanGoals).\
join(StudyPlan, StudyPlanGoals.plan_id == StudyPlan.id).\
filter(StudyPlanGoals.state == 1).\
filter(StudyPlan.id == id).\
filter(StudyPlan.state == 1).\
filter(StudyPlan.user_id == current_user.id)
progress = 0
if 'done' in kwargs:
if kwargs.get('done') == 1:
return get_goals.filter(StudyPlanGoals.done == 1).count()
elif kwargs.get('done') == 0:
return get_goals.filter(StudyPlanGoals.done == 0).count()
else:
return get_goals.count()
if 'progress' in kwargs:
if kwargs.get('progress') == 1:
done = get_goals.filter(StudyPlanGoals.done == 1).count()
total = get_goals.count()
try:
progress = (done * 100) / total
except ZeroDivisionError as e:
raise e
finally:
return progress
return get_goals.count()
def plan_de_estudio():
args = request.args.get('plan')
find = 'both'
get_plan = db.query(StudyPlan).\
filter(StudyPlan.user_id == current_user.id). \
filter(StudyPlan.state == 1).\
options(contains_eager(StudyPlan.user))
if args == 'all':
plan = get_plan.all()
elif args == 'finished':
find = 1
plan = get_plan.filter(StudyPlan.done == 1)
elif args == 'pending':
find = 0
plan = get_plan.filter(StudyPlan.done == 0)
else:
plan = get_plan.all()
return render_template('user/stady_plan.html.j2',
title='Studies plan -',
stady_plan=plan,
find=find)
async def refresh_route(refresh_token: str):
refresh_tokens = redis.lrange('refresh_tokens', 0,
redis.llen('refresh_tokens'))
if refresh_token.encode('utf-8') not in refresh_tokens:
print('NOT IN CACHE')
raise HTTPException(status_code=401, detail='Invalid Refresh Token')
try:
refresh_data = jwt.decode(refresh_token,
SECRET_KEY,
algorithms=[ALGORITHM])
except jwt.exceptions.InvalidTokenError as e:
if isinstance(e, jwt.exceptions.ExpiredSignatureError):
raise HTTPException(status_code=401,
detail='Refresh Token is expired')
else:
raise HTTPException(status_code=401,
detail='Refresh Token is invalid')
user = db.query(User).filter(User.id == refresh_data['userid']).first()
access_token_data = {
"user": {
"id": user.id,
"username": user.username,
"admin": user.admin
}
}
access_token = create_access_token(access_token_data)
return {"access_token": access_token, "token_type": "bearer"}
def tasks():
get_task = db.query(Tasks).\
filter(Tasks.user_id == current_user.id).\
filter(Tasks.state == 1)
args = request.args.get('tasks')
find = "all"
if args == "all":
task = get_task.all()
elif args == "finished":
find = 1
task = get_task.filter(Tasks.done == 1)
elif args == "pending":
find = 0
task = get_task.filter(Tasks.done == 0)
else:
task = get_task.all()
return render_template('user/all_tasks.html.j2',
title='Tasks -',
task_user=task,
find=find)
def teachers(id, n=1):
filtro = db.query(Teachers).\
filter(Teachers.user_id == current_user.id).\
filter(Teachers.state == n)
return filtro
def assing_teacher():
form = AssignForm()
if form.validate_on_submit():
# name = form.profe.data
id_teacher = request.form['profe']
id_subject = form.id.data
try:
update = db.query(Courses).\
filter(Courses.user_id == current_user.id)\
.filter(Courses.id == id_subject)
new_teacher = update.one()
new_teacher.Teachers_id = id_teacher
db.commit()
messages = 'La operacion se realizo con exito!'
category = 'success'
except ValueError as e:
raise e
messages = 'Ha ocurrido un error!'
category = 'error'
flash(messages, category)
return redirect(url_for('users.subjects'))
def teachers():
teacher = db.query(Teachers).filter(
Teachers.user_id == current_user.id).all()
return render_template('user/teachers.html.j2',
title="Teachers -",
teachers=teacher)
def details_task(id):
details = db.query(Tasks).filter(Tasks.id == id).\
options(contains_eager(Tasks.user)).one()
return render_template('user/details_task.html.j2',
title='details -',
details=details)
def edit_tasks(id):
datos = db.query(Tasks).filter(Tasks.user_id == current_user.id).\
filter(Tasks.id == id).one()
return render_template('user/edit/edit_tasks.html.j2',
title='Edit tasks -',
edit_data=datos)
async def fetch_all(username: str, resp: Response):
# TODO: Add token validation part
models = db.query(DeployedModel).join(User).filter(User.username == username).all()
if not models:
resp.status_code = status.HTTP_404_NOT_FOUND
return {"result": "fail", "reason": "No models found for given username"}
return {"result": "ok", "models": models}
async def generateExercise(user_id):
evaluation_query = db.query(Evaluation).filter(Evaluation.user_id == user_id).order_by(Evaluation.points.asc())
exercises = []
if len(evaluation_query.all()) >= 3:
for evaluation in evaluation_query.all()[:3]:
exercises.append({"factor1": evaluation.factor1, "factor2": evaluation.factor2})
exercises.append({"factor1": random.randint(2, 10), "factor2": random.randint(2, 10)})
return random.choice(exercises)
async def register(new_user: UserModel):
"""register a new user"""
if db.query(User).get(new_user.name) is not None:
raise HTTPException(status_code=422, detail="Username already in use")
new_user.password = get_password_hash(new_user.password)
db.add(User(name=new_user.name, password=new_user.password))
db.commit()
return {"action": "successful"}
async def evaluations_get(user=Depends(get_user)):
evaluations = db.query(Evaluation).filter(Evaluation.user_id == user.id).order_by(Evaluation.points.desc()).all()
return [
{
"factor1": evaluation.factor1,
"factor2": evaluation.factor2,
"points": evaluation.points,
"count": evaluation.count,
}
for evaluation in evaluations
]
async def fetch_one(uid: str, resp: Response):
# TODO: Choose between .first() and .one() to fetch a model.
# Using .one() throws an exception for zero or >1 results, hence using .first().
model = (db.query(
DeployedModel.name, DeployedModel.description,
User.username).join(User).filter(DeployedModel.uid == uid).first())
if not model:
resp.status_code = status.HTTP_404_NOT_FOUND
return {"result": "fail", "reason": "No model found for given UID"}
return {"result": "ok", "model": model}
async def log_add(factor1: int,
factor2: int,
user_result: int,
duration: int,
user=Depends(get_user)):
user_db = db.query(User).filter(User.id == user.id).first()
db.add(
LogEntry(user_db, factor1, factor2, user_result,
factor1 * factor2 == user_result, duration))
db.commit()
return {'message': 'Created Log', 'status': 201}
async def log_get(user=Depends(get_user)):
result: list[LogEntry] = db.query(LogEntry).filter(
LogEntry.user_id == user.id).all()
return [{
'id': row.id,
'factor1': row.factor1,
'factor2': row.factor2,
'user_result': row.user_result,
'correct': row.correct,
'timestamp': row.timestamp,
'duration': row.duration
} for row in result]
def courses(id):
get_task = db.query(Tasks).\
filter(Tasks.user_id == current_user.id). \
filter(Tasks.course_id == id). \
filter(Tasks.state == 1)
courses = db.query(Courses).\
filter(Courses.user_id == current_user.id).\
filter(Courses.id == id).first()
find = "both"
if 'tasks' in request.args:
args = request.args.get('tasks')
if args == 'finished':
find = 1
task = get_task.filter(Tasks.done == 1).all()
elif args == 'all':
task = get_task.all()
elif args == 'pending':
find = 0
task = get_task.filter(Tasks.done == 0).all()
else:
task = get_task.all()
else:
task = get_task.all()
return render_template('user/courses.html.j2',
title='Courses: {}'.format(courses.name),
course=courses,
assignments=task,
course_id=id,
find=find)
