Merge branch 'main' of https://github.com/nicolasreisdev/CTable into config/create-issues-smells/nicoals

Author: nicolasreisdev

README.md

@@ -20,7 +20,7 @@ Construir um sistema de ponta a ponta que rastreia fóruns, processa o texto das
 
 ### Rode a migration
 
-- Para criar o arquivo em databse.bd, no terminal, na pasta backend, execute: npx knex migrate:latest --knexfile knexfile.ts
+- Para criar o arquivo em databse.bd, no terminal, na pasta backend/src, execute: npx knex migrate:latest --knexfile knexfile.ts
 
 
 ## Criar seeds (popular tabelas)

backend/package-lock.json

@@ -15,22 +15,23 @@
   "license": "ISC",
   "type": "commonjs",
   "devDependencies": {
-    "@types/cors": "^2.8.19",
     "@types/bcryptjs": "^2.4.6",
-    "@types/jest": "^30.0.0",
+    "@types/cors": "^2.8.19",
     "@types/express": "^5.0.5",
+    "@types/jest": "^30.0.0",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^24.3.1",
     "@types/supertest": "^6.0.3",
     "jest": "^30.2.0",
     "supertest": "^7.1.4",
     "ts-jest": "^29.4.5",
+    "ts-node": "^10.9.2",
     "ts-node-dev": "^2.0.0",
     "typescript": "^5.9.2"
   },
   "dependencies": {
-    "cors": "^2.8.5",
     "bcryptjs": "^3.0.3",
+    "cors": "^2.8.5",
     "express": "^5.1.0",
     "jsonwebtoken": "^9.0.2",
     "knex": "^3.1.0",

backend/package.json

@@ -42,7 +42,72 @@ class businessLogicProject{
         });
     }
 
-    updateProject(){
+    async updateProject(projectId: string, projectData: Partial<any>, userId: number) {
+        
+        return knex.transaction(async (trx) => {
+            
+            // Busca projeto e valida autoria
+            const existingProject = await trx('Projects') 
+                .where({ projectID: projectId })
+                .first();
+
+            if (!existingProject) {
+                throw new Error("Projeto não encontrado.");
+            }
+
+            if (existingProject.creatorID !== userId) {
+                throw new Error("Você não tem permissão para editar este projeto.");
+            }
+
+            // Prepara campos da tabela PRINCIPAL (Projects)
+            const fieldsToUpdate: any = {};
+
+            if (projectData.title !== undefined) fieldsToUpdate.title = projectData.title;
+            if (projectData.description !== undefined) fieldsToUpdate.description = projectData.description;
+            if (projectData.status !== undefined) fieldsToUpdate.status = projectData.status;
+            if (projectData.startDate !== undefined) fieldsToUpdate.startDate = projectData.startDate;
+
+            // Atualiza o 'updatedAt' se houver mudanças nos campos principais
+            if (Object.keys(fieldsToUpdate).length > 0) {
+                fieldsToUpdate.updatedAt = new Date();
+                
+                await trx('Projects')
+                    .where({ projectID: projectId })
+                    .update(fieldsToUpdate);
+            }
+
+            // Atualiza a tabela de relacionamento (ProjectsKeywords)
+            if (projectData.technologies !== undefined) {
+                
+                // Remove TODAS as associações antigas desse projeto
+                await trx('ProjectsKeywords')
+                    .where({ projectID: projectId })
+                    .del();
+
+                // Se a nova lista não estiver vazia, insere as novas
+                if (Array.isArray(projectData.technologies) && projectData.technologies.length > 0) {
+                    
+                    // Busca os IDs das tags (Keywords) baseadas no nome (string) enviado pelo front
+                    const keywordIDs = await trx('Keywords')
+                        .whereIn('tag', projectData.technologies)
+                        .select('keywordID');
+
+                    // Prepara o array de inserção
+                    const linksToInsert = keywordIDs.map((k: any) => ({
+                        projectID: projectId,
+                        keywordID: k.keywordID
+                    }));
+
+                    // Insere
+                    if (linksToInsert.length > 0) {
+                        await trx('ProjectsKeywords').insert(linksToInsert);
+                    }
+                }
+            }
+
+            // Retorna o projeto atualizado
+            return await trx('Projects').where({ projectID: projectId }).first();
+        });
     }
 
     async userProjects(creatorID: number){

backend/src/business/businessLogicProject.ts

@@ -91,6 +91,18 @@ class requestController {
             throw error;
         }
     }
+
+    async updateProject(projectId: string, data: projectData, userId: number){
+        try{
+
+            const updatedProject = await businessLogicProject.updateProject(projectId, data, userId);
+
+            return updatedProject;
+
+        }catch(error){
+            throw error;
+        }
+    }
 }
 
 export default new requestController();

backend/src/controller/requestController.ts

@@ -134,4 +134,37 @@ routes.get('/api/user/projects', authMiddleware, async(request, response) => {
     }
 })
 
+// Endpoint para atualizar um projeto existente
+routes.put('/api/user/updateproject/:projectId', authMiddleware, async(request, response) => {
+  try{
+    const { projectId } = request.params;
+    const updatedData = request.body;
+    const creatorID = request.user.id;
+
+    const updatedProject = await requestController.updateProject(projectId, updatedData, creatorID);
+
+    return response.status(200).json({
+      message: "Projeto atualizado com sucesso!",
+      project: updatedProject
+    });
+
+  }catch(error){
+
+    if (error instanceof z.ZodError) { 
+      return response.status(400).json({ 
+           message: "Erro de validação",
+           errors: error.flatten().fieldErrors 
+      });
+    }
+
+    if(error instanceof Error){ 
+      return response.status(400).json({ message: error.message });
+    }
+    
+    console.error("Erro interno no servidor:", error);
+    return response.status(500).json({ message: "Erro interno no servidor." });
+
+  }
+});
+
 export default routes;

backend/src/routes.ts

@@ -1,4 +1,4 @@
-interface LoginProps {
+export interface LoginProps {
   username: string;
   senha: string;
 }
@@ -18,11 +18,12 @@ export async function Login(data: LoginProps) {
   }
 
   const {user, token} = await response.json();
-  localStorage.setItem('token', token);
+  console.log("Dados do usuário logado:", user);
+  return { user, token };
 
 }
 
-interface RegisterProps {
+export interface RegisterProps {
   nomeCompleto: string;
   username: string;
   email: string;
@@ -44,4 +45,15 @@ export async function Register(data: RegisterProps) {
     const errorData = await response.json();  
     throw new Error(errorData.message);  
   }
+}
+
+export function logout() {
+  localStorage.removeItem('token');
+  localStorage.removeItem('user');
+}
+
+export function getCurrentUser() {
+  const userString = localStorage.getItem('user');
+  if (!userString) return null;
+  return JSON.parse(userString);
 }

frontend/src/API/Auth.ts

@@ -0,0 +1,82 @@
+import React, { createContext, useContext, useState, useEffect } from 'react';
+import type { ReactNode } from 'react';
+import * as api from './Auth'; 
+import type { LoginProps } from './Auth';
+
+interface User {
+  id: string; 
+  username: string;
+  nomeCompleto?: string;
+  email?: string;
+}
+
+interface AuthContextType {
+  currentUser: User | null;
+  login: (data: LoginProps) => Promise<void>;
+  logout: () => void;
+  isAuthenticated: boolean;
+}
+
+// Crie o Contexto
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+// Crie o Provedor (Provider)
+export const AuthProvider: React.FC<{ children: ReactNode }> = ({ children }) => {
+  const [currentUser, setCurrentUser] = useState<User | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+
+  // Ao carregar o app, tente buscar o usuário do localStorage
+  useEffect(() => {
+    try {
+      const user = api.getCurrentUser();
+      const token = localStorage.getItem('token');
+      if (user && token) {
+        setCurrentUser(user);
+      }
+    } catch (error) {
+      console.error("Falha ao carregar usuário:", error);
+      api.logout(); // Limpa dados corrompidos
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  // Função de login que atualiza o estado E o localStorage
+  const login = async (data: LoginProps) => {
+    const { user, token } = await api.Login(data); // Chama sua API
+    localStorage.setItem('token', token);
+    localStorage.setItem('user', JSON.stringify(user));
+    setCurrentUser(user);
+  };
+
+  // Função de logout que limpa tudo
+  const logout = () => {
+    api.logout();
+    setCurrentUser(null);
+  };
+
+  // Não renderize o app até sabermos se o usuário está logado
+  if (isLoading) {
+    return <div>Carregando...</div>; // Ou um componente de Spinner
+  }
+
+  return (
+    <AuthContext.Provider value={{ 
+      currentUser, 
+      login, 
+      logout, 
+      isAuthenticated: !!currentUser 
+    }}>
+      {children}
+    </AuthContext.Provider>
+  );
+};
+
+// Hook customizado
+export const useAuth = () => {
+  const context = useContext(AuthContext);
+  if (context === undefined) {
+    throw new Error('useAuth deve ser usado dentro de um AuthProvider');
+  }
+  return context;
+};

frontend/src/API/AuthContext.tsx

@@ -0,0 +1,7 @@
+export interface CommentProps {
+  name: string;
+  description: string;
+  technologies: string[]; 
+  status: string;
+  date: string;
+}

frontend/src/API/Comment.ts

@@ -0,0 +1,24 @@
+export interface CommunityProps {
+    communityID: string;
+    name: string;
+    description: string;
+    keywords: string[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export async function NewCommunity(data: CommunityProps) { 
+  /* const response = await fetch('http://localhost:3000/api/user/newcommunity', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${localStorage.getItem('token')}`,
+    },
+    body: JSON.stringify(data),
+  });
+
+  if (!response.ok) {
+    const errorData = await response.json();  
+    throw new Error(errorData.message);  
+  } */
+}