advance on api (7b9011f3) · Commits · Anthony Jacob / api

app/controller/auth.py

+3 −5

Original line number	Diff line number	Diff line
		from flask import Blueprint, request, jsonify, current_app
		from helpers.security import check_auth, revoke_jwt
		from flask import Blueprint, request, jsonify
		from helpers.security import check_auth
		from model.security import revoke_jwt
		from helpers.limiter import limiter
		from flask_jwt_extended import (
		JWTManager,
		create_access_token,
		create_refresh_token,
		jwt_required,
		@@ -20,8 +20,6 @@ def login():
		username = data.get("username")
		password = data.get("password")

		print(data)

		if (
		not username
		or not password

app/controller/diploma.py

+213 −6

Original line number	Diff line number	Diff line
		from datetime import date, datetime
		from gettext import translation
		from flask import Blueprint, request, jsonify, current_app
		from helpers.security import require_auth
		from helpers.limiter import limiter
		from model.diploma.diploma import (
		insertDiploma,
		getDiplomas,
		getDiplomasFull,
		getDiploma,
		deleteDiploma,
		updateDiploma,
		)
		from model.language.language import isLanguagCodeExists

		diploma_bp = Blueprint("diploma", __name__)

		@@ -9,33 +20,229 @@ diploma_bp = Blueprint("diploma", __name__)
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def get_diplomas():
		return jsonify({"message": "list"})
		diploma_ids = getDiplomas()

		if diploma_ids is False:
		return jsonify({"error": "Database error"}), 500

		return jsonify({"diplomas": diploma_ids})


		@diploma_bp.route("/diplomas/full", methods=["GET"])
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def get_diplomas_full():
		diplomas = getDiplomasFull()

		if diplomas is False:
		return jsonify({"error": "Database error"}), 500

		return jsonify({"diplomas": diplomas})


		@diploma_bp.route("/diplomas/<int:id>", methods=["GET"])
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def get_diploma(id):
		return jsonify({"message": "update", "id": id})
		try:
		if not id:
		return jsonify({"error": "Missing Diploma id"}), 400
		else:
		result = getDiploma(id)
		if result == -1:
		return jsonify({"message": "diploma not found", "id": id}), 404
		elif result:
		return jsonify(result)
		else:
		return jsonify({"error": "Failed to get diploma"}), 500

		except Exception as e:
		return jsonify({"error": str(e)}), 500


		@diploma_bp.route("/diplomas", methods=["PUT"])
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def create_diploma():
		NewID: int = 10
		return jsonify({"message": "create", "id": NewID})
		try:
		data = request.get_json()
		start_date = None
		end_date = None
		translations = data.get("translations")

		if "end_date" not in data:
		return jsonify({"error": "Missing end_date"}), 400
		else:
		try:
		end_date: date = datetime.strptime(
		data.get("end_date"), "%Y-%m-%d"
		).date()
		except ValueError:
		return jsonify({"error": "end_date must be in YYYY-MM-DD format"}), 400

		if "start_date" in data:
		try:
		start_date: date = datetime.strptime(
		data.get("start_date"), "%Y-%m-%d"
		).date()
		except ValueError:
		return (
		jsonify(
		{
		"error": "if you provide start_date, it must be in YYYY-MM-DD format"
		}
		),
		400,
		)

		translationToUpdate: list = []
		for diplomaTranslation in translations:
		if "language_code" not in diplomaTranslation:
		return (
		jsonify(
		{
		"error": "you must provide a language_code for each translations"
		}
		),
		400,
		)
		elif not diplomaTranslation["language_code"].strip():
		return jsonify({"error": "language_code can't be empty"}), 400
		elif not isLanguagCodeExists(diplomaTranslation["language_code"]):
		return (
		jsonify(
		{
		"error": f"language_code is not existing ({diplomaTranslation['language_code']})"
		}
		),
		400,
		)
		else:
		translationToUpdate.append(diplomaTranslation["language_code"])

		if(len(translationToUpdate) != len(list(set(translationToUpdate)))):
		return (
		jsonify(
		{
		"error": "you provided multiple times the same language_code"
		}
		),
		400,
		)


		diploma_id = insertDiploma(start_date, end_date, translations)

		if diploma_id > 0:
		return (
		jsonify({"message": "Diploma inserted", "diploma_id": diploma_id}),
		201,
		)
		elif diploma_id == -1:
		return jsonify({"error": "diploma already exist"}), 409
		else:
		return jsonify({"error": "Failed to insert diploma"}), 500

		except Exception as e:
		return jsonify({"error": str(e)}), 500


		@diploma_bp.route("/diplomas/<int:id>", methods=["POST"])
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def update_diploma(id):
		return jsonify({"message": "update", "id": id})
		try:
		if not id:
		return jsonify({"error": "Missing Diploma id"}), 400
		else:
		diploma = getDiploma(id)
		if diploma == -1:
		return jsonify({"message": "diploma not found", "id": id}), 404
		elif diploma:
		data = request.get_json()

		start_date = None
		end_date = None
		translations = data.get("translations")

		if "end_date" in data:
		try:
		end_date: date = datetime.strptime(
		data.get("end_date"), "%Y-%m-%d"
		).date()
		except ValueError:
		return (
		jsonify({"error": "end_date must be in YYYY-MM-DD format"}),
		400,
		)

		if "start_date" in data:
		try:
		start_date: date = datetime.strptime(
		data.get("start_date"), "%Y-%m-%d"
		).date()
		except ValueError:
		return (
		jsonify({"error": "start must be in YYYY-MM-DD format"}),
		400,
		)

		for diplomaTranslation in translations:
		if "language_code" not in diplomaTranslation:
		return (
		jsonify(
		{
		"error": "you must provide a language_code for each translations"
		}
		),
		400,
		)
		elif not diplomaTranslation["language_code"].strip():
		return jsonify({"error": "language_code can't be empty"}), 400
		elif not isLanguagCodeExists(diplomaTranslation["language_code"]):
		return (
		jsonify(
		{
		"error": f"language_code is not existing ({diplomaTranslation['language_code']})"
		}
		),
		400,
		)

		updatedDiploma = updateDiploma(id, start_date, end_date, translations)

		if updatedDiploma:
		return (
		jsonify({"message": "Diploma updated", "id": updatedDiploma}),
		200,
		)
		else:
		return jsonify({"error": "Failed to update diploma"}), 500
		else:
		return jsonify({"error": "Failed to update diploma"}), 500

		except Exception as e:
		return jsonify({"error": str(e)}), 500


		@diploma_bp.route("/diplomas/<int:id>", methods=["DELETE"])
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def delete_diploma(id):
		return jsonify({"message": "delete", "id": id})
		try:
		if not id:
		return jsonify({"error": "Missing Diploma id"}), 400
		else:
		diploma = getDiploma(id)
		if diploma == -1:
		return jsonify({"message": "diploma not found", "id": id}), 404
		elif diploma:
		if deleteDiploma(id):
		return jsonify({"message": "diploma deleted", "id": id})
		else:
		return jsonify({"error": "Failed to delete diploma"}), 500
		else:
		return jsonify({"error": "Failed to retrieve diploma"}), 500

		except Exception as e:
		return jsonify({"error": str(e)}), 500

app/controller/keyword.py

0 → 100644

+267 −0

Original line number	Diff line number	Diff line
		import traceback
		from flask import Blueprint, request, jsonify, current_app
		from app.model.language.language import getLanguageByCode, isLanguagCodeExists
		from helpers.security import require_auth
		from helpers.limiter import limiter
		from model.keyword.keyword import (
		getKeywordByCode,
		insertKeyword,
		getKeywords,
		getKeywordsFull,
		getKeyword,
		deleteKeyword,
		updateKeyword,
		getLastPosition,
		isKeywordExists
		)

		keyword_bp = Blueprint("keyword", __name__)


		@keyword_bp.route("/keywords", methods=["GET"])
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def get_keywords():
		keyword_ids = getKeywords()

		if keyword_ids is False:
		return jsonify({"error": "Database error"}), 500

		return jsonify({"keywords": keyword_ids})


		@keyword_bp.route("/keywords/full", methods=["GET"])
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def get_keywords_full():
		keywords = getKeywordsFull()

		if keywords is False:
		return jsonify({"error": "Database error"}), 500

		return jsonify({"keywords": keywords})


		@keyword_bp.route("/keywords/<int:id>", methods=["GET"])
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def get_keyword(id):
		try:
		if not id:
		return jsonify({"error": "Missing Keyword id"}), 400
		else:
		result = getKeyword(id)
		if result == -1:
		return jsonify({"message": "keyword not found", "id": id}), 404
		elif result:
		return jsonify(result)
		else:
		return jsonify({"error": "Failed to get keyword"}), 500

		except Exception as e:
		return jsonify({"error": str(e)}), 500



		@keyword_bp.route("/keywords", methods=["PUT"])
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def create_keyword():
		try:
		data = request.get_json()
		keyword = data.get("keyword")
		language_code = data.get("language_code")
		position = None

		if "keyword" not in data:
		return jsonify({"error": "Missing keyword"}), 400

		if "language_code" not in data:
		return (
		jsonify(
		{
		"error": "you must provide a language_code for the keyword"
		}
		),
		400,
		)
		elif not language_code.strip():
		return jsonify({"error": "language_code can't be empty"}), 400
		elif not isLanguagCodeExists(language_code):
		return (
		jsonify(
		{
		"error": f"language_code is not existing ({language_code})"
		}
		),
		400,
		)


		if "position" in data and isinstance(data.get("position"), int):
		position = data.get("position")
		elif "position" in data:
		return (
		jsonify(
		{
		"error": "if you provide position, it must be an integer"
		}
		),
		400,
		)

		if(isKeywordExists(keyword, language_code)):
		return (
		jsonify(
		{
		"error": "The keyword already exists for this language"
		}
		),
		400,
		)

		if(position is None):
		position = getLastPosition(language_code) + 1

		languageID = getLanguageByCode(language_code)["id"]

		keyword_id = insertKeyword(keyword, languageID, position)

		if keyword_id > 0:
		return (
		jsonify({"message": "Keyword inserted", "keyword_id": keyword_id}),
		201,
		)
		elif keyword_id == -1:
		return jsonify({"error": "keyword already exist"}), 409
		else:
		return jsonify({"error": "Failed to insert keyword"}), 500

		except Exception as e:
		return jsonify({"error": str(e)}), 500


		@keyword_bp.route("/keywords/<int:id>", methods=["POST"])
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def update_keyword(id):
		try:
		if not id:
		return jsonify({"error": "Missing Keyword id"}), 400
		else:
		keyword = getKeyword(id)
		if keyword == -1:
		return jsonify({"message": "keyword not found", "id": id}), 404
		elif keyword:
		data = request.get_json()
		keyword = data.get("keyword")
		language_code = data.get("language_code")
		position = data.get("position")


		if "keyword" not in data:
		return jsonify({"error": "Missing keyword"}), 400

		if "language_code" not in data:
		return (
		jsonify(
		{
		"error": "you must provide a language_code for the keyword"
		}
		),
		400,
		)
		elif not language_code.strip():
		return jsonify({"error": "language_code can't be empty"}), 400
		elif not isLanguagCodeExists(language_code):
		return (
		jsonify(
		{
		"error": f"language_code is not existing ({language_code})"
		}
		),
		400,
		)

		if "position" not in data:
		return (
		jsonify(
		{
		"error": "you must provide a position for the keyword"
		}
		),
		400,
		)
		elif not isinstance(data.get("position"), int):
		return (
		jsonify(
		{
		"error": "if you provide position, it must be an integer"
		}
		),
		400,
		)

		existingKeyword = getKeywordByCode(keyword, language_code)
		print(existingKeyword)
		if(existingKeyword and existingKeyword != -1 and existingKeyword["id"] != id ):
		return (
		jsonify(
		{
		"error": f"the keyword {keyword} is already used by the keyword {existingKeyword['id']}"
		}
		),
		400,
		)


		languageID = getLanguageByCode(language_code)["id"]
		updatedKeyword = updateKeyword(id, keyword, languageID, position)
		# updatedKeyword = -2

		if updatedKeyword == -2:
		return (
		jsonify(
		{"error": "keyword code is already used by another keyword Id"}
		),
		500,
		)
		elif updatedKeyword:
		return (
		jsonify({"message": "Keyword updated", "keyword": updatedKeyword}),
		200,
		)
		else:
		return jsonify({"error": "Failed to insert keyword"}), 500

		except Exception as e:
		error_message = str(e)
		stack_trace = traceback.format_exc() # Capture full stack trace as a string

		return jsonify({
		"error": error_message,
		"stack_trace": stack_trace
		}), 500


		@keyword_bp.route("/keywords/<int:id>", methods=["DELETE"])
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def delete_keyword(id):
		try:
		if not id:
		return jsonify({"error": "Missing Keyword id"}), 400
		else:
		keyword = getKeyword(id)
		if keyword == -1:
		return jsonify({"message": "keyword not found", "id": id}), 404
		elif keyword:
		if deleteKeyword(id):
		return jsonify({"message": "keyword deleted", "id": id})
		else:
		return jsonify({"error": "Failed to delete keyword"}), 500
		else:
		return jsonify({"error": "Failed to retrieve keyword"}), 500

		except Exception as e:
		return jsonify({"error": str(e)}), 500

app/controller/language.py

+64 −4

Original line number	Diff line number	Diff line
		@@ -7,6 +7,7 @@ from model.language.language import (
		getLanguagesFull,
		getLanguage,
		deleteLanguage,
		updateLanguage,
		)

		language_bp = Blueprint("language", __name__)
		@@ -55,7 +56,6 @@ def get_language(id):
		except Exception as e:
		return jsonify({"error": str(e)}), 500

		return jsonify({"message": "update", "id": id})


		@language_bp.route("/languages", methods=["PUT"])
		@@ -65,11 +65,24 @@ def create_language():
		try:
		data = request.get_json()
		language_code = data.get("language_code")
		enabled = True

		if not language_code:
		if "language_code" not in data:
		return jsonify({"error": "Missing language_code"}), 400

		language_id = insertLanguage(language_code)
		if "enabled" in data and isinstance(data.get("enabled"), bool):
		enabled = data.get("enabled")
		elif "enabled" in data:
		return (
		jsonify(
		{
		"error": "if you provide enabled, it must be a boolean true or false"
		}
		),
		400,
		)

		language_id = insertLanguage(language_code, enabled)

		if language_id > 0:
		return (
		@@ -89,7 +102,54 @@ def create_language():
		@require_auth
		@limiter.limit("1/second", override_defaults=False)
		def update_language(id):
		return jsonify({"message": "update", "id": id})
		try:
		data = request.get_json()
		language_code = data.get("language_code")
		enabled = None

		if "language_code" not in data and "enabled" not in data:
		return (
		jsonify(
		{
		"error": "You must provide at least on parameter language_code or enabled"
		}
		),
		400,
		)

		if "enabled" in data and isinstance(data.get("enabled"), bool):
		enabled = data.get("enabled")
		elif "enabled" in data:
		return (
		jsonify(
		{
		"error": "if you provide enabled, it must be a boolean true or false"
		}
		),
		400,
		)

		updatedLanguage = updateLanguage(id, language_code, enabled)

		if updatedLanguage == -1:
		return jsonify({"error": "the language is not existing"}), 500
		elif updatedLanguage == -2:
		return (
		jsonify(
		{"error": "language code is already used by another language Id"}
		),
		500,
		)
		elif updatedLanguage:
		return (
		jsonify({"message": "Language updated", "language": updatedLanguage}),
		200,
		)
		else:
		return jsonify({"error": "Failed to insert language"}), 500

		except Exception as e:
		return jsonify({"error": str(e)}), 500


		@language_bp.route("/languages/<int:id>", methods=["DELETE"])

app/helpers/security.py

+2 −131

File changed.

Preview size limit exceeded, changes collapsed.