ff:"ExplicitChatIdProvider" 100:I[903690,["$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","$7d","$7e","$7f","$7a","$80","$81","$7b","$79","$82"],"$ff"] 101:I[838238,["$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","$7d","$7e","$7f","$7a","$80","$81","$7b","$79","$82"],"SWRDataProvider"] 104:[] 105:[["b_z1D76a1M9va",null],["b_6nsYKL264Yx",null],["b_7VUa1WqImr2",null]] 106:[["b_z1D76a1M9va",{"templateVersionId":null,"templateCanonId":null}],["b_6nsYKL264Yx",{"templateVersionId":null,"templateCanonId":null}],["b_7VUa1WqImr2",{"templateVersionId":null,"templateCanonId":null}]] 107:[["lp0GwWXLl14","$D2025-11-05T23:52:53.210Z"],["b_Ed4HzBFQpZy","$D2025-11-05T23:53:54.247Z"],["b_xEGdQPw6z9G","$D2025-11-06T22:23:56.016Z"],["b_z1D76a1M9va","$D2025-11-06T22:40:28.409Z"],["b_6nsYKL264Yx","$D2025-11-06T23:10:49.658Z"],["b_7VUa1WqImr2","$D2025-11-06T23:21:19.159Z"]] 108:[["b_z1D76a1M9va",false],["b_6nsYKL264Yx",false],["b_7VUa1WqImr2",false]] 109:[["b_z1D76a1M9va","$undefined"],["b_6nsYKL264Yx","$undefined"],["b_7VUa1WqImr2",{"git":{"ref":"main","sha":"5ca4b05a45adb06319480b45d1ddd8f8efe731f3","type":"github","repoId":0,"repoName":"v0-1-EZlSwaR400Qv6kaIyKlifAO6-h3ktc6Hy2QP","ownerName":"v0-git-s3-storage","commitMessage":"Initial commit from v0\n\nV0-Initial-Commit: v1"},"deploymentId":"dpl_5MG3R32VntS3FZbWhFyj1sd1hZVt"}]] 10a:[["b_z1D76a1M9va",null],["b_6nsYKL264Yx",null],["b_7VUa1WqImr2",null]] 10b:[["b_z1D76a1M9va",true],["b_6nsYKL264Yx",true],["b_7VUa1WqImr2",true]] 10c:[["b_z1D76a1M9va",true],["b_6nsYKL264Yx",true],["b_7VUa1WqImr2",true]] 10d:[] 10e:T4d3,O utilizador quer que implemente a lógica JavaScript para criar utilizadores no Painel de Administração (Gestão de Utilizadores) com as seguintes funcionalidades: 1. **Convenção de Nomenclatura**: Username deve ser construído automaticamente a partir: - Primeiras 2 letras do nome completo (maiúsculas) - Separador (.) - Nome completo em minúsculas sem espaços com pontos/hyphens - Exemplo: "João Silva" → "JS.joao.silva" 2. **Armazenamento no Firebase**: Guardar no Firestore com campos: - username - password - nome_completo - nivel_acesso - version_id (v1.0) - data_origem (ozai_primeira_versao) 3. **Comunicação Individual**: Botões para enviar credenciais por WhatsApp/Email com mensagem formatada 4. **Comunicação em Massa**: Enviar lista completa de utilizadores Preciso: 1. Ler os ficheiros atuais (UserForm.jsx, UserListTable.jsx) 2. Criar funções utilitárias para: - Gerar username baseado na convenção - Enviar para Firebase - Gerar mensagens de comunicação - Acionar WhatsApp e Email 3. Atualizar o formulário para usar a lógica 4. Atualizar a tabela para mostrar os botões de comunicação Vou fazer uma busca paralela dos ficheiros necessários.10f:T4d6,The user has provided a detailed specification (PRONT DE FORÇA MÁXIMA) for implementing dual credentials and zero-initialization logic without Firebase. Let me understand the requirements: 1. **Authentication Management (Backend/Server)**: - New credentials with "v1" suffix should be added to the users table - Password: ozai2025 - Server-side validation for both original and "v1" users 2. **Rigid Data Isolation (Server Logic)**: - After successful authentication, check if email contains "v1" - If yes, assign a session flag (FILTRO_VERSAO = 'V1_ZERO') - All database queries must filter data using a non-existent tag - Example: SELECT * FROM stock WHERE tag_versao = 'NAO_EXISTE_V1_DADOS' returns zero results 3. **Write Logic (New Version)**: - When v1 users create new data, tag it with a unique identifier (tag_versao = 'V1_TESTE') - Ensures test data doesn't appear to main version users I need to: 1. First explore the codebase to understand the current authentication and database query structure 2. Find where authentication happens 3. Find where database queries are made 4. Implement the dual credential system with server-side filtering Let me start by understanding the project structure.110:T2e2810,[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/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/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]/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" isQuickEdit="true" 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/admin-user-management.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 { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Badge } from "@/components/ui/badge" import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table" import { Dialog, DialogContent, DialogFooter, 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 { Alert, AlertDescription } from "@/components/ui/alert" import { Textarea } from "@/components/ui/textarea" import { Users, UserPlus, Search, Edit, UserCheck, UserX, Link2, Unlink, RefreshCw, AlertCircle, Building, Eye, EyeOff, Shield, Home, } from "lucide-react" import { useToast } from "@/hooks/use-toast" import { hrAdminIntegration } from "@/lib/hr-admin-integration" import { hrEmployeeService, type Employee as HREmployee } from "@/lib/hr-employee-service" interface User { id: string name: string email: string phone: string department: string role: string status: "ativo" | "inativo" | "suspenso" employee_id?: string lastLogin?: string createdAt: string permissions?: { modules: string[] actions: string[] level: string } } interface Employee { id: string name: string email: string department: string position: string status: string } interface IntegrationStats { totalEmployees: number employeesWithUser: number employeesWithoutUser: number totalUsers: number usersWithEmployee: number usersWithoutEmployee: number } export function AdminUserManagement() { const [users, setUsers] = useState([]) const [employees, setEmployees] = useState([]) const [employeesWithoutUser, setEmployeesWithoutUser] = useState([]) const [integrationStats, setIntegrationStats] = useState(null) const [searchTerm, setSearchTerm] = useState("") const [statusFilter, setStatusFilter] = useState("all") const [roleFilter, setRoleFilter] = useState("all") const [selectedEmployees, setSelectedEmployees] = useState([]) const [isLoading, setIsLoading] = useState(false) const [isBulkCreateOpen, setIsBulkCreateOpen] = useState(false) const [isIntegrationStatsOpen, setIsIntegrationStatsOpen] = useState(false) const [isNewUserDialogOpen, setIsNewUserDialogOpen] = useState(false) const [isEditUserDialogOpen, setIsEditUserDialogOpen] = useState(false) const [isPermissionsDialogOpen, setIsPermissionsDialogOpen] = useState(false) const [selectedUser, setSelectedUser] = useState(null) const [showPassword, setShowPassword] = useState(false) const [employeeSearchTerm, setEmployeeSearchTerm] = useState("") const [allEmployees, setAllEmployees] = useState([]) const [selectedPermissions, setSelectedPermissions] = useState({ modules: [] as string[], actions: [] as string[], level: "funcionario" as string, }) const [newUserForm, setNewUserForm] = useState({ name: "", email: "", phone: "", department: "", role: "funcionario", status: "ativo" as "ativo" | "inativo" | "suspenso", employee_id: "", username: "", password: "", confirmPassword: "", notes: "", }) const [editingUser, setEditingUser] = useState(null) const { toast } = useToast() useEffect(() => { loadIntegrationData() loadAllEmployees() loadUsersFromLocalStorage() }, []) const loadUsersFromLocalStorage = () => { try { const storedUsers = localStorage.getItem("sys_users_db") if (storedUsers) { const parsedUsers = JSON.parse(storedUsers) setUsers(parsedUsers) console.log("[v0] [Admin-User-Management] ✅ Usuários carregados do sys_users_db:", parsedUsers.length) } else { console.log("[v0] [Admin-User-Management] Nenhum usuário encontrado no sys_users_db") setUsers([]) } } catch (error) { console.error("[v0] [Admin-User-Management] ❌ Erro ao carregar usuários do localStorage:", error) setUsers([]) } } const loadIntegrationData = async () => { setIsLoading(true) try { console.log("[v0] [Admin-User-Management] Carregando dados de integração...") const stats = await hrAdminIntegration.getIntegrationStats() console.log("[v0] [Admin-User-Management] Estatísticas carregadas:", stats) setIntegrationStats(stats) const employeesWithoutUserData = await hrAdminIntegration.getEmployeesWithoutUser() console.log("[v0] [Admin-User-Management] Funcionários sem usuário:", employeesWithoutUserData.length) setEmployeesWithoutUser(employeesWithoutUserData) // const usersWithEmployeeData = await hrAdminIntegration.getUsersWithEmployee() // console.log("[v0] [Admin-User-Management] Usuários com funcionário:", usersWithEmployeeData.length) // setUsers(usersWithEmployeeData.map((item) => item.user)) console.log("[v0] [Admin-User-Management] ✅ Dados de integração carregados com sucesso") } catch (error) { console.error("[v0] [Admin-User-Management] ❌ Erro ao carregar dados:", error) toast({ title: "Erro de Integração", description: "Erro ao carregar dados de integração RH-Admin", variant: "destructive", }) } finally { setIsLoading(false) } } const loadAllEmployees = async () => { try { console.log("[v0] [Admin-User-Management] Carregando funcionários do localStorage...") await hrEmployeeService.loadEmployees() const hrEmployees = hrEmployeeService.getActiveEmployees() if (!Array.isArray(hrEmployees)) { console.log("[v0] [Admin-User-Management] hrEmployees não é array, usando array vazio") setAllEmployees([]) return } // Convert HR employees to the format expected by this component const convertedEmployees: Employee[] = hrEmployees.map((hrEmp: HREmployee) => ({ id: hrEmp.id, name: hrEmp.full_name, email: hrEmp.email || "", department: hrEmp.department, position: hrEmp.position, status: hrEmp.status, })) setAllEmployees(convertedEmployees) console.log("[v0] [Admin-User-Management] ✅ Funcionários carregados do localStorage:", convertedEmployees.length) // Subscribe to employee changes for real-time updates hrEmployeeService.subscribe((updatedEmployees) => { if (!Array.isArray(updatedEmployees)) { console.log("[v0] [Admin-User-Management] updatedEmployees não é array na subscription") return } const convertedUpdated: Employee[] = updatedEmployees .filter((emp) => emp.status === "ativo") .map((hrEmp: HREmployee) => ({ id: hrEmp.id, name: hrEmp.full_name, email: hrEmp.email || "", department: hrEmp.department, position: hrEmp.position, status: hrEmp.status, })) setAllEmployees(convertedUpdated) console.log( "[v0] [Admin-User-Management] 🔄 Funcionários atualizados via subscription:", convertedUpdated.length, ) }) } catch (error) { console.error("[v0] [Admin-User-Management] ❌ Erro ao carregar funcionários:", error) setAllEmployees([]) toast({ title: "Erro ao Carregar Funcionários", description: "Não foi possível carregar a lista de funcionários do sistema", variant: "destructive", }) } } const handleBulkCreateUsers = async () => { if (selectedEmployees.length === 0) { toast({ title: "Seleção Necessária", description: "Selecione pelo menos um funcionário para criar usuários", variant: "destructive", }) return } setIsLoading(true) try { const result = await hrAdminIntegration.createBulkUsersFromEmployees(selectedEmployees, "funcionario") toast({ title: "Criação em Lote Concluída", description: `${result.summary.successful} usuários criados com sucesso de ${result.summary.total} tentativas`, }) // Refresh data await loadIntegrationData() setSelectedEmployees([]) setIsBulkCreateOpen(false) } catch (error) { toast({ title: "Erro na Criação em Lote", description: "Erro ao criar usuários em lote", variant: "destructive", }) } finally { setIsLoading(false) } } const handleCreateUserFromEmployee = async (employeeId: string, accessLevel: string) => { setIsLoading(true) try { console.log("[v0] [Admin-User-Management] Criando usuário:", { employeeId, accessLevel }) const result = await hrAdminIntegration.createUserFromEmployee(employeeId, accessLevel as any) console.log("[v0] [Admin-User-Management] Resultado da criação:", result) if (result.success) { toast({ title: "✅ Usuário Criado", description: result.message, }) await loadIntegrationData() } else { console.error("[v0] [Admin-User-Management] Falha na criação:", result.message) toast({ title: "❌ Erro na Criação", description: result.message, variant: "destructive", }) } } catch (error) { console.error("[v0] [Admin-User-Management] Erro crítico:", error) toast({ title: "❌ Erro Crítico", description: "Erro interno ao criar usuário", variant: "destructive", }) } finally { setIsLoading(false) } } const handleSyncUserWithEmployee = async (userId: string, employeeId: string) => { setIsLoading(true) try { const result = await hrAdminIntegration.syncEmployeeToUser(employeeId) if (result.success) { toast({ title: "Sincronização Concluída", description: result.message, }) await loadIntegrationData() } else { toast({ title: "Erro na Sincronização", description: result.message, variant: "destructive", }) } } catch (error) { toast({ title: "Erro", description: "Erro ao sincronizar dados", variant: "destructive", }) } finally { setIsLoading(false) } } const handleEmployeeSelect = (employeeId: string) => { console.log("[v0] [Admin-User-Management] Funcionário selecionado:", employeeId) const selectedEmployee = allEmployees.find((emp) => emp.id === employeeId) if (selectedEmployee) { console.log("[v0] [Admin-User-Management] Preenchendo dados do funcionário:", selectedEmployee) // Verificar se já existe utilizador para este funcionário const existingUser = users.find((user) => user.employee_id === selectedEmployee.id) if (existingUser) { toast({ title: "⚠️ Funcionário já tem utilizador", description: `${selectedEmployee.name} já possui um utilizador no sistema`, variant: "destructive", }) return } // Gerar username único const baseUsername = selectedEmployee.email.split("@")[0].toLowerCase() let username = baseUsername let counter = 1 while (users.some((user) => user.username === username)) { username = `${baseUsername}${counter}` counter++ } setNewUserForm((prev) => ({ ...prev, employee_id: selectedEmployee.id, name: selectedEmployee.name, email: selectedEmployee.email, phone: selectedEmployee.phone || "", department: selectedEmployee.department, username: username, role: mapPositionToRole(selectedEmployee.position), password: generateRandomPassword(), confirmPassword: "", })) setEmployeeSearchTerm(selectedEmployee.name) toast({ title: "✅ Funcionário Selecionado", description: `Dados de ${selectedEmployee.name} preenchidos automaticamente. Password gerada automaticamente.`, }) } } const mapPositionToRole = (position: string): string => { const positionLower = position.toLowerCase() if (positionLower.includes("gerente") || positionLower.includes("diretor")) return "gerente" if (positionLower.includes("supervisor") || positionLower.includes("coordenador")) return "supervisor" if (positionLower.includes("admin")) return "admin" return "funcionario" } const generateRandomPassword = () => { const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%" let password = "" for (let i = 0; i < 12; i++) { password += chars.charAt(Math.floor(Math.random() * chars.length)) } return password } const validateUserForm = () => { const errors: string[] = [] if (!newUserForm.name.trim()) errors.push("Nome é obrigatório") if (!newUserForm.email.trim()) errors.push("Email é obrigatório") if (!newUserForm.username.trim()) errors.push("Nome de utilizador é obrigatório") if (!newUserForm.password.trim()) errors.push("Password é obrigatória") if (newUserForm.password !== newUserForm.confirmPassword) errors.push("Passwords não coincidem") // Validar formato do email const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/ if (newUserForm.email && !emailRegex.test(newUserForm.email)) { errors.push("Formato de email inválido") } // Validar força da password if (newUserForm.password.length < 8) { errors.push("Password deve ter pelo menos 8 caracteres") } // Verificar se username já existe if (users.some((user) => user.username === newUserForm.username && user.id !== editingUser?.id)) { errors.push("Nome de utilizador já existe") } // Verificar se email já existe if (users.some((user) => user.email === newUserForm.email && user.id !== editingUser?.id)) { errors.push("Email já está em uso") } return errors } const handleProceedToPermissions = () => { console.log("[v0] [Admin-User-Management] Validando formulário antes das permissões") // Validar formulário primeiro const validationErrors = validateUserForm() if (validationErrors.length > 0) { toast({ title: "❌ Erro de Validação", description: validationErrors.join(", "), variant: "destructive", }) return } // Definir permissões padrão baseadas no role const defaultPermissions = { funcionario: { modules: ["rh", "ponto"], actions: ["read"], level: "funcionario", }, supervisor: { modules: ["rh", "ponto", "relatorios"], actions: ["read", "create", "update"], level: "supervisor", }, gerente: { modules: ["rh", "ponto", "relatorios", "admin"], actions: ["read", "create", "update", "delete"], level: "gerente", }, admin: { modules: ["rh", "ponto", "relatorios", "admin", "sistema"], actions: ["read", "create", "update", "delete", "manage"], level: "admin", }, } const rolePermissions = defaultPermissions[newUserForm.role as keyof typeof defaultPermissions] || defaultPermissions.funcionario setSelectedPermissions(rolePermissions) setIsPermissionsDialogOpen(true) } const handleSaveUserWithPermissions = async () => { console.log("[v0] [Admin-User-Management] Salvando utilizador com permissões") console.log("[v0] [Admin-User-Management] Permissões selecionadas:", selectedPermissions) try { const userData = { id: editingUser?.id || `user_${Date.now()}`, name: newUserForm.name.trim(), email: newUserForm.email.trim().toLowerCase(), phone: newUserForm.phone.trim(), department: newUserForm.department.trim(), role: newUserForm.role, status: newUserForm.status, employee_id: newUserForm.employee_id || undefined, username: newUserForm.username.trim().toLowerCase(), permissions: selectedPermissions, lastLogin: editingUser?.lastLogin || undefined, createdAt: editingUser?.createdAt || new Date().toISOString(), } console.log("[v0] [Admin-User-Management] Dados completos do utilizador:", userData) if (editingUser) { setUsers((prev) => prev.map((user) => (user.id === editingUser.id ? userData : user))) toast({ title: "✅ Utilizador Atualizado", description: `${userData.name} foi atualizado com permissões definidas`, }) } else { setUsers((prev) => [...prev, userData]) toast({ title: "✅ Utilizador Criado", description: `${userData.name} foi criado com permissões definidas`, }) } const updatedUsers = editingUser ? users.map((user) => (user.id === editingUser.id ? userData : user)) : [...users, userData] localStorage.setItem("sys_users_db", JSON.stringify(updatedUsers)) console.log("[v0] [Admin-User-Management] ✅ Usuários salvos no sys_users_db:", updatedUsers.length) // Reset forms setNewUserForm({ name: "", email: "", phone: "", department: "", role: "funcionario", status: "ativo", employee_id: "", username: "", password: "", confirmPassword: "", notes: "", }) setSelectedPermissions({ modules: [], actions: [], level: "funcionario", }) setEmployeeSearchTerm("") setIsNewUserDialogOpen(false) setIsPermissionsDialogOpen(false) setEditingUser(null) } catch (error) { console.error("[v0] [Admin-User-Management] Erro ao salvar utilizador:", error) toast({ title: "❌ Erro ao Salvar", description: "Erro interno do sistema. Tente novamente.", variant: "destructive", }) } } 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 filteredEmployeesForSelection = (allEmployees || []).filter( (emp) => emp.name.toLowerCase().includes(employeeSearchTerm.toLowerCase()) || emp.email.toLowerCase().includes(employeeSearchTerm.toLowerCase()) || emp.department.toLowerCase().includes(employeeSearchTerm.toLowerCase()), ) const getStatusBadge = (status: string) => { const configs = { ativo: { color: "bg-green-100 text-green-800", label: "Ativo" }, inativo: { color: "bg-gray-100 text-gray-800", label: "Inativo" }, suspenso: { color: "bg-red-100 text-red-800", label: "Suspenso" }, } const config = configs[status as keyof typeof configs] || configs.inativo return {config.label} } const getRoleBadge = (role: string) => { const configs = { 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 = configs[role as keyof typeof configs] || configs.funcionario return {config.label} } return (

Gestão de Usuários com Integração RH

Gerencie usuários do sistema com sincronização automática de dados do RH

Usuários Ativos Integração RH Criação em Lote

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

Usuário Função Departamento Status Integração RH Ações {filteredUsers.map((user) => (

{user.name .split(" ") .map((n) => n[0]) .join("") .substring(0, 2)}

{user.name}

{user.email}

{getRoleBadge(user.role)}

{user.department}

{getStatusBadge(user.status)} {user.employee_id ? (

Vinculado

) : (

Sem vínculo

)}

{user.employee_id && ( )}

))}

Funcionários sem Usuário

{integrationStats?.employeesWithoutUser || 0}

de {integrationStats?.totalEmployees || 0} funcionários

Usuários Vinculados

{integrationStats?.usersWithEmployee || 0}

de {integrationStats?.totalUsers || 0} usuários

Taxa de Integração

{integrationStats ? Math.round((integrationStats.employeesWithUser / integrationStats.totalEmployees) * 100) : 0} %

funcionários com acesso

Funcionários Disponíveis para Criação de Usuário Funcionários ativos que ainda não possuem conta de usuário no sistema Nome Email Departamento Cargo Ações {employeesWithoutUser.map((employee) => ( {employee.name} {employee.email} {employee.department} {employee.position} ))}

Criação de Usuários em Lote Selecione múltiplos funcionários para criar contas de usuário simultaneamente

{selectedEmployees.length} funcionário(s) selecionado(s)

{ if (checked) { setSelectedEmployees(employeesWithoutUser.map((e) => e.id)) } else { setSelectedEmployees([]) } }} /> Nome Departamento Cargo Email {employeesWithoutUser.map((employee) => ( { if (checked) { setSelectedEmployees([...selectedEmployees, employee.id]) } else { setSelectedEmployees(selectedEmployees.filter((id) => id !== employee.id)) } }} /> {employee.name} {employee.department} {employee.position} {employee.email} ))}

{selectedEmployees.length > 0 && ( Todos os usuários serão criados com nível de acesso "Funcionário" por padrão. Você pode alterar as permissões individualmente após a criação. )} {/* Integration Statistics Dialog */} {/* New User Dialog */}