api_crud.py

from flask import Flask, request, jsonify
import psycopg2

app = Flask(__name__)


def connect_db():
    try:
        connection = psycopg2.connect(
            database="",
            user="",
            password="",
            host="",
            port="",
        )
        return connection
    except Exception as e:
        print(f"Erro ao conectar ao banco de dados: {e}")
        return None


@app.route("/api/funcionario", methods=["POST"])
def create_Funcionario():
    data = request.get_json()
    nome = data["nome"]
    endereco = data["endereco"]
    telefone = data["telefone"]
    email = data["email"]
    cargo = data["cargo"]

    connection = connect_db()
    cursor = connection.cursor()

    try:
        cursor.execute(
            f"""
            INSERT INTO rentcarsdb.funcionario (nome, endereco, telefone, email, cargo)
            VALUES ('{nome}', '{endereco}', '{telefone}', '{email}', '{cargo}')
            """
        )
        connection.commit()
        return jsonify(
            {"success": True, "message": f"funcionario {nome} criado com sucesso!"}
        )
    except Exception as e:
        connection.rollback()
        print(f"Erro ao criar funcionario: {e}")
        return jsonify({"success": False, "message": "Erro ao criar funcionario!"})
    finally:
        cursor.close()
        connection.close()


@app.route("/api/funcionario/<int:id>")
def get_Funcionario(id):
    '''
    id: id unico do funcionario a ser buscado
    '''
    connection = connect_db()
    cursor = connection.cursor()

    try:
        cursor.execute(
            f"""
            SELECT * FROM rentcarsdb.funcionario
            WHERE idFuncionario = {id}
            """
        )
        funcionario = cursor.fetchone()
        if funcionario:
            return jsonify({"success": True, "data": funcionario})
        else:
            return jsonify({"success": False, "message": "funcionario não encontrado!"})
    except Exception as e:
        print(f"Erro ao buscar funcionario: {e}")
        return jsonify({"success": False, "message": "Erro ao buscar funcionario!"})
    finally:
        cursor.close()
        connection.close()


@app.route("/api/funcionario/<int:id>", methods=["PUT"])
def update_Funcionario(id):
    '''
    id: id unico do funcionario a ser atualizado
    '''
    data = request.get_json()
    nome = data["nome"]
    endereco = data["endereco"]
    telefone = data["telefone"]
    email = data["email"]
    cargo = data["cargo"]
    update_fields = []
    update_values = []

    if nome is not None:
        update_fields.append("nome = %s")
        update_values.append(nome)
    if endereco is not None:
        update_fields.append("endereco = %s")
        update_values.append(endereco)
    if telefone is not None:
        update_fields.append("telefone = %s")
        update_values.append(telefone)
    if email is not None:
        update_fields.append("email = %s")
        update_values.append(email)
    if cargo is not None:
        update_fields.append("cargo = %s")
        update_values.append(cargo)

    if not update_fields:
        return jsonify(
            {"success": False, "message": "Nenhum campo informado para atualizacao!"}
        )

    connection = connect_db()
    cursor = connection.cursor()

    try:
        update_query = f"""
        UPDATE rentcarsdb.funcionario
        SET {", ".join(update_fields)}
        WHERE idFuncionario = {id}
        """
        cursor.execute(update_query, update_values)
        connection.commit()
        return jsonify(
            {"success": True, "message": f"funcionario {id} atualizado com sucesso!"}
        )
    except Exception as e:
        connection.rollback()
        print(f"Erro ao atualizar funcionario: {e}")
        return jsonify({"success": False, "message": "Erro ao atualizar funcionario!"})
    finally:
        cursor.close()
        connection.close()


@app.route("/api/funcionario/<int:id>", methods=["DELETE"])
def delete_Funcionario(id):
    '''
    id: id unico do funcionario a ser deletado
    '''
    connection = connect_db()
    cursor = connection.cursor()

    try:
        cursor.execute(
            f"""
            DELETE FROM rentcarsdb.funcionario
            WHERE idFuncionario = {id}
            """
        )
        connection.commit()
        return jsonify(
            {"success": True, "message": f"funcionario {id} excluído com sucesso!"}
        )
    except Exception as e:
        connection.rollback()
        print(f"Erro ao excluir funcionario: {e}")
        return jsonify({"success": False, "message": "Erro ao excluir funcionario!"})
    finally:
        cursor.close()
        connection.close()


@app.route("/api/filial", methods=["POST"])
def create_Filial():
    data = request.get_json()
    id_gerente = data["id_gerente"]
    id_carros = data["ids_carros"]
    nome = data["nome_filial"]
    connection = connect_db()
    cursor = connection.cursor()
    print(data)
    try:
        cursor.execute(
            f"""
            INSERT INTO rentcarsdb.filial (gerente_idFuncionario, ids_carros, nome_filial)
            VALUES ('{id_gerente}', ARRAY{id_carros}, '{nome}')
            """
        )
        connection.commit()
        return jsonify(
            {"success": True, "message": f"filial {nome} criada com sucesso!"}
        )
    except Exception as e:
        connection.rollback()
        print(f"Erro ao criar funcionario: {e}")
        return jsonify({"success": False, "message": "Erro ao criar filial!"})
    finally:
        cursor.close()
        connection.close()


@app.route("/api/filial/<int:id>")
def get_Filial(id):
    '''
    id: id unico da filial a ser buscada
    '''
    connection = connect_db()
    cursor = connection.cursor()

    try:
        cursor.execute(
            f"""
            SELECT * FROM rentcarsdb.filial
            WHERE idFilial = {id}
            """
        )
        filial = cursor.fetchone()
        if filial:
            return jsonify({"success": True, "data": filial})
        else:
            return jsonify(
                {"success": False, "message": f"filial {id} nao encontrado!"}
            )
    except Exception as e:
        print(f"Erro ao buscar funcionario: {e}")
        return jsonify({"success": False, "message": "Erro ao buscar filial!"})
    finally:
        cursor.close()
        connection.close()


@app.route("/api/filial/<int:id>", methods=["PUT"])
def update_Filial(id):
    '''
    id: id unico da filial a ser atualizada
    '''
    data = request.get_json()
    id_gerente = data["id_gerente"]
    id_carros = data["ids_carros"]
    nome = data["nome_filial"]
    update_fields = []
    update_values = []

    if id_gerente is not None:
        update_fields.append("gerente_idFuncionario = %s")
        update_values.append(id_gerente)
    if id_carros is not None:
        update_fields.append("ids_carros = %s")
        update_values.append(id_carros)
    if nome is not None:
        update_fields.append("nome_filial = %s")
        update_values.append(nome)

    if not update_fields:
        return jsonify(
            {"success": False, "message": "Nenhum campo informado para atualização!"}
        )

    connection = connect_db()
    cursor = connection.cursor()

    try:
        update_query = f"""
        UPDATE rentcarsdb.filial
        SET {", ".join(update_fields)}
        WHERE idFilial = {id}
        """
        cursor.execute(update_query, update_values)
        connection.commit()
        return jsonify(
            {"success": True, "message": f"filial {id} atualizado com sucesso!"}
        )
    except Exception as e:
        connection.rollback()
        print(f"Erro ao atualizar filial: {e}")
        return jsonify({"success": False, "message": "Erro ao atualizar filial!"})
    finally:
        cursor.close()
        connection.close()


@app.route("/api/filial/<int:id>", methods=["DELETE"])
def delete_Filial(id):
    '''
    id: id unico da filial a ser deletada
    '''
    connection = connect_db()
    cursor = connection.cursor()

    try:
        cursor.execute(
            f"""
            DELETE FROM rentcarsdb.filial
            WHERE idFilial = {id}
            """
        )
        connection.commit()
        return jsonify(
            {"success": True, "message": f"filial {id} excluído com sucesso!"}
        )
    except Exception as e:
        connection.rollback()
        print(f"Erro ao excluir filial: {e}")
        return jsonify({"success": False, "message": "Erro ao excluir filial!"})
    finally:
        cursor.close()
        connection.close()


@app.route("/api/trabalha", methods=["POST"])
def create_Trabalha():
    data = request.get_json()
    id_filial = data["filial_id"]
    id_funcionario = data["funcionario_id"]

    connection = connect_db()
    cursor = connection.cursor()

    try:
        cursor.execute(
            f"""
            INSERT INTO rentcarsdb.trabalha (Filial_idFilial, Funcionario_idFuncionario)
            VALUES ({id_filial}, {id_funcionario})
            """
        )
        connection.commit()
        return jsonify(
            {
                "success": True,
                "message": f"Relacao trabalha entre funcionario: {id_funcionario} e filial: {id_filial} criado com sucesso!",
            }
        )
    except Exception as e:
        connection.rollback()
        print(f"Erro ao criar funcionario: {e}")
        return jsonify({"success": False, "message": "Erro ao criar Relacao trabalha!"})
    finally:
        cursor.close()
        connection.close()


@app.route("/api/trabalha/<string:rel>/<int:id>")
def get_Trabalha(rel, id):
    '''
    get_Trabalha:
        se rel == "funcionario": busca o funcionario pelo id 
        que esta inserido na
        tabela da relacao trabalha
        se rel == "filial": busca a filial pelo id 
        que esta inserido na
        tabela da relacao trabalha
    rel: pode ser "funcionario" ou "filial"
    id: id unico do funcionario ou da filial
    '''
    connection = connect_db()
    cursor = connection.cursor()
    if rel.lower() == "funcionario":

        try:
            cursor.execute(
                f"""
                SELECT f.nome, f.cargo
                FROM rentcarsdb.trabalha t
                INNER JOIN rentcarsdb.funcionario f ON f.idfuncionario = t.funcionario_idfuncionario
                WHERE t.funcionario_idfuncionario = {id}
                """
            )
            relacoes = cursor.fetchall()
            if relacoes:
                return jsonify({"success": True, "data": relacoes})
            else:
                return jsonify(
                    {"success": False, "message": "funcionario nao encontrado!"}
                )
        except Exception as e:
            print(f"Erro ao buscar relacoes: {e}")
            return jsonify({"success": False, "message": "Erro ao buscar relacoes!"})
        finally:
            cursor.close()
            connection.close()

    elif rel.lower() == "filial":
        try:
            cursor.execute(
                f"""
                SELECT fi.nome_filial
                FROM rentcarsdb.trabalha t
                INNER JOIN rentcarsdb.filial fi ON fi.idfilial = t.filial_idfilial
                WHERE t.filial_idfilial = {id}
                """
            )
            relacoes = cursor.fetchall()
            if relacoes:
                return jsonify({"success": True, "data": relacoes})
            else:
                return jsonify({"success": False, "message": "filial nao encontrada!"})
        except Exception as e:
            print(f"Erro ao buscar relacoes: {e}")
            return jsonify({"success": False, "message": "Erro ao buscar relacoes!"})
        finally:
            cursor.close()
            connection.close()
    else:
        if connection is not None:
            cursor.close()
            connection.close()
            print("Erro ao buscar relacoes")
            return jsonify({"success": False, "message": "Erro ao buscar relacoes!"})


@app.route("/api/trabalha/<int:id_filial>/<int:id_funcionario>", methods=["PUT"])
def update_Trabalha(id_filial, id_funcionario):
    '''
    Atualiza o cargo do funcionario == id_funcionario
    que trabalha (relacao trabalha)
    na filial == id_filial
    '''
    data = request.get_json()
    cargo = data["cargo"]

    if not cargo:
        return jsonify(
            {"success": False, "message": "Nenhum campo informado para atualizacao!"}
        )

    connection = connect_db()
    cursor = connection.cursor()
    try:
        cursor.execute(
            f"""
            UPDATE rentcarsdb.funcionario 
            SET cargo = '{cargo}'
            WHERE idfuncionario = {id_funcionario} AND EXISTS (
                SELECT 1
                FROM rentcarsdb.trabalha t
                WHERE t.filial_idfilial = {id_filial} AND t.funcionario_idfuncionario = rentcarsdb.funcionario.idfuncionario
                )
            """
        )
        connection.commit()
        return jsonify(
            {"success": True, "message": "funcionario atualizado com sucesso!"}
        )
    except Exception as e:
        connection.rollback()
        print(f"Erro ao atualizar cargo: {e}")
        return jsonify({"success": False, "message": "Erro ao atualizar funcionario!"})
    finally:
        cursor.close()
        connection.close()


@app.route("/api/trabalha/<string:rel>/<int:id>", methods=["DELETE"])
def delete_Trabalha(rel, id):
    '''
    delete_Trabalha:
        se rel == "funcionario": deleta o funcionario pelo id 
        que esta inserido na
        tabela da relacao trabalha
        se rel == "filial": deleta a filial pelo id 
        que esta inserido na
        tabela da relacao trabalha
    rel: pode ser "funcionario" ou "filial"
    id: id unico do funcionario ou da filial
    '''
    connection = connect_db()
    cursor = connection.cursor()
    if rel.lower() == "funcionario":
        try:
            cursor.execute(
                f"""
                DELETE FROM rentcarsdb.trabalha
                WHERE Funcionario_idFuncionario = {id}
                """
            )
            connection.commit()
            return jsonify(
                {
                    "success": True,
                    "message": f"Relacao trabalha com funcionario: {id} excluído com sucesso!",
                }
            )
        except Exception as e:
            connection.rollback()
            print(f"Erro ao excluir trabalha: {e}")
            return jsonify({"success": False, "message": "Erro ao excluir trabalha!"})
        finally:
            cursor.close()
            connection.close()
    elif rel.lower() == "filial":
        try:
            cursor.execute(
                f"""
                DELETE FROM rentcarsdb.trabalha
                WHERE Filial_idFilial = {id}
                """
            )
            connection.commit()
            return jsonify(
                {
                    "success": True,
                    "message": f"Relacao trabalha com filial: {id} excluído com sucesso!",
                }
            )
        except Exception as e:
            connection.rollback()
            print(f"Erro ao excluir trabalha: {e}")
            return jsonify({"success": False, "message": "Erro ao excluir trabalha!"})
        finally:
            cursor.close()
            connection.close()
    else:
        if connection is not None:
            cursor.close()
            connection.close()
            print("Erro ao excluir relacoes")
            return jsonify({"success": False, "message": "Erro ao excluir relacoes!"})


def main():
    app.run(debug=True)


if __name__ == "__main__":
    main()