Tarefa - ORM /ODBC

README.md

@@ -1,3 +1,7 @@
+# Link para tarefa-orm.md
+[Ir para arquivo](https://github.com/anderson-gpc/bsi-tasks/blob/main/database/20252/tarefas/Anderson_Gabriel/orm/tarefa-orm.md)
+
+
 # BSI Tasks
 
 Repositório para Auxílio no Ensino de Banco de Dados Engenharia de Software, Teste de Software e Programação Web do curso de Bacharelado em Sistemas de Informação CERES/UFRN - Caicó RN

database/20252/tarefas/Anderson_Gabriel/orm/.gitignore

@@ -0,0 +1,2 @@
+node_modules
+.env

database/20252/tarefas/Anderson_Gabriel/orm/odbc/main.ts

@@ -0,0 +1,68 @@
+import readline from "readline";
+import AtividadeRepository from "./repository/AtividadeRepository";
+import ProjetoRepository from "./repository/ProjetoRepository";
+
+async function pegarTodasAtividades() {
+    const atividades = await AtividadeRepository.pegarTodasAtividades();
+    console.log("\n=== Atividades ===");
+    console.log(atividades);
+}
+
+async function atualizarLiderProjeto(data: { codigo: number, responsavel: number }) {
+    const projeto = await ProjetoRepository.mudarLiderProjeto(data.codigo, data.responsavel);
+    console.log("\n=== Projeto atualizado ===");
+    console.log(projeto);
+}
+
+async function criarAtividade(data: { descricao: string, data_inicio: string, data_fim: string }) {
+    const atividade = await AtividadeRepository.criarAtividade(data);
+    console.log("\n=== Atividade criada ===");
+    console.log(atividade);
+}
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+function perguntar(query: string): Promise<string> {
+    return new Promise(resolve => rl.question(query, resolve));
+}
+
+async function menu() {
+    console.log("\n=== Menu ===");
+    console.log("1 - Ver todas as atividades");
+    console.log("2 - Atualizar líder de projeto");
+    console.log("3 - Criar atividade");
+    console.log("0 - Sair");
+
+    const opcao = await perguntar("Escolha uma opção: ");
+
+    switch (opcao) {
+        case "1":
+            await pegarTodasAtividades();
+            break;
+        case "2":
+            const codigo = parseInt(await perguntar("Digite o código do projeto: "));
+            const responsavel = parseInt(await perguntar("Digite o ID do novo responsável: "));
+            await atualizarLiderProjeto({ codigo, responsavel });
+            break;
+        case "3":
+            const descricao = await perguntar("Digite a descrição da atividade: ");
+            const data_inicio = await perguntar("Digite a data de início (YYYY-MM-DD): ");
+            const data_fim = await perguntar("Digite a data de fim (YYYY-MM-DD): ");
+            await criarAtividade({ descricao, data_inicio, data_fim });
+            break;
+        case "0":
+            console.log("Saindo...");
+            rl.close();
+            return;
+        default:
+            console.log("Opção inválida!");
+    }
+
+
+    menu();
+}
+
+menu();

database/20252/tarefas/Anderson_Gabriel/orm/odbc/repository/AtividadeRepository.ts

@@ -0,0 +1,71 @@
+import { atividadeSchema } from "../schema/atividade.shcema";
+import conexaoODBC from "../service/server";
+import ProjetoRepository from "./ProjetoRepository";
+
+class AtividadeRepository {
+    private conexao: any | null;
+
+    async pegarTodasAtividades() {
+        this.conexao = await conexaoODBC();
+        try {
+            const resultado = await this.conexao.query(`SELECT 
+                a.codigo,
+                a.descricao AS atividade_descricao,
+                a.projeto AS projeto_codigo,
+                a.data_inicio,
+                a.data_fim,
+                p.nome AS projeto_nome,
+                p.descricao AS projeto_descricao
+                FROM atividade a
+                LEFT JOIN projeto p ON p.codigo = a.projeto;`);
+            return resultado.filter((key: any) => key != "columns");
+        } catch (error) {
+            console.error("Erro de conexão ou query:", error);
+            return [];
+        } finally {
+            if (this.conexao) await this.conexao.close();
+        }
+    }
+
+    async criarAtividade(data: any) {
+        const parsed = atividadeSchema.safeParse(data);
+        if (!parsed.success) {
+            return { success: false, message: "Dados inválidos." };
+        }
+
+        const { descricao, projeto, data_fim, data_inicio } = parsed.data;
+        this.conexao = await conexaoODBC();
+
+        try {
+            let codProjeto: number | null = null;
+
+            if (projeto !== undefined && projeto !== null) {
+                const projetoExiste = await this.projetoExiste(projeto);
+                if (!projetoExiste) {
+                    throw new Error("Projeto informado não existe.");
+                }
+                codProjeto = projeto;
+            }
+
+            await this.conexao.query(
+                `INSERT INTO atividade (descricao, projeto, data_fim, data_inicio)
+                 VALUES (?, ?, ?, ?)`,
+                [descricao, codProjeto, data_fim, data_inicio]
+            );
+
+            return { success: true, message: "Atividade criada com sucesso!" };
+        } catch (error: any) {
+            console.error("Erro de conexão ou query:", error);
+            return { success: false, message: error.message };
+        } finally {
+            if (this.conexao) await this.conexao.close();
+        }
+    }
+
+    async projetoExiste(projeto: number): Promise<boolean> {
+        const codProjeto = await ProjetoRepository.projetoExiste(projeto);
+        return !!codProjeto;
+    }
+}
+
+export default new AtividadeRepository();

database/20252/tarefas/Anderson_Gabriel/orm/odbc/repository/FuncionarioRepository.ts

@@ -0,0 +1,17 @@
+export class FuncionarioRepository {
+    private conexao: any | null;
+    private codigo: number;
+
+    constructor(conexao: any, codigo: number) {
+        this.conexao = conexao;
+        this.codigo = codigo;
+    }
+
+    async fucionarioExiste(): Promise<any> {
+        const [funcionario] = await this.conexao.query(
+            "SELECT 1 FROM funcionario WHERE codigo = ?",
+            [this.codigo]
+        );
+        return funcionario;
+    }
+}

database/20252/tarefas/Anderson_Gabriel/orm/odbc/repository/ProjetoRepository.ts

@@ -0,0 +1,60 @@
+import conexaoODBC from "../service/server";
+import { FuncionarioRepository } from "./FuncionarioRepository";
+
+class ProjetoRepository {
+    private conexao: any | null = null;
+
+    private async getConexao() {
+        if (!this.conexao) {
+            this.conexao = await conexaoODBC();
+        }
+        return this.conexao;
+    }
+
+    async mudarLiderProjeto(codigo: number, responsavel: number) {
+        const conexao = await this.getConexao();
+
+        try {
+            await conexao.beginTransaction();
+
+            const projeto = await this.projetoExiste(codigo);
+            if (!projeto) throw new Error("Projeto não encontrado.");
+
+            const funcionario = await this.funcionarioExiste(responsavel);
+            if (!funcionario) throw new Error("Responsável não encontrado.");
+
+            await conexao.query(
+                "UPDATE projeto SET responsavel = ? WHERE codigo = ?",
+                [responsavel, codigo]
+            );
+
+            await conexao.commit();
+            return { success: true, message: "Líder atualizado com sucesso!" };
+        } catch (error: any) {
+            await conexao.rollback();
+            console.error("Erro ao mudar líder:", error.message);
+            return { success: false, message: error.message };
+        } finally {
+            if (this.conexao) await this.conexao.close();
+            this.conexao = null;
+        }
+    }
+
+    async projetoExiste(codigo: number): Promise<any> {
+        const conexao = await this.getConexao();
+        const [projeto] = await conexao.query(
+            "SELECT 1 FROM projeto WHERE codigo = ?",
+            [codigo]
+        );
+        return projeto;
+    }
+
+    private async funcionarioExiste(responsavel: number): Promise<any> {
+        const conexao = await this.getConexao();
+        const funcionarioRepo = new FuncionarioRepository(conexao, responsavel);
+        const funcionario = await funcionarioRepo.fucionarioExiste();
+        return funcionario;
+    }
+}
+
+export default new ProjetoRepository();

database/20252/tarefas/Anderson_Gabriel/orm/odbc/schema/atividade.shcema.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+export const atividadeSchema = z.object({
+  descricao: z.string().min(1, "Descrição obrigatória."),
+  projeto: z.number().optional(),
+  data_inicio: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Data inválida (AAAA-MM-DD)."),
+  data_fim: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Data inválida (AAAA-MM-DD).")
+});

database/20252/tarefas/Anderson_Gabriel/orm/odbc/service/server.ts

@@ -0,0 +1,11 @@
+import odbc from "odbc";
+
+async function conexaoODBC(): Promise<odbc.Connection> {
+    try {
+        return await odbc.connect("DSN=MeuPostgres");
+    } catch {
+        throw new Error('Erro ao solicitar a conexão!');
+    }
+}
+
+export default conexaoODBC;

database/20252/tarefas/Anderson_Gabriel/orm/orm/database/model/atividade.model.ts

@@ -0,0 +1,27 @@
+import { DataTypes } from "sequelize";
+import { sequelize } from "../sequelize";
+import { Projeto } from "./projeto.model";
+
+export const Atividade = sequelize.define(
+    "atividade",
+    {
+        codigo: {
+            type: DataTypes.INTEGER,
+            primaryKey: true,
+            autoIncrement: true,
+        },
+        descricao: { type: DataTypes.STRING(250) },
+        data_inicio: { type: DataTypes.DATE },
+        data_fim: { type: DataTypes.DATE },
+    },
+    {
+        tableName: "atividade",
+        freezeTableName: false,
+        timestamps: false,
+    }
+);
+
+Atividade.belongsTo(Projeto, {
+    foreignKey: "projeto",
+    as: "projetoAssociado",
+});

database/20252/tarefas/Anderson_Gabriel/orm/orm/database/model/funcionario.model.ts

@@ -0,0 +1,24 @@
+import { DataTypes } from "sequelize";
+import { sequelize } from "../sequelize";
+
+export const Funcionario = sequelize.define(
+    "funcionario",
+    {
+        codigo: {
+            type: DataTypes.INTEGER,
+            primaryKey: true,
+            autoIncrement: true,
+        },
+        nome: { type: DataTypes.STRING(150), allowNull: false },
+        sexo: { type: DataTypes.CHAR(1) },
+        dt_nasc: { type: DataTypes.DATE },
+        salario: { type: DataTypes.DECIMAL },
+        supervisor: { type: DataTypes.INTEGER, allowNull: true },
+        depto: { type: DataTypes.INTEGER, allowNull: true },
+    },
+    {
+        tableName: "funcionario",
+        freezeTableName: false,
+        timestamps: false,
+    }
+);

database/20252/tarefas/Anderson_Gabriel/orm/orm/database/model/projeto.model.ts

@@ -0,0 +1,30 @@
+// projeto.model.ts
+import { DataTypes } from "sequelize";
+import { sequelize } from "../sequelize";
+import { Funcionario } from "./funcionario.model";
+
+export const Projeto = sequelize.define(
+    "projeto",
+    {
+        codigo: {
+            type: DataTypes.INTEGER,
+            primaryKey: true,
+            autoIncrement: true,
+        },
+        nome: { type: DataTypes.STRING(50), unique: true },
+        descricao: { type: DataTypes.STRING(250) },
+        depto: { type: DataTypes.INTEGER, allowNull: true },
+        data_inicio: { type: DataTypes.DATE },
+        data_fim: { type: DataTypes.DATE },
+    },
+    {
+        tableName: "projeto",
+        freezeTableName: true,
+        timestamps: false,
+    }
+);
+
+Projeto.belongsTo(Funcionario, {
+    foreignKey: 'responsavel',
+    as: 'funcionarioAssociado'
+})

database/20252/tarefas/Anderson_Gabriel/orm/orm/database/sequelize.ts

@@ -0,0 +1,6 @@
+import { Sequelize } from "sequelize";
+
+export const sequelize = new Sequelize("atividade_db", "admin", "senha", {
+    dialect: "postgres",
+    host: "localhost",
+});