def resend_confirmation():
if not request.is_json:
raise NotValidRequestException("POST doesn't have payload.")
email = request.json.get('email', None)
username = request.json.get('username', None)
if not email:
raise MissingParametersException("Missing email.")
if not username:
raise MissingParametersException("Missing username.")
user = Users.query.filter_by(name=username, email=email).first()
if user and user.confirmed:
raise UserIsConfirmedException("User is confirmed", user)
token = generate_confirmation_token(user.email)
# confirm_url = url_for('auth.confirmation', token=token, _external=True)
confirm_url = 'http://localhost/register/confirmation?token=' + token.decode(
"utf-8")
send_email(user.email, confirm_url)
user_event = UserEvents(user, "confirmation email sender again")
db_session.add(user_event)
db_session.commit()
return user_schema.dump(user)
def add_agreements():
if not request.is_json:
raise NotValidRequestException("POST doesn't have JSON payload.")
agreement_id = request.json.get('agreement_id', None)
if not agreement_id:
raise MissingParametersException("Missing agreement_id.")
is_accepted = request.json.get('is_accepted', None)
current_user = get_jwt_identity()
user = Users.query.filter_by(public_id=current_user).first()
agreement = Agreements.query.filter_by(id=agreement_id).first()
existing_user_agreements = UserAgreements.query.filter_by(
user=user, agreement=agreement).first()
if existing_user_agreements:
raise CreatedRelationExistException(
"User has Agreement relation exist.")
user_agreements = UserAgreements(user=user,
agreement=agreement,
is_accepted=is_accepted)
user_agreements.is_read = True
db_session.add(user_agreements)
db_session.commit()
return jsonify(user_agreements_schema.dump(user_agreements))
def post():
if not request.json or not 'name' in request.json:
abort(400)
name = request.json['name']
platform_id = request.json['platform']
publisher_id = request.json['publisher']
course = Courses(name)
course.platform_id = platform_id
course.publisher_id = publisher_id
db_session.add(course)
db_session.commit()
# https://github.com/seek-ai/esengine
# https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-xvi-full-text-search
# es.index(index='courses', doc_type='title', id=course.id, body=json.dumps(course_search_schema.dump(course)))
# from flask import current_app
#
# message = json.dumps(json.dumps(course_search_schema.dump(course)))
#
# current_app.logger.info(current_app.topic.__dict__)
#
# with current_app.topic.get_producer() as producer:
# producer.produce(message.encode('ascii'))
return course_schema.dump(course)
def update(id):
publisher = Publishers.query.get(id)
publisher.name = request.json.get('name', publisher.name)
publisher.updated_on = func.now()
db_session.commit()
return jsonify(publisher_schema.dump(Publishers.query.get(id)))
def update(id):
platform = Platforms.query.get(id)
platform.name = request.json.get('name', platform.name)
platform.updated_on = func.now()
db_session.commit()
return jsonify(platform_schema.dump(Platforms.query.get(id)))
def user_is_confirmed_exception(e):
user = Users.query.filter_by(id=e.user.id).first()
user_event = UserEvents(user, "confirmed user try another confirmation",
dict(request.headers))
db_session.add(user_event)
db_session.commit()
return jsonify({"message": e.message}), 403
def update(id):
tag = Tags.query.get(id)
tag.name = request.json.get('name', tag.name)
tag.description = request.json.get('description', tag.description)
tag.updated_on = func.now()
db_session.commit()
return jsonify(tag_schema.dump(Tags.query.get(id)))
def not_authorized_logging_exception(e):
user = Users.query.filter_by(id=e.user.id).first()
user_event = UserEvents(user, "not authorized logging",
dict(request.headers))
db_session.add(user_event)
db_session.commit()
return jsonify({"message": e.message}), 403
def post():
if not request.json or not 'name' in request.json:
abort(400)
name = request.json['name']
publisher = Publishers(name)
db_session.add(publisher)
db_session.commit()
return publisher_schema.dump(publisher)
def post():
if not request.json or not 'name' in request.json:
abort(400)
name = request.json['name']
platform = Platforms(name)
db_session.add(platform)
db_session.commit()
return platform_schema.dump(platform)
def post():
if not request.json or not 'name' in request.json:
abort(400)
name = request.json['name']
description = request.json['description']
tag = Tags(name, description)
db_session.add(tag)
db_session.commit()
return tag_schema.dump(tag)
def update(id):
course = Courses.query.filter_by(id=id).first()
course.name = request.json.get('name', course.name)
course.updated_on = func.now()
db_session.commit()
# es.index(index='courses', doc_type='title', id=course.id, body=json.dumps(course_search_schema.dump(course)))
return jsonify(course_schema.dump(course))
def update(id):
agreement = Agreements.query.get(id)
agreement.title = request.json.get('title', agreement.title)
agreement.description = request.json.get('description', agreement.description)
agreement.body = request.json.get('body', agreement.body)
agreement.is_required = request.json.get('is_required', agreement.is_required)
agreement.valid_from = request.json.get('valid_from', agreement.valid_from)
agreement.valid_to = request.json.get('valid_to', agreement.valid_to)
agreement.is_active = request.json.get('is_active', agreement.is_active)
agreement.updated_on = func.now()
db_session.commit()
return jsonify(agreement_schema.dump(Agreements.query.get(id)))
def post():
if not request.json or not 'title' in request.json:
abort(400)
title = request.json['title']
agreement = Agreements(title)
agreement.description = request.json['description']
agreement.body = request.json['body']
agreement.is_required = request.json['is_required']
agreement.valid_from = request.json['valid_from']
agreement.valid_to = request.json['valid_to']
db_session.add(agreement)
db_session.commit()
return agreement_schema.dump(agreement)
def add_tag(course_id):
if not request.json or not 'tag_id' in request.json:
abort(400)
tag_id = request.json['tag_id']
course = Courses.query.get(course_id)
tag = Tags.query.filter_by(id=tag_id).first()
course.tags.append(tag)
db_session.commit()
# es.index(index='courses', doc_type='title', id=course.id, body=json.dumps(course_search_schema.dump(course)))
return jsonify(course_schema.dump(course))
def post():
if not request.json or not 'name' in request.json:
abort(400)
if not request.json or not 'description' in request.json:
abort(400)
name = request.json['name']
description = request.json['description']
release_type = ReleaseTypes(name=name, description=description)
db_session.add(release_type)
db_session.commit()
return release_type_schema.dump(release_type)
def add_keyword(course_id):
if not request.json or not 'name' in request.json:
abort(400)
course = Courses.query.get(course_id)
name = request.json['name']
keyword = Keywords(name)
course.keywords.append(keyword)
course.updated_on = func.now()
db_session.commit()
# es.index(index='courses', doc_type='title', id=course.id, body=json.dumps(course_search_schema.dump(course)))
return keyword_schema.dump(keyword)
def confirmation(token):
try:
email = email_from_confirm_token(token)
except:
raise InvalidTokenException("URL Token is not valid.")
print(email)
user = Users.query.filter_by(email=email).first()
if user.confirmed:
raise UserIsConfirmedException("User is confirmed", user)
else:
user.confirmed = True
user.confirmed_on = datetime.datetime.now()
db_session.add(user)
db_session.commit()
return jsonify({"msg": "Confirmed!"}), 200
def releases_create(course_id):
course = Courses.query.get(course_id)
name = request.json['name']
description = request.json['description']
release_type_id = request.json['release_type_id']
release_type = ReleaseTypes.query.get(release_type_id)
release = Releases(name, description, release_type)
course.releases.append(release)
course.updated_on = func.now()
db_session.commit()
# es.index(index='courses', doc_type='title', id=course.id, body=json.dumps(course_search_schema.dump(course)))
return release_schema.dump(release)
def ratings_create(course_id):
if not request.json or not 'points' in request.json:
abort(400)
points = request.json['points']
course = Courses.query.get(course_id)
current_user = get_jwt_identity()
user = Users.query.filter_by(public_id=current_user).first()
rating = Ratings(user=user, course=course, points=points)
db_session.add(rating)
db_session.commit()
# es.index(index='courses', doc_type='title', id=course.id, body=json.dumps(course_search_schema.dump(course)))
return rating_schema.dump(rating)
def reviews_create(course_id):
if not request.json or not 'description' in request.json:
abort(400)
description = request.json['description']
course = Courses.query.get(course_id)
current_user = get_jwt_identity()
user = Users.query.filter_by(public_id=current_user).first()
review = Reviews(user=user, course=course, description=description)
db_session.add(review)
db_session.commit()
# es.index(index='courses', doc_type='title', id=course.id, body=json.dumps(course_search_schema.dump(course)))
return review_schema.dump(review)
def password_change(token):
if not request.is_json:
raise NotValidRequestException("POST doesn't have JSON payload.")
new_password = request.json.get('password', None)
try:
email = email_from_confirm_token(token)
except:
raise InvalidTokenException("URL Token is not valid.")
user = Users.query.filter_by(email=email).first()
if user and not user.confirmed:
raise UserIsNotConfirmedException("User is not confirmed", user)
user.password = sha256_crypt.encrypt(new_password)
db_session.add(user)
db_session.commit()
return jsonify({"msg": "Password changed."}), 200
def login():
if not request.is_json:
raise NotValidRequestException("POST doesn't have JSON payload.")
username = request.json.get('username', None)
password = request.json.get('password', None)
if not username or not password:
raise MissingParametersException("Missing username or password")
user = Users.query.filter_by(name=username).first()
if not user:
raise UserNotExistException("User do not exist.")
if user and not user.confirmed:
raise UserIsNotConfirmedException("User is not confirmed", user)
if sha256_crypt.verify(password, user.password):
user_event = UserEvents(user, "correctly logged",
dict(request.headers))
db_session.add(user_event)
# https://flask-jwt-extended.readthedocs.io/en/stable/add_custom_data_claims/
access_token = create_access_token(identity=user.public_id)
refresh_token = create_refresh_token(identity=user.public_id)
user_event = UserEvents(user, "generated tokens", {
"access_token": access_token,
"refresh_token": refresh_token
})
db_session.add(user_event)
db_session.commit()
return jsonify({
'access_token': access_token,
'refresh_token': refresh_token
}), 200
else:
raise NotAuthorizedLoggingException(
"User is not authorized or not exist.", user)
def reviews_delete(course_id, review_id):
db_session.delete(Reviews.query.get(review_id))
db_session.commit()
return jsonify({'result': True})
def delete(id):
db_session.delete(Platforms.query.get(id))
db_session.commit()
return jsonify({'result': True})
def delete(id):
db_session.delete(ReleaseTypes.query.get(id))
db_session.commit()
return jsonify({'result': True})
def ratings_delete(course_id, rating_id):
db_session.delete(Ratings.query.get(rating_id))
db_session.commit()
return jsonify({'result': True})
