112:"ExplicitChatIdProvider" 113:I[903690,["$49","$4a","$4b","$4c","$4d","$4e","$4f","$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7a","$8c","$8d","$7c","$85","$7f","$7e","$8e","$80","$8f","$90","$91","$7d","$92","$87","$8a","$84","$83","$88","$89","$93","$94","$86","$95","$82"],"$112"] 114:I[838238,["$49","$4a","$4b","$4c","$4d","$4e","$4f","$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7a","$8c","$8d","$7c","$85","$7f","$7e","$8e","$80","$8f","$90","$91","$7d","$92","$87","$8a","$84","$83","$88","$89","$93","$94","$86","$95","$82"],"SWRDataProvider"] 116:[] 117:[["b_eTuQUmnnxt1",null],["b_MZqbVnZGitl",null],["b_BDOki41DZtg",null]] 118:[["b_eTuQUmnnxt1",{"templateVersionId":null,"templateCanonId":null}],["b_MZqbVnZGitl",{"templateVersionId":null,"templateCanonId":null}],["b_BDOki41DZtg",{"templateVersionId":null,"templateCanonId":null}]] 119:[["uaOMc9bRGXL","$D2025-12-16T20:50:54.475Z"],["b_cruJOuyW5cs","$D2025-12-16T20:54:43.194Z"],["b_eTuQUmnnxt1","$D2025-12-16T21:20:08.084Z"],["b_MZqbVnZGitl","$D2025-12-16T21:22:07.546Z"],["b_BDOki41DZtg","$D2025-12-16T21:31:43.314Z"]] 11a:[["b_eTuQUmnnxt1",false],["b_MZqbVnZGitl",false],["b_BDOki41DZtg",false]] 11b:[["b_eTuQUmnnxt1","$undefined"],["b_MZqbVnZGitl",{"deploymentId":"dpl_AZxufBbEXGMsUwv21No3M5QKEdL8"}],["b_BDOki41DZtg","$undefined"]] 11c:[["b_eTuQUmnnxt1",null],["b_MZqbVnZGitl",null],["b_BDOki41DZtg",null]] 11d:[["b_eTuQUmnnxt1",true],["b_MZqbVnZGitl",true],["b_BDOki41DZtg",true]] 11e:[["b_eTuQUmnnxt1",true],["b_MZqbVnZGitl",true],["b_BDOki41DZtg",true]] 11f:[] 120:T4f7,O usuário forneceu um esquema de design detalhado para um sistema web/mobile com as seguintes especificações: 1. **Esquema de Cores:** - Verde como cor primária (ações, botões, sucesso) - Branco como cor de fundo e conteúdo - Preto para texto primário e contraste - Verde intenso e vibrante mas profissional (esmeralda ou floresta) 2. **Performance:** - Design minimalista e limpo - Ícones SVG leves - Evitar animações pesadas - Carregamento rápido 3. **Funcionalidade/UX:** - Interface intuitiva e funcional - Uso eficaz de espaço em branco - Navegação óbvia e direta - CTAs com alto contraste e feedback visual 4. **Saída Esperada:** - Paleta de cores com hex codes - Tipografia (fontes leves como Inter, Roboto) - Layout principal (Header, Sidebar, Content Area) - Estilo de componentes (Botões, Forms, Cards) Preciso implementar esse design no sistema existente. Vou: 1. Atualizar o globals.css com a nova paleta de cores (design tokens) 2. Atualizar o layout.tsx com fontes adequadas 3. Criar/atualizar componentes principais seguindo o novo design 4. Garantir que seja minimalista e performático Primeiro, vou examinar a estrutura atual do projeto para entender o que precisa ser atualizado.121:T2ed823,[V0_FILE]plaintext:file=".gitignore" isMerged="true" # See https://help.github.com/articles/ignoring-files/ for more about ignoring files. # dependencies /node_modules # next.js /.next/ /out/ # production /build # debug npm-debug.log* yarn-debug.log* yarn-error.log* .pnpm-debug.log* # env files .env* # vercel .vercel # typescript *.tsbuildinfo next-env.d.ts [V0_FILE]markdown:file="README.md" isMerged="true" # Sistema de Gestão Inteligente *Version 2025.1.0 - Business Management System* *Automatically synced with your [v0.dev](https://v0.dev) deployments* [![Deployed on Vercel](https://img.shields.io/badge/Deployed%20on-Vercel-black?style=for-the-badge&logo=vercel)](https://vercel.com/certo7252-2575s-projects/v0-ozai-sistema-gestao-inteligente) [![Built with v0](https://img.shields.io/badge/Built%20with-v0.dev-black?style=for-the-badge)](https://v0.dev/chat/projects/MASdPF5asyp) ## Overview Sistema de Gestão Inteligente is a comprehensive business management system designed for modern enterprises. This repository stays in sync with your deployed chats on [v0.dev](https://v0.dev). **Version:** 2025.1.0 **Release Date:** January 2025 ## Deployment Your project is live at: **[https://vercel.com/certo7252-2575s-projects/v0-ozai-sistema-gestao-inteligente](https://vercel.com/certo7252-2575s-projects/v0-ozai-sistema-gestao-inteligente)** ## Build your app Continue building your app on: **[https://v0.dev/chat/projects/MASdPF5asyp](https://v0.dev/chat/projects/MASdPF5asyp)** ## How It Works 1. Create and modify your project using [v0.dev](https://v0.dev) 2. Deploy your chats from the v0 interface 3. Changes are automatically pushed to this repository 4. Vercel deploys the latest version from this repository ## Version History - **2025.1.0** - Initial release with comprehensive business management features --- [V0_FILE]javascriptreact:file="app/admin/users/page.jsx" isMerged="true" "use client" import { useEffect } from "react" import { useRouter } from "next/navigation" import { useAuth } from "@/contexts/auth-context" import { UserListTable } from "@/components/admin/UserListTable" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Users, Home, AlertTriangle } from "lucide-react" import { Button } from "@/components/ui/button" import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert" export default function AdminUsersPage() { const { user, isLoading } = useAuth() const router = useRouter() useEffect(() => { if (!isLoading) { console.log("[v0] [Admin Users Page] User check:", { hasUser: !!user, userEmail: user?.email, userRole: user?.role, isAdmin: user?.role === "admin", }) if (!user) { console.log("[v0] [Admin Users Page] No user found - redirecting to login") } else if (user.role !== "admin" && user.role !== "gerente") { console.log("[v0] [Admin Users Page] User is not admin or gerente - showing access denied message") } } }, [user, isLoading]) // Show loading state while checking authentication if (isLoading) { return (

A carregar...

) } if (!user || (user.role !== "admin" && user.role !== "gerente")) { return (

{/* Page Header with Back Button */}

Acesso Negado

Você não tem permissão para acessar esta página

{/* Access Denied Alert */} Permissão Insuficiente {!user ? ( <> Você precisa estar autenticado para acessar a Gestão de Utilizadores. Por favor, faça login com uma conta de administrador. ) : ( <> Apenas utilizadores com perfil de Administrador ou Gerente podem acessar esta página.
Seu perfil atual: {user.role === "supervisor" ? "Supervisor" : user.role}

{user.role === "supervisor" ? ( <> Como Supervisor, você tem acesso a todos os dados operacionais do sistema, mas a Gestão de Utilizadores é restrita aos Administradores e Gerentes. ) : ( <>Se você precisa de acesso administrativo, entre em contato com um administrador do sistema. )} )} {/* Help Card */} Precisa de Ajuda? Informações sobre acesso à Gestão de Utilizadores

Quem pode acessar?

Apenas utilizadores com perfil de Administrador ou Gerente têm acesso à Gestão de Utilizadores.

Como obter acesso?

Entre em contato com um administrador do sistema para solicitar permissões administrativas.

Contas de teste disponíveis:

• admin@ozai.ao - Administrador (acesso total)
• supervisor@ozai.ao - Supervisor
• gerente@ozai.ao - Gerente
• funcionario@ozai.ao - Funcionário

Senhas válidas: ozai2025, admin123, endiama2025

) } return (

{/* Page Header with Back Button */}

Gestão de Utilizadores

Gerir utilizadores do sistema com integração ao Registo Técnico (R.H.)

{/* Main Content Card */} Utilizadores do Sistema Lista completa de utilizadores com acesso ao sistema. Crie novos utilizadores a partir do Registo Técnico.

) } [V0_FILE]typescript:file="app/api/admin/users/[id]/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { userService } from "@/lib/database-service" export async function GET(request: NextRequest, { params }: { params: { id: string } }) { try { const userId = params.id const user = await userService.getById(userId) if (!user) { return NextResponse.json({ error: "Usuário não encontrado" }, { status: 404 }) } return NextResponse.json({ user, hasEmployeeLink: false, }) } catch (error) { console.error("Erro ao buscar usuário:", error) return NextResponse.json({ error: "Erro interno do servidor" }, { status: 500 }) } } export async function PUT(request: NextRequest, { params }: { params: { id: string } }) { try { const userId = params.id const body = await request.json() const { name, email, phone, role, status, department } = body // Update user const updatedUser = await userService.update(userId, { name, email, phone, role, status, department, updated_at: new Date().toISOString(), }) console.log("[v0] Usuário atualizado:", { id: userId, email: updatedUser.email, }) return NextResponse.json({ success: true, user: updatedUser, message: "Usuário atualizado com sucesso", }) } catch (error) { console.error("Erro ao atualizar usuário:", error) return NextResponse.json({ error: "Erro interno do servidor" }, { status: 500 }) } } export async function DELETE(request: NextRequest, { params }: { params: { id: string } }) { try { const userId = params.id const user = await userService.getById(userId) if (!user) { return NextResponse.json({ error: "Usuário não encontrado" }, { status: 404 }) } // Soft delete - set status to inactive instead of hard delete await userService.update(userId, { status: "inativo", updated_at: new Date().toISOString(), }) console.log("[v0] Usuário desativado:", { id: userId, email: user.email, }) return NextResponse.json({ success: true, message: "Usuário desativado com sucesso", }) } catch (error) { console.error("Erro ao desativar usuário:", error) return NextResponse.json({ error: "Erro interno do servidor" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/admin/users/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { userService } from "@/lib/database-service" export async function POST(request: NextRequest) { try { const body = await request.json() const { name, email, phone, role, department, temporaryPassword } = body // Validate required fields if (!name || !email || !role) { return NextResponse.json({ error: "Nome, email e role são obrigatórios" }, { status: 400 }) } // Check if email already exists const existingUser = await userService.getByEmail(email) if (existingUser) { return NextResponse.json({ error: "Email já está em uso" }, { status: 409 }) } // Create user const newUser = await userService.create({ name, email, phone: phone || "", role, status: "ativo", department: department || "", created_at: new Date().toISOString(), updated_at: new Date().toISOString(), }) console.log("[v0] Usuário criado via Admin:", { id: newUser.id, email: newUser.email, role: newUser.role, }) return NextResponse.json( { success: true, user: newUser, message: "Usuário criado com sucesso", }, { status: 201 }, ) } catch (error) { console.error("Erro ao criar usuário:", error) return NextResponse.json({ error: "Erro interno do servidor" }, { status: 500 }) } } export async function GET(request: NextRequest) { try { const { searchParams } = new URL(request.url) const role = searchParams.get("role") const status = searchParams.get("status") const department = searchParams.get("department") console.log("[v0] Buscando usuários com filtros:", { role, status, department }) const users = await userService.getAll() // Apply filters let filteredUsers = users if (role) { filteredUsers = filteredUsers.filter((user) => user.role === role) } if (status) { filteredUsers = filteredUsers.filter((user) => user.status === status) } if (department) { filteredUsers = filteredUsers.filter((user) => user.department === department) } return NextResponse.json({ users: filteredUsers }) } catch (error) { console.error("Erro ao buscar usuários:", error) return NextResponse.json({ error: "Erro interno do servidor" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/backup/create/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { firebaseBackupService } from "@/lib/firebase-backup-service" export async function POST(request: NextRequest) { try { const body = await request.json() const { userId } = body if (!userId) { return NextResponse.json({ error: "User ID is required" }, { status: 400 }) } console.log("[v0] Creating backup for user:", userId) const result = await firebaseBackupService.createBackup(userId) if (result.success) { return NextResponse.json({ success: true, backupId: result.backupId, message: "Backup created successfully", }) } else { return NextResponse.json({ error: result.error }, { status: 500 }) } } catch (error) { console.error("[v0] Error creating backup:", error) return NextResponse.json({ error: "Failed to create backup" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/backup/info/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { firebaseBackupService } from "@/lib/firebase-backup-service" export async function GET(request: NextRequest) { try { const searchParams = request.nextUrl.searchParams const userId = searchParams.get("userId") if (!userId) { return NextResponse.json({ error: "User ID is required" }, { status: 400 }) } const lastBackup = await firebaseBackupService.getLastBackupDate(userId) return NextResponse.json({ lastBackup, hasBackup: lastBackup !== null, }) } catch (error) { console.error("[v0] Error fetching backup info:", error) return NextResponse.json({ error: "Failed to fetch backup info" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/notifications/email/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { notificationService } from "@/lib/notification-service" export async function POST(request: NextRequest) { try { const body = await request.json() const { type, data } = body if (!type) { return NextResponse.json({ error: "Tipo de notificação é obrigatório" }, { status: 400 }) } const success = await notificationService.sendEmailNotification(type, data) if (success) { return NextResponse.json({ success: true, message: "Email enviado com sucesso", }) } else { return NextResponse.json({ error: "Falha ao enviar email" }, { status: 500 }) } } catch (error) { console.error("Erro na API de email:", error) return NextResponse.json({ error: "Erro interno do servidor" }, { status: 500 }) } } export async function GET(request: NextRequest) { try { const { searchParams } = new URL(request.url) const action = searchParams.get("action") switch (action) { case "history": const history = notificationService.getEmailHistory() return NextResponse.json({ emails: history }) case "stats": const stats = notificationService.getEmailStats() return NextResponse.json(stats) default: return NextResponse.json({ error: "Ação não especificada" }, { status: 400 }) } } catch (error) { console.error("Erro ao buscar dados de email:", error) return NextResponse.json({ error: "Erro interno do servidor" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/notifications/preferences/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" export async function PUT(request: NextRequest) { try { const body = await request.json() const { userId, preferences } = body console.log(`[v0] Updating notification preferences for user ${userId}:`, preferences) // Here you would: // 1. Save preferences to database // 2. Configure email service (SendGrid, AWS SES, etc.) // 3. Configure SMS service (Twilio, AWS SNS, etc.) // 4. Update push notification subscriptions return NextResponse.json({ success: true, message: "Preferências de notificação atualizadas", }) } catch (error) { return NextResponse.json({ error: "Erro ao atualizar preferências" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/notifications/sms/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { notificationService } from "@/lib/notification-service" export async function POST(request: NextRequest) { try { const body = await request.json() const { type, data } = body if (!type) { return NextResponse.json({ error: "Tipo de notificação é obrigatório" }, { status: 400 }) } const success = await notificationService.sendNotification(type, data) if (success) { return NextResponse.json({ success: true, message: "SMS enviado com sucesso", }) } else { return NextResponse.json({ error: "Falha ao enviar SMS" }, { status: 500 }) } } catch (error) { console.error("Erro na API de SMS:", error) return NextResponse.json({ error: "Erro interno do servidor" }, { status: 500 }) } } export async function GET(request: NextRequest) { try { const { searchParams } = new URL(request.url) const action = searchParams.get("action") switch (action) { case "history": const history = notificationService.getNotificationHistory() return NextResponse.json({ sms: history }) case "stats": const stats = notificationService.getNotificationStats() return NextResponse.json(stats) default: return NextResponse.json({ error: "Ação não especificada" }, { status: 400 }) } } catch (error) { console.error("Erro ao buscar dados de SMS:", error) return NextResponse.json({ error: "Erro interno do servidor" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/public/stats/route.ts" isMerged="true" import { NextResponse } from "next/server" import { statsService, userService, orderService } from "@/lib/database-service" export async function GET() { try { const [dashboardStats, users, orders] = await Promise.all([ statsService.getDashboardStats(), userService.getAll(), orderService.getAll(), ]) // Calculate real statistics const activeUsers = users.filter((u) => u.status === "ativo").length const totalTransactions = orders.length // Calculate average response time (simulated based on system performance) const avgResponseTime = 85 // ms - can be calculated from actual API metrics // Calculate uptime percentage (can be integrated with monitoring service) const uptime = 99.9 // percentage return NextResponse.json({ uptime, activeUsers, transactionsPerDay: totalTransactions, responseTime: avgResponseTime, }) } catch (error) { console.error("Error fetching public stats:", error) // Return fallback values if there's an error return NextResponse.json({ uptime: 99.9, activeUsers: 500, transactionsPerDay: 10000, responseTime: 95, }) } } [V0_FILE]typescript:file="app/api/reset/initiate/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" /** * POST /api/reset/initiate * Inicia o processo de reset zero */ export async function POST(request: NextRequest) { try { // Validar autorização const authHeader = request.headers.get("authorization") if (!authHeader?.startsWith("Bearer ")) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const body = await request.json() const { reason, backupName } = body if (!reason) { return NextResponse.json({ error: "Motivo do reset é obrigatório" }, { status: 400 }) } console.log("[API] Reset iniciado", { reason, backupName, timestamp: new Date().toISOString(), }) // Gerar código de confirmação const confirmationCode = Math.random().toString(36).substring(2, 10).toUpperCase() // Aqui você enviaria um email com o código return NextResponse.json({ success: true, confirmationCode, message: "Email de confirmação enviado", backupName, }) } catch (error) { console.error("[API] Erro ao iniciar reset:", error) return NextResponse.json( { error: "Erro ao iniciar reset", details: error instanceof Error ? error.message : "Erro desconhecido", }, { status: 500 }, ) } } [V0_FILE]typescript:file="app/api/reset/status/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" /** * GET /api/reset/status * Retorna status das últimas operações de reset */ export async function GET(request: NextRequest) { try { // Validar autorização const authHeader = request.headers.get("authorization") if (!authHeader?.startsWith("Bearer ")) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Aqui você buscaria os logs de auditoria const status = { lastReset: null, lastResetBy: null, backupsCount: 0, totalItemsDeleted: 0, systemStatus: "READY", } return NextResponse.json({ success: true, status, timestamp: new Date().toISOString(), }) } catch (error) { console.error("[API] Erro ao obter status:", error) return NextResponse.json( { error: "Erro ao obter status", details: error instanceof Error ? error.message : "Erro desconhecido", }, { status: 500 }, ) } } [V0_FILE]typescript:file="app/api/reset/validate/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" /** * GET /api/reset/validate * Valida o estado pós-reset */ export async function GET(request: NextRequest) { try { // Validar autorização const authHeader = request.headers.get("authorization") if (!authHeader?.startsWith("Bearer ")) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Aqui você executaria as validações const validation = { localStorageClean: true, sessionStorageClean: true, firebaseEmpty: true, indexedDBClean: true, isCompletelyClean: true, } return NextResponse.json({ success: true, validation, timestamp: new Date().toISOString(), }) } catch (error) { console.error("[API] Erro ao validar reset:", error) return NextResponse.json( { error: "Erro ao validar reset", details: error instanceof Error ? error.message : "Erro desconhecido", }, { status: 500 }, ) } } [V0_FILE]typescript:file="app/api/users/[id]/avatar/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" export async function POST(request: NextRequest, { params }: { params: { id: string } }) { try { const formData = await request.formData() const file = formData.get("avatar") as File if (!file) { return NextResponse.json({ error: "Nenhum arquivo enviado" }, { status: 400 }) } // Validate file type and size const allowedTypes = ["image/jpeg", "image/png", "image/gif"] if (!allowedTypes.includes(file.type)) { return NextResponse.json({ error: "Tipo de arquivo não permitido" }, { status: 400 }) } if (file.size > 2 * 1024 * 1024) { return NextResponse.json({ error: "Arquivo muito grande (máximo 2MB)" }, { status: 400 }) } // Here you would upload to storage service (Vercel Blob, AWS S3, etc.) console.log(`[v0] Uploading avatar for user ${params.id}:`, { filename: file.name, size: file.size, type: file.type, }) return NextResponse.json({ success: true, message: "Avatar atualizado com sucesso", avatar_url: `/uploads/avatars/${params.id}.jpg`, }) } catch (error) { return NextResponse.json({ error: "Erro ao fazer upload do avatar" }, { status: 500 }) } } export async function DELETE(request: NextRequest, { params }: { params: { id: string } }) { try { console.log(`[v0] Removing avatar for user ${params.id}`) return NextResponse.json({ success: true, message: "Avatar removido com sucesso", }) } catch (error) { return NextResponse.json({ error: "Erro ao remover avatar" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/users/[id]/language/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" export async function PUT(request: NextRequest, { params }: { params: { id: string } }) { try { const body = await request.json() const { language } = body // Validate language if (!["pt", "en"].includes(language)) { return NextResponse.json({ error: "Idioma não suportado" }, { status: 400 }) } console.log(`[v0] Updating language preference for user ${params.id}:`, language) // Update user language preference in database const { createServerClient } = await import("@supabase/ssr") const { cookies } = await import("next/headers") const cookieStore = cookies() const supabase = createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!, { cookies: { get(name: string) { return cookieStore.get(name)?.value }, }, }) // Insert or update language preference const { error: dbError } = await supabase.from("user_language_preferences").upsert( { user_id: Number.parseInt(params.id), language: language, updated_at: new Date().toISOString(), }, { onConflict: "user_id", }, ) if (dbError) { console.error("[v0] Database error updating language:", dbError) return NextResponse.json({ error: "Erro ao salvar preferência de idioma" }, { status: 500 }) } console.log(`[v0] Language preference saved successfully for user ${params.id}`) return NextResponse.json({ success: true, message: language === "en" ? "Language updated successfully" : "Idioma atualizado com sucesso", language, }) } catch (error) { console.error("[v0] Error updating language:", error) return NextResponse.json( { error: "Erro ao atualizar idioma", }, { status: 500 }, ) } } export async function GET(request: NextRequest, { params }: { params: { id: string } }) { try { console.log(`[v0] Fetching language preference for user ${params.id}`) const { createServerClient } = await import("@supabase/ssr") const { cookies } = await import("next/headers") const cookieStore = cookies() const supabase = createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!, { cookies: { get(name: string) { return cookieStore.get(name)?.value }, }, }) const { data, error } = await supabase .from("user_language_preferences") .select("language") .eq("user_id", Number.parseInt(params.id)) .single() if (error && error.code !== "PGRST116") { // PGRST116 = no rows returned console.error("[v0] Database error fetching language:", error) return NextResponse.json({ error: "Erro ao buscar preferência de idioma" }, { status: 500 }) } const language = data?.language || "pt" // Default to Portuguese console.log(`[v0] Language preference retrieved: ${language}`) return NextResponse.json({ success: true, language, }) } catch (error) { console.error("[v0] Error fetching language preference:", error) return NextResponse.json( { error: "Erro ao buscar preferência de idioma", language: "pt", // Fallback to Portuguese }, { status: 500 }, ) } } [V0_FILE]typescript:file="app/api/users/[id]/profile/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" export async function GET(request: NextRequest, { params }: { params: { id: string } }) { try { // For now, return mock data structure that would come from database const userProfile = { id: params.id, name: "Sidney Matos", email: "sidney.matos@company.co.ao", phone: "+244 900 123 456", department: "Tecnologia", avatar_url: null, created_at: new Date().toISOString(), updated_at: new Date().toISOString(), } return NextResponse.json(userProfile) } catch (error) { return NextResponse.json({ error: "Erro ao buscar perfil do usuário" }, { status: 500 }) } } export async function PUT(request: NextRequest, { params }: { params: { id: string } }) { try { const body = await request.json() // Validate and sanitize input data const { name, email, phone, department } = body // Here you would update the database console.log(`[v0] Updating profile for user ${params.id}:`, { name, email, phone, department, }) return NextResponse.json({ success: true, message: "Perfil atualizado com sucesso", }) } catch (error) { return NextResponse.json({ error: "Erro ao atualizar perfil" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/users/[id]/security/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" export async function GET(request: NextRequest, { params }: { params: { id: string } }) { try { const { id } = params // Get security settings from localStorage (in real app, from database) const settings = { twoFactorEnabled: false, emailNotifications: true, smsNotifications: false, loginAlerts: true, } return NextResponse.json(settings) } catch (error) { console.error("[v0] Error fetching security settings:", error) return NextResponse.json({ error: "Failed to fetch security settings" }, { status: 500 }) } } export async function PUT(request: NextRequest, { params }: { params: { id: string } }) { try { const { id } = params const body = await request.json() console.log("[v0] Updating security settings for user:", id, body) // In real app, save to database // For now, return success return NextResponse.json({ success: true }) } catch (error) { console.error("[v0] Error updating security settings:", error) return NextResponse.json({ error: "Failed to update security settings" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/users/[id]/sessions/[sessionId]/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" export async function DELETE(request: NextRequest, { params }: { params: { id: string; sessionId: string } }) { try { console.log(`[v0] Revoking session ${params.sessionId} for user ${params.id}`) return NextResponse.json({ success: true, message: "Sessão revogada com sucesso", }) } catch (error) { return NextResponse.json({ error: "Erro ao revogar sessão" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/users/[id]/sessions/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" export async function GET(request: NextRequest, { params }: { params: { id: string } }) { try { // This would query the sessions table for the user const activeSessions = [ { id: "session-1", device: "Chrome - Windows", location: "Luanda, Angola", ip: "197.149.84.1", lastActive: "Agora", current: true, created_at: new Date().toISOString(), }, ] console.log(`[v0] Fetching sessions for user ${params.id}`) return NextResponse.json(activeSessions) } catch (error) { return NextResponse.json({ error: "Erro ao buscar sessões ativas" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/backup/page.tsx" isMerged="true" import { RealTimeBackupInterface } from "@/components/real-time-backup-interface" export default function BackupPage() { return (

Sistema de Backup

Backup completo em tempo real de todos os módulos do sistema

) } [V0_FILE]typescriptreact:file="app/not-found.tsx" isMerged="true" "use client" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Home, ArrowLeft } from "lucide-react" import { useRouter } from "next/navigation" export default function NotFound() { const router = useRouter() return (

404

Página não encontrada A página que você está procurando não existe ou foi movida.

) } [V0_FILE]typescriptreact:file="app/orders-basic/page.tsx" isMerged="true" import { BasicOrdersTable } from "@/components/basic-orders-table" export default function BasicOrdersPage() { return (

) } [V0_FILE]typescriptreact:file="app/rh/ferias/page.tsx" isMerged="true" "use client" import { useEffect } from "react" import { useRouter } from "next/navigation" import { useAuth } from "@/contexts/auth-context" import { VacationRequests } from "@/components/hr/vacation-requests" export default function FeriasPage() { const { user, isLoading } = useAuth() const router = useRouter() useEffect(() => { if (!isLoading && !user) { router.push("/") } }, [user, isLoading, router]) if (isLoading) { return (

A carregar...

) } if (!user) { return null } return (

Solicitação de Férias

{user.role === "admin" ? "Gerencie todos os pedidos de férias da equipa" : "Crie e acompanhe os seus pedidos de férias"}

) } [V0_FILE]typescriptreact:file="app/rh/folha/page.tsx" isMerged="true" "use client" import { useEffect } from "react" import { useRouter } from "next/navigation" import { useAuth } from "@/contexts/auth-context" import { PayrollManagement } from "@/components/hr/payroll-management" import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert" import { ShieldAlert } from "lucide-react" export default function PayrollPage() { const { user } = useAuth() const router = useRouter() useEffect(() => { if (user?.role === "funcionario" || user?.role === "supervisor") { console.log(`[v0] 🚫 BLOQUEIO DE ROTA: Bloqueando acesso à Folha de Pagamento para ${user.role}`) console.log(`[v0] 🔒 Usuário: ${user.email} | Role: ${user.role}`) console.log(`[v0] ↩️ Redirecionando para dashboard...`) router.push("/") } }, [user, router]) // Show access denied message if user is not admin if (user?.role === "funcionario" || user?.role === "supervisor") { return (

Acesso Negado Você não tem permissão para aceder à Folha de Pagamento. Este módulo é exclusivo para Administradores.

) } return (

) } [V0_FILE]typescriptreact:file="app/rh/funcionarios/page.tsx" isMerged="true" "use client" import { useEffect } from "react" import { useRouter } from "next/navigation" import { useAuth } from "@/contexts/auth-context" import { EmployeeManagement } from "@/components/hr/employee-management" import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert" import { ShieldAlert } from "lucide-react" export default function EmployeesPage() { const { user } = useAuth() const router = useRouter() useEffect(() => { if (user?.role === "funcionario" || user?.role === "supervisor") { console.log(`[v0] 🚫 BLOQUEIO DE ROTA: Bloqueando acesso à Gestão de Funcionários para ${user.role}`) console.log(`[v0] 🔒 Usuário: ${user.email} | Role: ${user.role}`) console.log(`[v0] ↩️ Redirecionando para dashboard...`) router.push("/") } }, [user, router]) // Show access denied message if user is not admin if (user?.role === "funcionario" || user?.role === "supervisor") { return (

Acesso Negado Você não tem permissão para aceder à Gestão de Funcionários. Este módulo é exclusivo para Administradores.

) } return (

) } [V0_FILE]typescriptreact:file="app/rh/ponto/page.tsx" isMerged="true" "use client" import { useEffect } from "react" import { useRouter } from "next/navigation" import { useAuth } from "@/contexts/auth-context" import { EmployeeTimeClock } from "@/components/hr/employee-time-clock" import { TimeClockManagement } from "@/components/hr/time-clock-management" export default function PontoPage() { const { user, isLoading } = useAuth() const router = useRouter() useEffect(() => { if (!isLoading && !user) { router.push("/") } }, [user, isLoading, router]) if (isLoading) { return (

A carregar...

) } if (!user) { return null } // Employees see the simple clock in/out interface // Admins and supervisors see the management interface const isEmployee = user.role === "funcionario" return (

{isEmployee ? "Registo de Ponto" : "Gestão de Ponto"}

{isEmployee ? "Marque a sua entrada e saída diária" : "Gerencie rotações de horário e localizações"}

{isEmployee ? : }

) } [V0_FILE]typescriptreact:file="app/stock/page.tsx" isMerged="true" "use client" import dynamic from "next/dynamic" import { LoadingSpinner } from "@/components/loading-spinner" const GestaoStock = dynamic(() => import("@/components/gestao-stock"), { ssr: false, loading: () => (

), }) export default function StockPage() { return (

) } [V0_FILE]json:file="components.json" isMerged="true" { "$schema": "https://ui.shadcn.com/schema.json", "version": "2025.1.0", "style": "default", "rsc": true, "tsx": true, "tailwind": { "config": "tailwind.config.ts", "css": "app/globals.css", "baseColor": "neutral", "cssVariables": true, "prefix": "" }, "aliases": { "components": "@/components", "utils": "@/lib/utils", "ui": "@/components/ui", "lib": "@/lib", "hooks": "@/hooks" }, "iconLibrary": "lucide" } [V0_FILE]typescriptreact:file="components/adicionar-item.tsx" isMerged="true" "use client" import { useState, useCallback, useEffect } from "react" import { addDoc, collection, Timestamp } from "firebase/firestore" import { firebaseSingleton } from "@/lib/firebase-singleton" import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription } from "@/components/ui/dialog" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { useToast } from "@/hooks/use-toast" import { sincronizarDashboard } from "@/lib/dashboard-sync" import { idGenerationService } from "@/lib/id-generation-service" interface AdicionarItemProps { isOpen: boolean onClose: () => void onSaveSuccess: () => void } interface FormData { code: string description: string unit: string currentStock: string minimumStock: string maximumStock: string unitCost: string location: string supplier_name: string } const initialFormState: FormData = { code: "", description: "", unit: "unidade", currentStock: "0", minimumStock: "0", maximumStock: "0", unitCost: "0", location: "", supplier_name: "", } export function AdicionarItem({ isOpen, onClose, onSaveSuccess }: AdicionarItemProps) { const [formData, setFormData] = useState(initialFormState) const [isSubmitting, setIsSubmitting] = useState(false) const [isGeneratingID, setIsGeneratingID] = useState(false) const { toast } = useToast() useEffect(() => { if (isOpen) { const generateID = async () => { setIsGeneratingID(true) try { const nextID = await idGenerationService.generateNextID("stock") setFormData((prev) => ({ ...prev, code: nextID })) } catch (error) { console.error("[v0] Error generating stock ID:", error) toast({ title: "Erro", description: "Erro ao gerar código do item. Tente novamente.", variant: "destructive", }) } finally { setIsGeneratingID(false) } } generateID() } }, [isOpen, toast]) const handleInputChange = (field: keyof FormData, value: string) => { setFormData((prev) => ({ ...prev, [field]: value })) } const handleAddStock = useCallback(async () => { setIsSubmitting(true) try { console.log("[v0] Iniciando salvamento do item...") const { db } = firebaseSingleton.getInstances() const currentStock = Number.parseInt(formData.currentStock) || 0 const unitCost = Number.parseFloat(formData.unitCost) || 0 const totalValue = currentStock * unitCost const itemData = { code: formData.code, description: formData.description, unit: formData.unit, current_stock: currentStock, minimum_stock: Number.parseInt(formData.minimumStock) || 0, maximum_stock: Number.parseInt(formData.maximumStock) || 0, unit_cost: unitCost, total_value: totalValue, location: formData.location, supplier_name: formData.supplier_name, created_at: Timestamp.now(), updated_at: Timestamp.now(), } const docRef = await addDoc(collection(db, "ozai_stock_items"), itemData) console.log(`[v0] ✅ Item guardado com sucesso! ID: ${docRef.id}`) console.log("[v0] 🔄 Sincronizando Dashboard após adicionar item...") await sincronizarDashboard({ type: "item_added", itemId: docRef.id, itemName: itemData.description, }) toast({ title: "Item Criado com Sucesso", description: `Item ${itemData.code} foi adicionado ao stock.`, variant: "default", }) setFormData(initialFormState) onSaveSuccess() } catch (error) { console.error("[v0] ❌ ERRO ao guardar item:", error) } finally { setIsSubmitting(false) } }, [formData, onSaveSuccess, toast]) const handleClose = () => { if (!isSubmitting) { setFormData(initialFormState) onClose() } } return ( ) } [V0_FILE]typescriptreact:file="components/admin-module.tsx" isMerged="true" "use client" import { useState, useEffect } from "react" import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { Label } from "@/components/ui/label" import { Badge } from "@/components/ui/badge" import { Input } from "@/components/ui/input" import { Textarea } from "@/components/ui/textarea" import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription } from "@/components/ui/dialog" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { Checkbox } from "@/components/ui/checkbox" import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group" import { Shield, CheckCircle, TrendingUp, Save, Loader2, Key, Users, Database, Activity, Trash2, HardDrive, Calendar, Clock, UserPlus, Edit, Search, Filter, AlertTriangle, MessageCircle, } from "lucide-react" import { useToast } from "@/hooks/use-toast" import { useAuth } from "@/contexts/auth-context" import type { Permission } from "@/hooks/use-permissions" import { Alert, AlertDescription } from "@/components/ui/alert" import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table" import * as XLSX from "xlsx" import JSZip from "jszip" const LICENSE_CAPACITY = { admin: 5, supervisor: 10, funcionario: 50, } const availablePermissions: { [key: string]: { permission: Permission; label: string; description: string }[] } = { sistema: [ { permission: "admin.access", label: "Acesso Admin", description: "Acesso ao módulo de administração" }, { permission: "admin.users", label: "Gestão de Usuários", description: "Criar e gerir contas de utilizador" }, { permission: "admin.system", label: "Configurações", description: "Configurações do sistema" }, { permission: "admin.security", label: "Segurança", description: "Políticas de segurança" }, ], operacoes: [ { permission: "orders.view", label: "Ver Pedidos", description: "Visualizar pedidos" }, { permission: "orders.create", label: "Criar Pedidos", description: "Criar novos pedidos" }, { permission: "orders.approve", label: "Aprovar", description: "Aprovar/rejeitar pedidos" }, { permission: "equipment.manage", label: "Equipamentos", description: "Gestão de equipamentos" }, ], recursos: [ { permission: "inventory.manage", label: "Estoque", description: "Gestão de inventário" }, { permission: "reports.view", label: "Relatórios", description: "Acesso a relatórios" }, ], } interface UserFormData { name: string email: string phone: string department: string role: string status: string permissions: string[] notes: string password: string } interface BackupPreferences { schedule: "manual" | "daily" | "weekly" | "every3days" lastBackup: string | null } export function AdminModule() { const [isEditUserOpen, setIsEditUserOpen] = useState(false) const [isCreateUserOpen, setIsCreateUserOpen] = useState(false) const [searchTerm, setSearchTerm] = useState("") const [statusFilter, setStatusFilter] = useState("all") const [roleFilter, setRoleFilter] = useState("all") const [isSubmitting, setIsSubmitting] = useState(false) const [isBackingUp, setIsBackingUp] = useState(false) const [selectedUser, setSelectedUser] = useState(null) const [activeTab, setActiveTab] = useState("user-management") const [backupPreferences, setBackupPreferences] = useState({ schedule: "manual", lastBackup: null, }) const [formData, setFormData] = useState({ name: "", email: "", phone: "", department: "", role: "", status: "ativo", permissions: [], notes: "", password: "", }) const [users, setUsers] = useState([]) const { user: currentUser } = useAuth() const { toast } = useToast() const systemMetrics = { uptime: "0%", responseTime: "0ms", activeUsers: 0, totalUsers: 0, diskUsage: 0, memoryUsage: 0, cpuUsage: 0, networkStatus: "offline", lastBackup: backupPreferences.lastBackup || "Nunca", databaseSize: "0 MB", } useEffect(() => { const savedPreferences = localStorage.getItem("backup_preferences") if (savedPreferences) { setBackupPreferences(JSON.parse(savedPreferences)) } }, []) useEffect(() => { const loadUsers = () => { // Load employees from HR module const employees = JSON.parse(localStorage.getItem("employees") || "[]") setUsers(employees) } loadUsers() }, []) const updateBackupPreferences = (newPreferences: Partial) => { const updated = { ...backupPreferences, ...newPreferences } setBackupPreferences(updated) localStorage.setItem("backup_preferences", JSON.stringify(updated)) } const clearAllSimulationData = () => { console.log("[v0] [Admin] Iniciando limpeza completa de dados de simulação...") // Lista completa de chaves a remover const keysToRemove = [ "sys_users", "admin_users", "user_profiles", "audit_logs", "mock_users", "simulation_data", "test_users", "demo_data", "sample_data", "fake_users", "employees", "funcionarios", "hr_employees", "employee_data", ] let removedCount = 0 keysToRemove.forEach((key) => { if (localStorage.getItem(key)) { localStorage.removeItem(key) removedCount++ console.log(`[v0] [Admin] Removido: ${key}`) } }) console.log(`[v0] [Admin] Limpeza concluída. ${removedCount} itens removidos.`) toast({ title: "✅ Sistema Limpo", description: `Todos os dados de simulação foram eliminados (${removedCount} itens).`, }) // Forçar recarregamento para garantir estado limpo setTimeout(() => { window.location.reload() }, 1000) } useEffect(() => { console.log("[v0] [Admin] Inicializando módulo de administração...") // Remover automaticamente qualquer dado de simulação na inicialização const simulationKeys = [ "sys_users", "admin_users", "user_profiles", "audit_logs", "mock_users", "simulation_data", "test_users", "demo_data", "sample_data", "fake_users", ] simulationKeys.forEach((key) => { if (localStorage.getItem(key)) { console.log(`[v0] [Admin] Auto-removendo dados de simulação: ${key}`) localStorage.removeItem(key) } }) console.log("[v0] [Admin] Módulo inicializado com dados zerados.") }, []) const systemMetricsDisplay = { uptime: systemMetrics.uptime, responseTime: systemMetrics.responseTime, activeUsers: systemMetrics.activeUsers, totalUsers: systemMetrics.totalUsers, diskUsage: systemMetrics.diskUsage, memoryUsage: systemMetrics.memoryUsage, cpuUsage: systemMetrics.cpuUsage, networkStatus: systemMetrics.networkStatus, lastBackup: systemMetrics.lastBackup, databaseSize: systemMetrics.databaseSize, } const resetForm = () => { setFormData({ name: "", email: "", phone: "", department: "", role: "", status: "ativo", permissions: [], notes: "", password: "", }) } const handleCreateUser = async () => { // Check capacity before creating const capacityInfo = getCapacityInfo(formData.role) if (capacityInfo.isAtCapacity) { toast({ title: "❌ Capacidade Esgotada", description: `Não é possível criar mais utilizadores ${formData.role}. Limite de ${capacityInfo.total} atingido.`, variant: "destructive", }) return } setIsSubmitting(true) try { await new Promise((resolve) => setTimeout(resolve, 1000)) const userPermissions = getRolePermissions(formData.role) const newUser = { id: Date.now().toString(), ...formData, permissions: userPermissions, // Use inherited permissions permissao_id: formData.role === "admin" ? 1 : formData.role === "supervisor" ? 2 : 3, // Map to permission level createdAt: new Date().toISOString(), } if (formData.role === "funcionario") { console.log("[v0] 🎯 CREATING FUNCIONARIO USER:") console.log("[v0] Email:", newUser.email) console.log("[v0] Permission Level: 3 (Nível 3)") console.log("[v0] Inherited Permissions:", newUser.permissions) console.log("[v0] ✓ Complete inheritance from funcionario@ozai.ao model") console.log("[v0] ✓ Total isolation: data.own_only") console.log("[v0] ✓ HR access: Férias and Ponto ONLY") console.log("[v0] ✓ Gestão de Funcionários: BLOCKED") console.log("[v0] ✓ Actions: CREATE/SUBMIT only") } const updatedUsers = [...users, newUser] setUsers(updatedUsers) localStorage.setItem("employees", JSON.stringify(updatedUsers)) toast({ title: "✅ Utilizador Criado", description: `${formData.name} foi criado com sucesso. Email: ${formData.email}${formData.role === "funcionario" ? " | Nível 3: Permissões herdadas de funcionario@ozai.ao" : ""}`, }) resetForm() setIsCreateUserOpen(false) } catch (error) { toast({ title: "❌ Erro", description: "Erro ao criar utilizador. Tente novamente.", variant: "destructive", }) } finally { setIsSubmitting(false) } } const handleEditUser = async () => { setIsSubmitting(true) try { await new Promise((resolve) => setTimeout(resolve, 1000)) const updatedUsers = users.map((u) => (u.id === selectedUser?.id ? { ...u, ...formData } : u)) setUsers(updatedUsers) localStorage.setItem("employees", JSON.stringify(updatedUsers)) toast({ title: "✅ Utilizador Atualizado", description: `${formData.name} foi atualizado com sucesso.`, }) resetForm() setIsEditUserOpen(false) setSelectedUser(null) } catch (error) { toast({ title: "❌ Erro", description: "Erro ao atualizar utilizador. Tente novamente.", variant: "destructive", }) } finally { setIsSubmitting(false) } } const openEditDialog = (user: any) => { setSelectedUser(user) setFormData({ name: user.name || "", email: user.email || "", phone: user.phone || "", department: user.department || "", role: user.role || "", status: user.status || "ativo", permissions: user.permissions || [], notes: user.notes || "", password: user.password || "", // Ensure password is included when opening edit dialog }) setIsEditUserOpen(true) } const filteredUsers = users.filter((user) => { const matchesSearch = user.name?.toLowerCase().includes(searchTerm.toLowerCase()) || user.email?.toLowerCase().includes(searchTerm.toLowerCase()) const matchesStatus = statusFilter === "all" || user.status === statusFilter const matchesRole = roleFilter === "all" || user.role === roleFilter return matchesSearch && matchesStatus && matchesRole }) const getRolePermissions = (role: string): string[] => { const roleToProfileMap: { [key: string]: string } = { admin: "admin", gerente: "supervisor", // Map gerente to supervisor profile supervisor: "supervisor", funcionario: "funcionario", } const profileId = roleToProfileMap[role] || "funcionario" // Import USER_PROFILES from global-permissions.ts const userProfiles = { admin: [ "admin.access", "admin.users", "admin.system", "admin.settings", "hr.view", "hr.manage", "hr.payroll", "hr.view_all", "orders.view", "orders.create", "orders.edit", "orders.approve", "orders.delete", "orders.view_all", "equipment.view", "equipment.create", "equipment.edit", "equipment.delete", "equipment.manage", "inventory.view", "inventory.manage", "inventory.audit", "inventory.view_all", "suppliers.view", "suppliers.create", "suppliers.edit", "suppliers.delete", "suppliers.manage", "reports.view", "reports.create", "reports.operational", "reports.financial", "reports.management", "analytics.view", "analytics.advanced", "maintenance.view", "maintenance.create", "maintenance.edit", "maintenance.manage", "maintenance.approve", "data.all", "approvals.process", ], supervisor: [ "hr.view", "orders.view", "orders.approve", "orders.view_all", "equipment.view", "equipment.edit", "inventory.view", "inventory.manage", "suppliers.view", "suppliers.edit", "reports.view", "reports.operational", "reports.management", "analytics.view", "maintenance.view", "maintenance.approve", "data.department", "approvals.process", ], funcionario: [ // Basic view permissions - ONLY view, NO edit/delete/manage "orders.view", // Can view orders "orders.create", // Can CREATE orders (submit only) "equipment.view", // Can view equipment "inventory.view", // Can view inventory "suppliers.view", // Can view suppliers "reports.view", // Can view reports "reports.operational", // Can view operational reports "maintenance.view", // Can view maintenance "maintenance.create", // Can CREATE maintenance requests (submit only) // CRITICAL: Data isolation - see ONLY own records "data.own_only", // Total isolation - see ONLY their own records // NO access to: // - hr.manage, hr.payroll, hr.view_all (blocked from employee management) // - orders.approve, orders.edit, orders.delete (no approval/editing rights) // - equipment.edit, equipment.delete, equipment.manage (no equipment management) // - inventory.manage, inventory.audit (no inventory management) // - suppliers.edit, suppliers.delete, suppliers.manage (no supplier management) // - admin.* (no admin access) // - approvals.process (no approval rights) ], } const permissions = userProfiles[profileId] || userProfiles.funcionario console.log(`[v0] 🔐 PERMISSION INHERITANCE: Role="${role}" → Profile="${profileId}"`) console.log(`[v0] 📋 Assigned ${permissions.length} permissions:`, permissions) if (profileId === "funcionario") { console.log("[v0] ⚠️ FUNCIONARIO RULES APPLIED:") console.log("[v0] ✓ Visualization: TOTAL ISOLATION (data.own_only)") console.log("[v0] ✓ HR Module: Access ONLY to Férias and Ponto") console.log("[v0] ✓ Gestão de Funcionários: BLOCKED") console.log("[v0] ✓ Actions: CREATE/SUBMIT only (NO edit/delete/approve)") } return permissions } const generateNextUserId = (role: string): string => { const timestamp = Date.now().toString(36) // Convert timestamp to base36 for shorter string const randomStr = Math.random().toString(36).substring(2, 6) // 4 random characters return `${timestamp}${randomStr}` // Unique code like "lm3k9a7f" } const generateStrongPassword = (): string => { const uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" const lowercase = "abcdefghijklmnopqrstuvwxyz" const numbers = "0123456789" const special = "@#$%&*" const allChars = uppercase + lowercase + numbers + special let password = "" // Ensure at least one of each type password += uppercase[Math.floor(Math.random() * uppercase.length)] password += lowercase[Math.floor(Math.random() * lowercase.length)] password += numbers[Math.floor(Math.random() * numbers.length)] password += special[Math.floor(Math.random() * special.length)] // Fill the rest randomly (total 12 characters) for (let i = 4; i < 12; i++) { password += allChars[Math.floor(Math.random() * allChars.length)] } // Shuffle the password to randomize position of required characters return password .split("") .sort(() => Math.random() - 0.5) .join("") } const generateCredentials = (role: string, name: string, department: string) => { // Extract first 2 letters from name (lowercase, remove spaces) const nameInitials = name.toLowerCase().replace(/\s+/g, "").substring(0, 2).padEnd(2, "x") // Pad with 'x' if name is too short // Extract first 2 letters from department (lowercase, remove spaces) const deptInitials = department.toLowerCase().replace(/\s+/g, "").substring(0, 2).padEnd(2, "x") // Pad with 'x' if department is too short // Find the next sequential number for this combination const existingUsers = users.filter((u) => { const emailPrefix = `${role}${nameInitials}${deptInitials}` return u.email?.startsWith(emailPrefix) }) const nextNumber = existingUsers.length + 1 const sequentialNumber = nextNumber.toString().padStart(2, "0") // Format as 01, 02, etc. // Generate email: [level][2name][2dept][number]@ozai.ao const email = `${role}${nameInitials}${deptInitials}${sequentialNumber}@ozai.ao` // Authentication uniqueness is guaranteed by the unique email, not the password const password = "ozai2025" return { email, password } } const getCapacityInfo = (role: string) => { const used = users.filter((u) => u.role === role).length const total = LICENSE_CAPACITY[role as keyof typeof LICENSE_CAPACITY] || 0 const available = total - used const isAtCapacity = available <= 0 return { used, total, available, isAtCapacity } } const handleRoleChange = (role: string) => { // Only generate credentials if we have name and department if (formData.name && formData.department) { const { email, password } = generateCredentials(role, formData.name, formData.department) setFormData({ ...formData, role, email, password, permissions: getRolePermissions(role), }) } else { // Just set the role without credentials setFormData({ ...formData, role, email: "", password: "", permissions: getRolePermissions(role), }) } } const handleNameOrDepartmentChange = (field: "name" | "department", value: string) => { const updatedFormData = { ...formData, [field]: value } // If we have role, name, and department, regenerate credentials if (updatedFormData.role && updatedFormData.name && updatedFormData.department) { const { email, password } = generateCredentials( updatedFormData.role, updatedFormData.name, updatedFormData.department, ) setFormData({ ...updatedFormData, email, password, }) } else { setFormData(updatedFormData) } } const copyToClipboard = (text: string) => { navigator.clipboard.writeText(text) toast({ title: "✅ Copiado", description: "Senha copiada para a área de transferência.", }) } const handlePermissionChange = (permission: string, checked: boolean) => { if (checked) { setFormData({ ...formData, permissions: [...formData.permissions, permission], }) } else { setFormData({ ...formData, permissions: formData.permissions.filter((p) => p !== permission), }) } } const getRoleBadge = (role: string) => { const roleConfig = { admin: { color: "bg-red-100 text-red-800", label: "Admin" }, gerente: { color: "bg-blue-100 text-blue-800", label: "Gerente" }, supervisor: { color: "bg-green-100 text-green-800", label: "Supervisor" }, funcionario: { color: "bg-gray-100 text-gray-800", label: "Funcionário" }, } const config = roleConfig[role as keyof typeof roleConfig] || roleConfig.funcionario return {config.label} } const createSystemBackup = async (isAutomatic = false) => { setIsBackingUp(true) try { console.log("[v0] [Backup] Iniciando backup completo do sistema...") const getAllModuleData = () => { const currentTimestamp = new Date().toISOString() // Helper function to add timestamps to records const addTimestamps = (data: any[], moduleName: string) => { return data.map((item, index) => ({ ...item, backup_timestamp: currentTimestamp, backup_module: moduleName, backup_record_id: `${moduleName}_${index + 1}`, backup_date: new Date().toLocaleDateString("pt-PT"), backup_time: new Date().toLocaleTimeString("pt-PT"), })) } return { // Dashboard Data Dashboard: addTimestamps(JSON.parse(localStorage.getItem("dashboard_data") || "[]"), "Dashboard"), // Equipamentos e Manutenção - Complete Equipment Module Equipamentos: addTimestamps(JSON.parse(localStorage.getItem("equipment") || "[]"), "Equipamentos"), Equipamentos_Alt: addTimestamps(JSON.parse(localStorage.getItem("equipamentos") || "[]"), "Equipamentos_Alt"), Manutenção: addTimestamps(JSON.parse(localStorage.getItem("maintenance") || "[]"), "Manutenção"), Manutenção_Alt: addTimestamps(JSON.parse(localStorage.getItem("manutencao") || "[]"), "Manutenção_Alt"), Equipamentos_Histórico: addTimestamps( JSON.parse(localStorage.getItem("equipment_history") || "[]"), "Equipamentos_Histórico", ), // Pedidos e Ordens de Compra - Complete Orders Module Pedidos: addTimestamps(JSON.parse(localStorage.getItem("orders") || "[]"), "Pedidos"), Pedidos_Alt: addTimestamps(JSON.parse(localStorage.getItem("pedidos") || "[]"), "Pedidos_Alt"), Ordens_Compra: addTimestamps(JSON.parse(localStorage.getItem("purchase_orders") || "[]"), "Ordens_Compra"), Ordens_Compra_Alt: addTimestamps( JSON.parse(localStorage.getItem("ordens_compra") || "[]"), "Ordens_Compra_Alt", ), Requisições: addTimestamps(JSON.parse(localStorage.getItem("requisitions") || "[]"), "Requisições"), Aprovações: addTimestamps(JSON.parse(localStorage.getItem("approvals") || "[]"), "Aprovações"), // Fornecedores - Complete Suppliers Module Fornecedores: addTimestamps(JSON.parse(localStorage.getItem("suppliers") || "[]"), "Fornecedores"), Fornecedores_Alt: addTimestamps(JSON.parse(localStorage.getItem("fornecedores") || "[]"), "Fornecedores_Alt"), Fornecedores_Contratos: addTimestamps( JSON.parse(localStorage.getItem("supplier_contracts") || "[]"), "Fornecedores_Contratos", ), Fornecedores_Avaliações: addTimestamps( JSON.parse(localStorage.getItem("supplier_evaluations") || "[]"), "Fornecedores_Avaliações", ), // Stock e Inventário - Complete Stock Module Stock: addTimestamps(JSON.parse(localStorage.getItem("stock") || "[]"), "Stock"), Stock_Alt: addTimestamps(JSON.parse(localStorage.getItem("estoque") || "[]"), "Stock_Alt"), Inventário: addTimestamps(JSON.parse(localStorage.getItem("inventory") || "[]"), "Inventário"), Stock_Movimentos: addTimestamps( JSON.parse(localStorage.getItem("stock_movements") || "[]"), "Stock_Movimentos", ), Stock_Níveis: addTimestamps(JSON.parse(localStorage.getItem("stock_levels") || "[]"), "Stock_Níveis"), // Movimentos e Transações Movimentos: addTimestamps(JSON.parse(localStorage.getItem("movements") || "[]"), "Movimentos"), Movimentos_Alt: addTimestamps(JSON.parse(localStorage.getItem("movimentos") || "[]"), "Movimentos_Alt"), Transações: addTimestamps(JSON.parse(localStorage.getItem("transactions") || "[]"), "Transações"), Transferências: addTimestamps(JSON.parse(localStorage.getItem("transfers") || "[]"), "Transferências"), // Sistema e Utilizadores - Complete System Module Utilizadores: addTimestamps(JSON.parse(localStorage.getItem("users") || "[]"), "Utilizadores"), Perfis_Utilizador: addTimestamps( JSON.parse(localStorage.getItem("user_profiles") || "[]"), "Perfis_Utilizador", ), Logs_Sistema: addTimestamps(JSON.parse(localStorage.getItem("system_logs") || "[]"), "Logs_Sistema"), Logs_Auditoria: addTimestamps(JSON.parse(localStorage.getItem("audit_logs") || "[]"), "Logs_Auditoria"), Sessões: addTimestamps(JSON.parse(localStorage.getItem("user_sessions") || "[]"), "Sessões"), // Configurações - Complete Settings Module Configurações: addTimestamps(JSON.parse(localStorage.getItem("settings") || "[]"), "Configurações"), Configurações_Sistema: addTimestamps( JSON.parse(localStorage.getItem("system_settings") || "[]"), "Configurações_Sistema", ), Configurações_Utilizador: addTimestamps( JSON.parse(localStorage.getItem("user_settings") || "[]"), "Configurações_Utilizador", ), Parâmetros: addTimestamps(JSON.parse(localStorage.getItem("parameters") || "[]"), "Parâmetros"), // Relatórios e Análises - Complete Reports Module Relatórios: addTimestamps(JSON.parse(localStorage.getItem("reports") || "[]"), "Relatórios"), Relatórios_Gerados: addTimestamps( JSON.parse(localStorage.getItem("generated_reports") || "[]"), "Relatórios_Gerados", ), Análises: addTimestamps(JSON.parse(localStorage.getItem("analytics") || "[]"), "Análises"), Estatísticas: addTimestamps(JSON.parse(localStorage.getItem("statistics") || "[]"), "Estatísticas"), // Dados Financeiros Financeiro: addTimestamps(JSON.parse(localStorage.getItem("financial") || "[]"), "Financeiro"), Orçamentos: addTimestamps(JSON.parse(localStorage.getItem("budgets") || "[]"), "Orçamentos"), Custos: addTimestamps(JSON.parse(localStorage.getItem("costs") || "[]"), "Custos"), Despesas: addTimestamps(JSON.parse(localStorage.getItem("expenses") || "[]"), "Despesas"), // Administração Administração: addTimestamps(JSON.parse(localStorage.getItem("administration") || "[]"), "Administração"), Permissões: addTimestamps(JSON.parse(localStorage.getItem("permissions") || "[]"), "Permissões"), Grupos_Acesso: addTimestamps(JSON.parse(localStorage.getItem("access_groups") || "[]"), "Grupos_Acesso"), Backup_Histórico: addTimestamps( JSON.parse(localStorage.getItem("backup_history") || "[]"), "Backup_Histórico", ), } } const moduleData = getAllModuleData() // Create workbook const workbook = XLSX.utils.book_new() const totalRecords = Object.values(moduleData).reduce((sum, data) => sum + data.length, 0) const modulesWithData = Object.entries(moduleData).filter(([_, data]) => data.length > 0) const metadata = [ ["Sistema", "Sistema Ozai - Backup Completo"], ["Arquivo", "backup_Ozai.zip"], ["Data/Hora Backup", new Date().toLocaleString("pt-PT")], ["Versão Sistema", "1.0.0"], ["Criado Por", currentUser?.name || "Sistema"], ["Tipo Backup", isAutomatic ? "Automático" : "Manual"], ["Total Registos", totalRecords], ["Módulos com Dados", modulesWithData.length], ["Total Módulos Verificados", Object.keys(moduleData).length], ["", ""], ["=== MÓDULOS DO SISTEMA ===", ""], ["Dashboard", "Dados do painel principal"], ["Equipamentos", "Equipamentos e manutenção"], ["Pedidos", "Pedidos e ordens de compra"], ["Fornecedores", "Fornecedores e contratos"], ["Stock", "Inventário e movimentos de stock"], ["Sistema", "Utilizadores e configurações"], ["Relatórios", "Relatórios e análises"], ["Administração", "Permissões e configurações"], ["", ""], ["=== ESTATÍSTICAS POR MÓDULO ===", ""], ...modulesWithData.map(([name, data]) => [name, `${data.length} registos`]), ["", ""], ["=== INFORMAÇÕES TÉCNICAS ===", ""], ["Formato", "XLSX em ZIP"], ["Nome Arquivo", "backup_Ozai.zip"], ["Codificação", "UTF-8"], ["Timestamps", "Incluídos em todos os registos"], ["Compatibilidade", "Excel 2010+"], ["Histórico", "Data/hora para análise dia-a-dia"], ] const metadataSheet = XLSX.utils.aoa_to_sheet(metadata) XLSX.utils.book_append_sheet(workbook, metadataSheet, "📋 Informações") Object.entries(moduleData).forEach(([moduleName, data]) => { if (Array.isArray(data) && data.length > 0) { // Add summary row at the top with complete module information const summaryData = [ [ `Módulo: ${moduleName}`, `Total de Registos: ${data.length}`, `Backup: ${new Date().toLocaleString("pt-PT")}`, `Dados Completos: Sim`, ], [], // Empty row for spacing ] const worksheet = XLSX.utils.json_to_sheet(data) // Add summary manually at the top XLSX.utils.sheet_add_aoa(worksheet, summaryData, { origin: "A1" }) // Ensure sheet name fits Excel limits (31 characters max) const sheetName = moduleName.length > 31 ? moduleName.substring(0, 31) : moduleName XLSX.utils.book_append_sheet(workbook, worksheet, sheetName) } }) // Generate XLSX buffer const xlsxBuffer = XLSX.write(workbook, { type: "array", bookType: "xlsx" }) const zip = new JSZip() const xlsxFilename = "Ozai.xlsx" zip.file(xlsxFilename, xlsxBuffer) const summaryText = ` BACKUP COMPLETO - SISTEMA OZAI ============================== INFORMAÇÕES DO BACKUP: - Arquivo: backup_Ozai.zip - Data/Hora: ${new Date().toLocaleString("pt-PT")} - Tipo: ${isAutomatic ? "Automático" : "Manual"} - Utilizador: ${currentUser?.name || "Sistema"} DADOS INCLUÍDOS: - Total de registos: ${totalRecords} - Módulos com dados: ${modulesWithData.length} - Módulos verificados: ${Object.keys(moduleData).length} MÓDULOS DO SISTEMA: ✓ Dashboard - Dados do painel principal ✓ Equipamentos - Equipamentos e manutenção ✓ Pedidos - Pedidos e ordens de compra ✓ Fornecedores - Fornecedores e contratos ✓ Stock - Inventário e movimentos de stock ✓ Sistema - Utilizadores e configurações ✓ Relatórios - Relatórios e análises ✓ Administração - Permissões e configurações MÓDULOS COM DADOS: ${modulesWithData.map(([name, data]) => `- ${name}: ${data.length} registos`).join("\n")} FORMATO E ESTRUTURA: - Arquivo principal: ${xlsxFilename} - Formato: Excel XLSX compactado em ZIP - Codificação: UTF-8 - Organização: Cada módulo em folha separada - Timestamps: Incluídos em todos os registos para análise histórica - Dados completos: Sem resumos, todas as informações preservadas ANÁLISE HISTÓRICA: Este backup permite análise dia-a-dia dos dados através dos timestamps incluídos em cada registo. Ideal para relatórios mensais, semanais e diários. COMPATIBILIDADE: - Excel 2010 ou superior - LibreOffice Calc - Google Sheets (após descompactação) `.trim() zip.file("LEIA-ME.txt", summaryText) const zipBlob = await zip.generateAsync({ type: "blob" }) const url = URL.createObjectURL(zipBlob) const link = document.createElement("a") link.href = url link.download = "backup_Ozai.zip" document.body.appendChild(link) link.click() document.body.removeChild(link) URL.revokeObjectURL(url) const backupTime = new Date().toLocaleString("pt-PT") updateBackupPreferences({ lastBackup: backupTime }) console.log(`[v0] [Backup] Backup completo criado: backup_Ozai.zip (${totalRecords} registos)`) toast({ title: "✅ Backup Completo Realizado", description: `Backup de ${totalRecords} registos de ${modulesWithData.length} módulos salvo como "backup_Ozai.zip". Arquivo ZIP com dados completos de todos os módulos transferido para o seu computador.`, }) } catch (error) { console.error("[v0] [Backup] Erro ao criar backup:", error) toast({ title: "❌ Erro no Backup", description: "Ocorreu um erro ao criar o backup completo. Tente novamente.", variant: "destructive", }) } finally { setIsBackingUp(false) } } const openWhatsAppSupport = () => { const phoneNumber = "933026378" const message = encodeURIComponent("Olá, preciso de suporte técnico para o Sistema Ozai.") const whatsappUrl = `https://wa.me/${phoneNumber}?text=${message}` window.open(whatsappUrl, "_blank") } return (

Painel de Administração

Gestão de utilizadores, permissões e segurança do sistema

Painel de Administração: Acesso exclusivo para Administradores (Nível 1). Gestão completa de utilizadores e configurações do sistema.

Utilizadores Ativos

{users.filter((u) => u.status === "ativo").length}

Total: {users.length}

Tempo de Atividade

Sem dados

Base de Dados

0 MB

Vazia

Último Backup

{backupPreferences.lastBackup ? "Feito" : "Nunca"}

{backupPreferences.lastBackup || "Nenhum backup"}

Gestão de Utilizadores Permissões Configurações de Backup

Gestão de Utilizadores Crie, edite e gerencie contas de utilizador do sistema. Apenas acessível para Administradores.

Controlo de Capacidade de Licenças Inventário de licenças adquiridas e disponibilidade por nível de permissão

{/* Admin Capacity */}

Administrador

Nível 1

Capacidade Total: {LICENSE_CAPACITY.admin}

Utilizadores Usados: {users.filter((u) => u.role === "admin").length}

Disponível: 0 ? "text-green-600" : "text-red-600" }`} > {getCapacityInfo("admin").available}

{getCapacityInfo("admin").isAtCapacity && ( Capacidade esgotada )}

{/* Supervisor Capacity */}

Supervisor

Nível 2

Capacidade Total: {LICENSE_CAPACITY.supervisor}

Utilizadores Usados: {users.filter((u) => u.role === "supervisor").length}

Disponível: 0 ? "text-green-600" : "text-red-600" }`} > {getCapacityInfo("supervisor").available}

{getCapacityInfo("supervisor").isAtCapacity && ( Capacidade esgotada )}

{/* Funcionário Capacity */}

Funcionário

Nível 3

Capacidade Total: {LICENSE_CAPACITY.funcionario}

Utilizadores Usados: {users.filter((u) => u.role === "funcionario").length}

Disponível: 0 ? "text-green-600" : "text-red-600" }`} > {getCapacityInfo("funcionario").available}

{getCapacityInfo("funcionario").isAtCapacity && ( Capacidade esgotada )}

Total de Utilizadores

{users.length}

Todos os níveis

Utilizadores Admin

{users.filter((u) => u.role === "admin").length}

Nível 1 - Acesso Total

Utilizadores Supervisor

{users.filter((u) => u.role === "supervisor").length}

Nível 2 - Gestão

Utilizadores Funcionário

{users.filter((u) => u.role === "funcionario").length}

Nível 3 - Operacional

setSearchTerm(e.target.value)} className="pl-10" />

Nome Email Função Departamento Estado Ações {filteredUsers.length === 0 ? ( Nenhum utilizador encontrado ) : ( filteredUsers.map((user) => ( {user.name} {user.email} {getRoleBadge(user.role)} {user.department || "-"} {user.status} )) )}

Gestão de Permissões Configure níveis de acesso e permissões por módulo do sistema.

{Object.entries(availablePermissions).map(([module, permissions]) => (

{module}

{permissions.map(({ permission, label, description }) => (

{label}

{description}

))}

Configurações de Backup Automático Configure o agendamento automático de backups do sistema. Os backups são salvos como "backup_Ozai.zip" contendo o arquivo "Ozai.xlsx" com dados organizados por módulo.

Frequência de Backup Automático updateBackupPreferences({ schedule: value as any })} >

Manual apenas - Sem agendamento automático

Diário - Backup automático uma vez por dia

Semanal - Backup automático uma vez por semana

A cada 3 dias - Backup automático a cada 3 dias

Informações do Backup

Os backups são criados como "backup_Ozai.zip" contendo o arquivo "Ozai.xlsx" com todos os dados organizados em folhas separadas por módulo. Cada backup inclui metadados com data, hora e estatísticas do sistema.

{backupPreferences.lastBackup && (

Último backup: {backupPreferences.lastBackup}

)}

{/* Edit User Dialog - existing code with minor updates */}