update all request to new version for manage pagination and search in frontend

#!/bin/bash

set -e  # Detener la ejecución si ocurre un error

# Función para manejar errores

handle_error() {

    echo "Error en el script. Línea: $1"

    exit 1

}

# Capturar errores y llamar a la función handle_error

trap 'handle_error $LINENO' ERR

# Obtener la última versión desde ECR usando AWS CLI

LAST_VERSION=$(aws ecr-public describe-image-tags --repository-name opencapif/backoffice-backend --region us-east-1 --query 'imageTagDetails[*].imageTag' --output text | grep -Eo 'v3.1.[0-9]+' | sed 's/v3.1.//' | sort -n | tail -1)

if [ -z "$LAST_VERSION" ]; then

    echo "No se pudo obtener la última versión desde ECR. Verifica si el repositorio o las imágenes existen."

    exit 1

fi

# Incrementar la versión

NEW_VERSION=$((LAST_VERSION + 1))

echo "Nueva versión: v3.1.$NEW_VERSION"

# Establecer la plataforma y construir la imagen Docker

echo "Construyendo la imagen Docker..."

DOCKER_DEFAULT_PLATFORM=linux/amd64 docker-compose build || { echo "Error en la construcción de la imagen Docker."; exit 1; }

# Pedir al usuario el ARN de MFA

read -p "Introduce el ID de cuenta de AWS (ej. 230672794366): " AWS_ACCOUNT_ID

read -p "Introduce el nombre del dispositivo MFA (ej. google_authenticator_phone): " MFA_DEVICE

MFA_ARN="arn:aws:iam::$AWS_ACCOUNT_ID:mfa/$MFA_DEVICE"

# Autenticación MFA con AWS para obtener un token temporal

read -p "Introduce el código MFA de 6 dígitos: " MFA_CODE

# Obtener un token temporal usando MFA

echo "Autenticando con AWS usando MFA..."

TEMP_CREDS=$(aws sts get-session-token --serial-number "$MFA_ARN" --token-code "$MFA_CODE" --output json)

if [ -z "$TEMP_CREDS" ]; then

    echo "Error: No se pudo obtener el token temporal de AWS. Verifica el código MFA."

    exit 1

fi

# Exportar credenciales temporales

export AWS_ACCESS_KEY_ID=$(echo "$TEMP_CREDS" | jq -r '.Credentials.AccessKeyId')

export AWS_SECRET_ACCESS_KEY=$(echo "$TEMP_CREDS" | jq -r '.Credentials.SecretAccessKey')

export AWS_SESSION_TOKEN=$(echo "$TEMP_CREDS" | jq -r '.Credentials.SessionToken')

# Autenticar Docker con Amazon ECR Public

aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws/o2v4a8t6 || { echo "Error en la autenticación con Docker."; exit 1; }

# Taggear la imagen con la nueva versión

echo "Etiquetando la imagen Docker..."

docker tag pesp_capif_backoffice_backend-backoffice_microservice public.ecr.aws/o2v4a8t6/opencapif/backoffice-backend:v3.1.$NEW_VERSION || { echo "Error al etiquetar la imagen Docker."; exit 1; }

# Push de la imagen con la nueva versión

echo "Pushing la nueva imagen a ECR..."

docker push public.ecr.aws/o2v4a8t6/opencapif/backoffice-backend:v3.1.$NEW_VERSION || { echo "Error al hacer push de la imagen Docker."; exit 1; }

# Mostrar la nueva versión

echo "Nueva imagen subida correctamente: public.ecr.aws/o2v4a8t6/opencapif/backoffice-backend:v3.1.$NEW_VERSION"

# Mostrar la nueva versión

echo "Nueva imagen subida correctamente: public.ecr.aws/o2v4a8t6/opencapif/backoffice-backend:v3.1.$NEW_VERSION"

# Tag a desplegar

echo "Backend tag a desplegar: v3.1.$NEW_VERSION"

 No newline at end of file

# Get private key

private_key = dump_privatekey(FILETYPE_PEM, key)

print(f"Using Vault token: {os.getenv('VAULT_TOKEN')}")

# Get ca.cert from vault

config = Config().get_config() # get configuration from config.py

url = 'http://{}:{}/v1/secret/data/ca'.format(os.getenv('VAULT_HOSTNAME'), os.getenv('VAULT_PORT'))   # http://vault:8200/v1/secret/data/ca

headers = {'X-Vault-Token': os.getenv('VAULT_TOKEN')}

response = requests.request("GET", url, headers=headers, verify = False)

# Imprimir el contenido completo de la respuesta para inspección

print("Response from Vault (ca.cert request):")

print(response)

ca_cert = json.loads(response.text)["data"]["data"]["ca"]

# print ("CA CERT URL: ", url)

# Request Vault a CA certificate to backoffice application

url = 'http://{}:{}/v1/pki_int/sign/my-ca'.format(os.getenv('VAULT_HOSTNAME'), os.getenv('VAULT_PORT'))  # http://vault:8200/v1/pki_int/sign/my-ca

headers = {'X-Vault-Token': os.getenv('VAULT_TOKEN')}  # token = dev-only-token

headers = {'X-Vault-Token': os.getenv('VAULT_TOKEN')}  # token = dev-only-token -> for dev environment

data = {

    'format':'pem_bundle',

    'ttl': '43000h',

#----------------------------------------

# the applicacions starts here in every interface and port 8080

# ssl -> contains backoffice_cert.crt and backoffice_key.key

if __name__ == "__main__":

    app.run(debug=True, host='0.0.0.0', port=8080)

# NOS LO FUMAMOS -> SSL 

# if __name__ == "__main__":

#     app.run(debug=True, host='0.0.0.0', port=8080, ssl_context=(

#         "/usr/src/app/backoffice_service/certs/backoffice_cert.crt", "/usr/src/app/backoffice_service/certs/backoffice_key.key"))

@apis_routes.route("/", methods=["GET"])

@jwt_required()

def get_apis_pages_order():

    page = request.args.get('page', default=1, type=int)

    page_size = request.args.get('pageSize', default=10, type=int)

    order = request.args.get('order', default="ascending", type=str)

    return operations.get_apis_pages_order(page, page_size, order)

    return operations.get_apis_list()

 # GET information of a single api   

@cross_origin()

@apis_routes.route("/alone", methods=["GET"])

@jwt_required()

def get_api_by_id():

    api_id = request.args.get('api_id', type=str)

    # Log para verificar si el API ID está siendo recibido correctamente

    print(f"Received API ID: {api_id}")

    # Llamar al método operations.get_api_by_id

    api_data = operations.get_api_by_id(api_id)

    if "error" in api_data:

        # Log si no se encuentra el API o hay un error

        print(f"API ID {api_id} not found or error occurred.")

        return jsonify(api_data), 500  # Devolver el error con código 500

    return jsonify(api_data), 200  # Devolver los datos con código 200 si todo va bien

# GET apis of a provider

@cross_origin()

@apis_routes.route("/provider", methods=["GET"])

@jwt_required()

def get_apis_of_provider():

    apf_id = request.args.get('apf_id', type=str)

    return operations.get_apis_of_a_provider(apf_id)

# DELETE multiple apis

def get_apis():

    return operations.get_apis()

# # GET apis with pagination

# @cross_origin()

# @apis_routes.route("/pages", methods=["GET"])

# @jwt_required()

# def get_apis_pages():

#     page = request.args.get('page', default=1, type=int)

#     page_size = request.args.get('pageSize', default=10, type=int)

#     return operations.get_apis_pages(page, page_size)

# # GET the number of apis

@cross_origin()

@jwt_required()

def get_num_apis():    

    return operations.get_num_apis()

# # SEARCH apis

# @cross_origin()

# @apis_routes.route("/search", methods=["GET"])

# @jwt_required()

# def search_apis():

#     try:

#         search_term = request.args.get('searchTerm', default='', type=str)

#         page = request.args.get('page', default=1, type=int)

#         page_size = request.args.get('pageSize', default=10, type=int)

#         response, status_code = operations.search_apis(search_term, page, page_size)

#         return jsonify(response), status_code

#     except Exception as e:

#         return jsonify({"error": str(e)}), 500

@backoffice_routes.route('/grafana', methods=['GET'])

@jwt_required()

def get_grafana_data():

    return jsonify("todo guya mi nigga"), 200

    return jsonify("todo ok"), 200

@cross_origin()

@backoffice_routes.route('/refreshgrafana', methods=['GET'])

@jwt_required()

def refresh_grafana_data():

    return jsonify("todo guya mi nigga"), 200

    return jsonify("todo ok"), 200

operations = Operations()   # create operations object -> operations.py

# GET invokers with date order and pagination

# GET invokers with date order and pagination -> DEPRECATED

@cross_origin()

@invokers_routes.route("/", methods=["GET"])

@jwt_required()

    order = request.args.get('order', default="ascending", type=str)

    return operations.get_invokers_pages_order(page, page_size, order)

@cross_origin()

@invokers_routes.route("/total", methods=["GET"])

@jwt_required()

def get_invokers_list():

    return operations.get_invokers_list()

# GET information of a single invoker

@cross_origin()

@invokers_routes.route("/alone", methods=["GET"])

@jwt_required()

def get_invoker_by_id():

    invoker_id = request.args.get('invoker_id', default="1", type=str)

    # Llamar al método operations.get_invoker_by_id

    invoker_data = operations.get_invoker_by_id(invoker_id)

    if invoker_data:

        # Envolver los datos devueltos en jsonify

        return jsonify(invoker_data), 200

    else:

        return jsonify({"error": "Invoker not found"}), 404

# GET security context of an invoker -> single page invoker information

@cross_origin()

@invokers_routes.route("/security", methods=["GET"])

@jwt_required()

def get_invoker_security_context():

    invoker_id = request.args.get('invoker_id', type=str)

    # Llamar al método operations.get_invoker_by_id

    invoker_data = operations.get_security_context_of_a_invoker(invoker_id)

    if invoker_data:

        # Envolver los datos devueltos en jsonify

        return jsonify(invoker_data), 200

    else:

        return jsonify({"error": "Invoker not found"}), 404

# GET security context of an invoker -> single page invoker information

@cross_origin()

@invokers_routes.route("/security/all", methods=["GET"])

@jwt_required()

def get_invoker_security_context_all():    

    # Llamar al método operations.get_invoker_by_id

    data = operations.get_security_context_all()

    if data:

        # Envolver los datos devueltos en jsonify

        return jsonify(data), 200

    else:

        return jsonify({"error": "SS not found"}), 404

# GET invokers of a user

@cross_origin()

@invokers_routes.route("/user", methods=["GET"])

@jwt_required()

def get_invokers_of_a_user():

    # Obtener el parámetro 'uuid' de la query

    uuid = request.args.get('uuid', type=str)  # uuid será None si no se pasa el parámetro

    if not uuid:

        return jsonify({"error": "UUID parameter is required"}), 400  # Respuesta de error si no se pasa el UUID

    # Llamar a la operación con el UUID

    return operations.get_invokers_of_a_user(uuid)

# DELETE multiple invokers

@invokers_routes.route("/", methods=["DELETE"])

@jwt_required()

    page_size = request.args.get('pageSize', default=10, type=int)

    return operations.get_invokersPages(page, page_size)

# DELETE a security context of an invoker

@cross_origin()

@invokers_routes.route("/security/<invoker_id>/<aef_id>/<api_id>", methods=["DELETE"])

@jwt_required()

def delete_security_context(invoker_id, aef_id, api_id):

    if invoker_id == "null" or aef_id == "null" or api_id == "null":

        return jsonify(message="Invalid parameters", object=None), 400

    return operations.delete_security_context(invoker_id, aef_id, api_id)

# SEARCH invokers

@cross_origin()

@invokers_routes.route("/search", methods=["GET"])

@jwt_required()

def get_num_ixnvokers():

    return operations.get_num_invokers()

# GET security context of an invoker -> single page invoker information

@cross_origin()

@invokers_routes.route("/security/<invoker_id>", methods=["GET"])

@jwt_required()

def get_invoker_security_context(invoker_id):

    if invoker_id == "null":

        return jsonify(message="Invalid invoker_id", security_contexts=None), 400

    return operations.get_invoker_security_context(invoker_id)

# DELETE a single invoker

# @cross_origin()

# @invokers_routes.route("/<id>", methods=["DELETE"])

# @jwt_required()

# def delete_invoker(id):

#     if id == "null":

#         return jsonify(message="Invalid id", object=None), 400

#     return operations.delete_invoker(id)