Seu marketplace de confiança para encontrar e agendar os melhores profissionais de limpeza da sua região!
O projeto LimpeJá é construído sobre pilares tecnológicos e de arquitetura que garantem sua robustez, escalabilidade e modernidade, alinhando-se às melhores práticas do mercado.
- 📖 Sobre o Projeto
- ✨ Funcionalidades Principais
- 🛠️ Tecnologias Principais
- 🔩 Arquitetura do Sistema
- 🔗 Conexão Frontend-Backend
- 📁 Estrutura do Projeto
- 🚀 Começando
- 📱 Gerando um APK para Teste (Android)
- 🤝 Contribuindo
- 📜 Licença
- 📞 Contato
- 💰 LimpeJá Ganhos: Nossa Estratégia de Monetização
- ✅ Status e Próximas Etapas
- 📚 Recursos e Suporte
O LimpeJá é um mercado inovador que visa revolucionar a forma como serviços de limpeza e organização são contratados e gerenciados. Ele conecta clientes que buscam serviços de alta qualidade para profissionais independentes e empresas especializadas, oferecendo uma plataforma intuitiva para descobrir profissionais envolvidos, verificar avaliações, agendar serviços com dados e horários flexíveis, e realizar pagamentos seguros.
Para os profissionais de limpeza, o LimpeJá é uma ferramenta poderosa para expandir sua clientela, gerenciando sua agenda de forma autônoma e recebendo pagamentos de forma garantida e simplificada. Construído com tecnologia de ponta, o aplicativo oferece uma experiência de usuário fluida e moderna, tanto para quem busca um ambiente limpo quanto para quem oferece o serviço de limpeza. O setor de limpeza no Brasil está se consolidando como uma indústria estratégica e essencial, com a valorização da higiene intensificada após a pandemia de COVID-19, o que representa uma oportunidade estrutural para o LimpeJá.
- 🧼 Busca Inteligente: Encontre profissionais por especialidade, localização e avaliações.
- 📅 Agendamento Flexível: Escolha dados e horários que se encaixam na sua rotina e gerencie seus agendamentos.
- 💳 Pagamento Seguro (incluindo PIX): Transações protegidas dentro da plataforma, com suporte a geração de cobranças PIX e processamento de webhooks para atualização de status de pagamento.
- ⭐ Avaliações Confiáveis: Deixe e veja avaliações para ajudar a comunidade e garantir a qualidade do serviço.
- 💬 Comunicação Direta (Chat em Tempo Real): Chat em tempo real integrado para combinar detalhes com o profissional, com persistência de conversas e notificações instantâneas.
- 🏠 Perfis Detalhados: Visualize informações completas sobre os profissionais, incluindo serviços oferecidos e status de verificação.
- 🔔 Notificações em Tempo Real: Receba alertas instantâneos sobre o status dos agendamentos, mensagens e promoções via notificações push.
- ⚙️ Gerenciamento de Perfil: Atualize suas informações pessoais e de contato.
- 🚀 Visibilidade Ampliada: Alcance mais clientes e aumente sua renda através de um perfil profissional detalhado.
- 🗓️ Gestão de Agenda: Controle total sobre seus horários e disponibilidade, aceitando ou recusando agendamentos.
- 💰 Pagamentos Garantidos e Saques: Receba de forma segura e pontual pelos seus serviços, com visualizações de ganhos, solicitação de saques e atomicidade garantida nas transações.
- 📊 Perfil Profissional Detalhado: Mostre suas habilidades, experiência, portfólio de serviços e avaliações recebidas.
- 🔔 Notificações em Tempo Real: Sobre novos pedidos, mensagens e atualizações de agendamento via notificações push.
- ✅ Processo de Verificação Robusto: Passe por um processo de verificação de conta (CPF, documento com OCR, selfie com comparação facial e prova de vida, verificação de antecedentes em APIs reais) para aumentar a confiança dos clientes.
- 🛠️ Gerenciamento de Serviços: Adicione, edite e remova os tipos de serviços que você oferece, definindo preços e durações.
- 💬 Chat em Tempo Real: Comunique-se diretamente com seus clientes para esclarecer dúvidas e combinar detalhes, com persistência de conversas.
O projeto LimpeJá é construído sobre uma pilha tecnológica robusta e moderna, garantindo eficiência e escalabilidade em todas as camadas.
- Framework UI: React Native - Para construção de interfaces de usuário nativo para iOS e Android a partir de uma única base de código, com foco em desempenho e experiência do usuário.
- Navegação: Expo Router - Sistema de roteamento baseado em arquivos para aplicativos Expo e React Native, oferecendo navegação robusta, tipada e com suporte a deep linking.
- Gerenciamento de Estado Global: React Context API - Para gerenciar estados compartilhados, como o contexto de autenticação (`AuthContext`), de forma eficiente, evitando 'perfuração de prop' e centralizando dados.
- Tipagem: TypeScript - Essencial para a segurança e consistência dos dados, especialmente na integração com o backend e para escalabilidade do desenvolvimento.
- Estilização: StyleSheet do React Native, com temas sonoros (claro/escuro) gerenciados via `Colors.ts` e `theme.ts` para consistência visual.
- Animações: React Native Animated API para transições suaves e `react-native-reanimated` para animações complexas e performáticas, incluindo efeitos visuais com `expo-linear-gradient` e `expo-blur`.
- Ícones: `@expo/vector-icons` e `react-native-svg` para ícones personalizados e animados.
- Utilitários Expo: `expo-image-picker`, `expo-clipboard`, `react-native-safe-area-context`, `expo-haptics` (para feedback tátil).
- Requisições HTTP: Axios - Para chamadas HTTP à API backend, configuradas com interceptores para tratamento de autenticação e erros.
- Serviços Expo: EAS (Expo Application Services) - Para um fluxo de desenvolvimento gerenciado, builds e atualizações. Inclui:
- `EAS Build`: Para compilação de APKs/AABs e IPAs na nuvem.
- `EAS Submit`: Para envio para as lojas (futuramente).
- `EAS Update`: Para atualizações over-the-air (futuramente).
- Autenticação por Telefone (Firebase): Implementação de login e registro via número de telefone com OTP (One-Time Password) utilizando o Firebase Authentication, garantindo um fluxo de autenticação seguro e eficiente para dispositivos móveis.
- Notificações Push (Firebase Cloud Messaging): Integração com o Firebase Cloud Messaging para envio e recebimento de notificações push em tempo real, mantendo os usuários informados sobre agendamentos, mensagens de chat e atualizações importantes.
- Framework: NestJS (Node.js) - Escolha estratégica por sua modularidade, forte tipagem (TypeScript), aderência a padrões de arquitetura (DDD, MVC-like) e um ecossistema robusto para construir APIs escaláveis e manuteníveis.
- Linguagem: TypeScript - Oferece segurança de tipo em todas as camadas, desde os DTOs até a interação com o banco de dados via ORM, melhorando a manutenibilidade e reduzindo erros no tempo de execução.
- Banco de Dados: PostgreSQL - Um sistema de dados relacionado a banco robusto, bastante e escalável, ideal para dados estruturados e relações complexas.
- ORM: Prisma - ORM moderno e type-safe que simplifica a interação com o banco de dados, oferece migrações declarativas e garantir a segurança de tipo nas operações de persistência.
- Autenticação: JWT (JSON Web Tokens) com Passport.js - Para autenticação stateless e segura, permitindo controle de acesso baseado em papéis (RBAC) e protegendo rotas sensíveis.
- Comunicação em Tempo Real: Socket.IO - Para comunicação bidirecional em tempo real, fundamental para funcionalidades como chat e notificações instantâneas.
- Validação: Class-validator e Class-transformer - Para validação declarativa de DTOs, garantindo que os dados de entrada da API estejam sempre no formato e com os valores esperados.
- API de documentação: Swagger (OpenAPI) - Para documentação automática e interativa da API, facilitando o consumo por desenvolvedores de frontend e a utilização da API.
- Variáveis de Ambiente: `@nestjs/config` com Joi - Para gerenciamento seguro e validação rigorosas das configurações de ambiente, garantindo a integridade da aplicação.
- Verificação de Provedores (APIs Reais): Implementação robusta do processo de verificação de provedores, incluindo integração com Google Cloud Vision API para OCR (reconhecimento de documentos), comparação facial, e APIs de terceiros para verificação de antecedentes criminais.
- Gateway de Pagamento PIX (Integração Real): Integração com um gateway de pagamento PIX real (ex: PagSeguro, Stripe, etc.) para processar transações, gerenciar webhooks e garantir a atomicidade das operações financeiras.
- Notificações Push (FCM): Suporte a notificações push via Firebase Cloud Messaging (FCM) para enviar alertas e atualizações em tempo real aos usuários.
- Busca Geoespacial Avançada: Implementação de lógica geoespacial (`PostGIS` com `Prisma.$queryRaw`) para busca de provedores por proximidade, utilizando coordenadas de latitude/longitude.
- Consistência Monetária (Prisma Decimal): Uso do tipo `Decimal` do Prisma para garantir precisão exata em todos os cálculos e armazenamento de valores monetários.
- Gerenciamento de Ganhos e Saques: Funcionalidades completas para provedores visualizarem seus ganhos, solicitarem saques e garantir a atomicidade das transações financeiras.
O projeto LimpeJá adota uma arquitetura em camadas claras, divididas principalmente entre o Backend (API) e o Frontend (Aplicativo Móvel), que se comunicam através de APIs RESTful e WebSockets.
O backend do LimpeJá é uma camada de serviço que gerencia toda a lógica de negócios, persistência de dados e a comunicação com o frontend. Construído com NestJS, o backend é responsável por conectar clientes e provedores, facilitando agendamentos, pagamentos, chat e avaliações. Sua arquitetura modular e escalável garante robustez e alto desempenho.
O fluxo de uma requisição típica no sistema LimpeJá segue o seguinte caminho:
- Cliente (Usuário): Interage com a interface do usuário no Frontend (Aplicativo Móvel).
- Frontend (Aplicativo Móvel): Coleta e valida os dados de entrada do usuário, realiza chamadas a serviços internos, formato de requisição (HTTP ou WebSocket) e envio para o Backend, incluindo o token JWT no cabeçalho `Authorization` para requisições protegidas.
- Backend (API NestJS):
- Guardas: Interceptam uma requisição para validação de autenticação (JWT) e autorização (papéis do usuário).
- Pipes: Validam e transformam os DTOs de entrada.
- Controlador: Recebe uma requisição validada, extrai parâmetros e delega a lógica de negócios para o Serviço de segurança.
- Serviço: Contém a lógica de negócios principais, orquestrando operações e interagindo com o `PrismaService`. Pode injetar outros serviços para operações complexas.
- PrismaService: Atua como uma camada de acesso a dados, executando operações no Banco de Dados.
- Banco de Dados (PostgreSQL): Persiste e recupera os dados.
- Resposta: O Service retorna os dados ao Controller, que os formato (geralmente usando DTOs de resposta) e os envio de volta ao Frontend.
- Filtros: Capturam abordagens HTTP, formatando as respostas de erro de forma consistente.
- Frontend (Aplicativo Móvel): Recebe uma resposta do Backend, processa os dados e atualiza a interface do usuário, exibindo informações ou mensagens de erro ao Cliente.
O backend é organizado em módulos coesos, seguindo o princípio de responsabilidade única. Cada módulo encapsula funcionalidades específicas, incluindo seus próprios controladores, serviços, DTOs e entidades.
- `src/auth`: Gerenciamento de autenticação (registro, login, redefinição de senha, **incluindo autenticação por telefone e verificação de OTP via Firebase Admin SDK**).
- `src/users`: Operações genéricas sobre usuários (perfis, dados básicos).
- `src/clients`: Lógica específica para o papel do cliente.
- `src/providers`: Lógica específica para o papel de provedor.
- `src/availability`: Gestão da disponibilidade de horários dos provedores.
- `src/services`: Gerenciamento de tipos de serviços globais (por exemplo, "Limpeza Padrão").
- `src/provider-services`: Gerenciamento dos serviços específicos oferecidos por cada provedor.
- `src/bookings`: Criação e gestão de agendamentos.
- `src/payments`: Processamento de pagamentos (**PIX real** e saques) e integração com webhooks de gateways de pagamento.
- `src/chat`: Funcionalidades de chat (**REST e WebSocket com persistência de conversas**).
- `src/notifications`: Gerenciamento de notificações para usuários (**suporte a notificações push via FCM**).
- `src/reviews`: Envio e consulta de avaliações.
- `src/offers`: Gerenciamento de ofertas e promoções.
- `src/search`: Motor de busca abrangente (**incluindo busca geoespacial de provedores**).
- `src/verification`: Processo de verificação de provedores (**CPF, documentos com OCR, selfie com comparação facial e prova de vida, verificação de antecedentes em APIs reais**).
- `src/prisma`: Módulo global para o `PrismaService`.
- `src/config`: Módulo global para gerenciamento de configurações.
- `src/common`: Componentes reutilizáveis (pipes, filtros de exceção, DTOs genéricos, enums).
O prisma/schema.prisma define o modelo de dados relacional e é a fonte da verdade para a estrutura do banco de dados. Ele inclui:
- Enums: `UserRole` (CLIENTE, PROVEDOR, ADMIN, SISTEMA), `VerificationStatus` (REVISÃO_INICIAL_PENDENTE, APROVADO, REJEITADO, etc.), `BookingStatus` (PENDENTE, CONFIRMADO, CONCLUÍDO, CANCELADO, etc.), `TransactionType` (PAGAMENTO, SAQUE, COMISSÃO).
- Modelos Principais (Tabelas):
- `User`: Entidade base para todos os usuários, com `email`, `passwordHash`, `role` e `avatarUrl`.
- `Cliente`: Detalhes específicos para clientes (`fullName`, `phone`).
- `Provider`: Detalhes específicos para provedores (`fullName`, `cpf`, `dateOfBirth`, `verificationStatus`, `pixKey`). **Inclui campos para armazenamento de URLs de documentos e resultados de verificação.**
- `Endereço`: Informações de endereço, usadas por clientes, provedores e agendamentos. **Suporta dados geoespaciais (`location`) para busca por proximidade.**
- `Serviço`: Tipos de serviços que podem ser oferecidos (`nome`, `preço`, `icon`).
- `ProviderService`: Um serviço específico oferecido por uma operadora, com `price` e `durationMinutes`.
- `Booking`: Representa um agendamento de serviço, incluindo `totalPrice` e um `addressId` específico para o agendamento. **Status de agendamento expandidos para maior granularidade.**
- `Chat` e `Message`: Para comunicação em tempo real entre usuários. **Com persistência de mensagens.**
- `Notificação`: Armazena notificações para usuários.
- `Review`: Avaliações de serviços, vinculadas a um `Booking`.
- `Oferta`: Gerencia ofertas e promoções.
- `Transaction`: Registra todas as transações financeiras, utilizando `Prisma.Decimal` para garantir a rentabilidade monetária. **Inclui `bookingId` para rastreamento de transações de agendamento.**
- `Disponibilidade`: Define a disponibilidade de horários dos provedores.
- Precisão Monetária: O uso do tipo `Decimal` do Prisma (`@db.Decimal(10, 2)`) para campos como `price`, `totalPrice` e `amount` garante precisão exata em cálculos financeiros, evitando erros de arredondamento.
O projeto LimpeJá segue princípios de design e padrões de projeto que promovem qualidade, manutenibilidade e escalabilidade em todo o stack.
- Arquitetura em Camadas: Tanto o frontend quanto o backend seguem uma arquitetura em camadas claras (Controladores/Telas, Serviços/Lógica de Negócios, Acesso a Dados), promovendo a separação de preocupações.
- Data Transfer Objects (DTOs): Utilização rigorosa de DTOs para validação de entrada (com `class-validator` e `class-transformer`) e tipagem de saída em todas as interações API, garantindo a integridade e segurança dos dados.
- Autenticação e Autorização: Implementação robusta de JWT e RBAC (Role-Based Access Control) para proteger rotas e recursos, com `Guards` e `Strategies` no NestJS.
- Tratamento Centralizado de Erros: O `HttpExceptionFilter` do backend padroniza as respostas de erro, permitindo que o frontend interprete e exiba mensagens significativas ao usuário via `Alert.alert` ou `ToastMessage`.
- Modularidade: Módulos de dados no backend (NestJS) e componentes reutilizáveis no frontend (React Native) garantem organização, testabilidade e reutilização de código.
- Segurança de Tipos (Type-Safety): O uso extensivo de TypeScript em ambas as camadas, complementado pelo Prisma ORM no backend, garante a consistência e integridade dos dados em tempo de construção e execução.
- Injeção de Dependência: Sem backend (NestJS), facilita a testabilidade e modularidade dos serviços, seguindo os princípios SOLID.
- Componentização (Frontend): Divisão da UI em componentes pequenos e reutilizáveis (`components/ui/`), promovendo reutilização e manutenibilidade.
- Gerenciamento de Estado: Combinação de Hooks do React (`useState`, `useEffect`, `useRef`) para estado local e Context API (`AuthContext`, `AppContext`, `ProviderRegistrationContext`) para estado global no frontend.
- Navegação Declarativa: Uso do Expo Router para uma gestão de rotas intuitiva e baseada em arquivos, com layouts aninhados.
- Animações e Responsividade: Aplicação de animações fluidas (`react-native-reanimated`, React Native Animated API) e design responsivo para aprimorar a experiência do usuário em diferentes dispositivos, com `useNativeDriver: true` para otimização.
- Gerenciamento de Dados e Fluxo de Informações: O frontend segue o padrão Unidirecional do React, com dados fluindo de contextos globais e estado local, e interações com o backend via camada de serviços tipada (`services/`).
- Separação de Entidades e DTOs (Backend): Entidades (`*.entity.ts`) para o modelo de domínio e DTOs (`*.dto.ts`) para validação/formatação de API, melhorando segurança e validação.
- Consistência na Manipulação de Dados: Uso cuidadoso de objetos Date e UTC para evitar problemas de fuso horário, especialmente em agendamentos e disponibilidade.
- Hooks de Desligamento do Prisma: Garantem o fechamento gracioso da conexão com o banco de dados em caso de encerramento da aplicação.
A interligação entre o Frontend (React Native/Expo) e o Backend (NestJS) do projeto LimpeJá é um pilar fundamental da arquitetura, garantindo uma comunicação eficiente e segura.
- Padrão de Comunicação: Predominantemente APIs RESTful (HTTP) para operações transacionais e de consulta, e WebSockets para funcionalidades de comunicação em tempo real (chat, notificações).
- Autenticação JWT: O `AuthContext` no frontend gerencia o ciclo de vida do token JWT, obtido via `POST /auth/login`. Este token é armazenado de forma segura no AsyncStorage e anexado automaticamente como `Authorization: Bearer ` em todas as requisições protegidas ao backend.
- Consistência de Dados (DTOs e Interfaces TypeScript): Um alinhamento específico é reservado entre as interfaces TypeScript do frontend (localizadas em `LimpeJaApp/src/types/backend/`) e os DTOs definidos no backend. Isso garante a validação e consistência da estrutura de dados em ambas as camadas, minimizando erros de tipagem e facilitando a colaboração.
- Tratamento de Erros: O `HttpExceptionFilter` do backend padroniza as respostas de erro, permitindo que o frontend interprete e exiba mensagens significativas ao usuário. As chamadas de API no frontend incluem blocos `try-catch` para lidar com erros de rede e respostas de erro da API.
- Serviços Centralizados: Chamadas de API são encapsuladas em serviços centralizados (`authService.ts`, `clientService.ts`, `providerService.ts`) que utilizam o Axios, promovendo reutilização de código e padronização.
Para uma lista completa de endpoints e DTOs, consulte uma documentação detalhada do backend, que pode ser acessada via Swagger UI em `http://localhost:3000/api` (após iniciar o backend). Abaixo alguns exemplos de interações:
<cabeça>
O projeto LimpeJá é um monorepo, contendo pastas para o frontend (LimpeJaApp/) e para o backend (backend-LimpeJá/).
LimpeJáApp/
├── app/ # Contém apenas as rotas e layouts do Expo Router
│ ├── (auth)/ # Authentication Flow
│ │ ├── provider-registration/
│ │ │ ├── verification/
│ │ │ │ ├── background-check-status.tsx
│ │ │ │ ├── document-upload.tsx
│ │ │ │ ├── facial-recognition.tsx
│ │ │ │ ├── index.tsx
│ │ │ │ ├── layout.tsx
│ │ │ │ ├── personal-details.tsx
│ │ │ │ ├── service-details.tsx
│ │ │ │ └── verify-account.tsx
│ │ │ ├── index.tsx
│ │ │ ├── layout.tsx
│ │ │ ├── personal-details.tsx
│ │ │ └── service-details.tsx
│ │ ├── client-registration.tsx
│ │ ├── forgot-password.tsx
│ │ ├── layout.tsx
│ │ ├── login.tsx
│ │ ├── README.md
│ │ ├── register-options.tsx
│ │ └── connection-test.tsx
│ ├── (client)/ # Client Functionalities
│ │ ├── bookings/ # Client Appointments
│ │ │ ├── [bookingId].tsx
│ │ │ ├── index.tsx
│ │ │ ├── schedule-service.tsx
│ │ │ └── success.tsx
│ │ ├── explore/ # Explore Services/Professionals
│ │ │ ├── [providerId].tsx
│ │ │ ├── index.tsx
│ │ │ ├── search-results.tsx
│ │ │ ├── search-results.tsx
│ │ │ ├── services-by-category.tsx
│ │ │ ├── all-categories.tsx
│ │ │ └── all-nearby-providers.tsx
│ │ ├── messages/ # Client Messages
│ │ │ ├── [chatId].tsx
│ │ │ └── index.tsx
│ │ ├── offers/ # Client Offers
│ │ │ └── [offerId].tsx
│ │ └── profile/ # Client Profile
│ │ │ ├── edit.tsx
│ │ │ ├── index.tsx
│ │ │ ├── layout.tsx
│ │ │ └── layout.tsx
│ ├── (common)/ # Common Functionalities (client and provider)
│ │ ├── reviews/
│ │ │ └── [targetId].tsx
│ │ ├── help.tsx
│ │ ├── layout.tsx
│ │ ├── notifications.tsx
│ │ ├── privacy.tsx
│ │ ├── README.md
│ │ ├── settings.tsx
│ │ └── terms.tsx
│ ├── (provider)/ # Provider Functionalities
│ │ ├── messages/ # Provider Messages
│ │ │ ├── [chatId].tsx
│ │ │ └── index.tsx
│ │ ├── profile/ # Provider Profile
│ │ │ ├── edit-services.tsx
│ │ │ └── index.tsx
│ │ ├── scheduling/ # Provider Schedule/Availability
│ │ │ └── index.tsx
│ │ ├── services/ # Provider Services/Requests
│ │ │ ├── [serviceId].tsx
│ │ │ └── index.tsx
│ │ ├── dashboard.tsx
│ │ ├── earnings.tsx
│ │ ├── layout.tsx
│ │ └── README.md
│ ├── _layout.tsx
│ ├── +not-found.tsx
│ ├── doc.md
│ ├── index.tsx
│ ├── README.md
│ └── welcome.tsx
├── assets/ # Static resources (fonts, images, lottie)
│ ├── fonts/
│ ├── images/
│ └── lottie/
├── components/ # Componentes React UI globais e reutilizáveis (InputWithIcon, AnimatedErrorMessage, etc.)
│ ├── layout/
│ └── ui/
├── config/ # Configurações do aplicativo (AppConfig, Firebase, etc.)
│ ├── AppConfig.ts
│ ├── firebase.ts
│ └── firebaseClient.ts
├── constants/ # Constantes globais (Cores, Rotas, Strings, Temas)
│ ├── Colors.ts
│ ├── routes.ts
│ ├── strings.ts
│ └── theme.ts
├── contexts/ # Contextos React para gerenciamento de estado global
│ ├── AppContext.tsx
│ ├── AuthContext.tsx
│ └── ProviderRegistrationContext.tsx
├── documentation/ # Documentação interna
├── hooks/ # Hooks React personalizados
│ ├── useAuth.ts
│ ├── useColorScheme.ts
│ ├── useColorScheme.web.ts
│ ├── useFormValidation.ts
│ └── useThemeColor.ts
├── node_modules/
├── scripts/ # Scripts auxiliares para o projeto
│ └── reset-project.js
├── services/ # Camada de serviços para comunicação com o backend (Axios, etc.)
│ ├── api.ts
│ ├── authService.ts
│ ├── bookingService.ts
│ ├── chatService.ts
│ ├── clientService.ts
│ ├── faqService.ts
│ ├── firebaseConfig.ts
│ ├── notificationService.ts
│ ├── offerService.ts
│ ├── paymentService.ts
│ ├── providerService.ts
│ ├── reviewService.ts
│ ├── searchService.ts
│ ├── uploadService.ts
│ └── verificationService.ts
├── types/ # Definições de tipos TypeScript (interfaces, enums) para frontend e backend
│ ├── auth.ts
│ ├── booking.ts
│ ├── bookings.ts
│ ├── chat.ts
│ ├── clients.ts
│ ├── faqs.ts
│ ├── index.ts
│ ├── navigation.ts
│ ├── notifications.ts
│ ├── offers.ts
│ ├── payments.ts
│ ├── provider.ts
│ ├── providers.ts
│ ├── reviews.ts
│ ├── service.ts
│ ├── services.ts
│ ├── types.ts
│ ├── user.ts
│ ├── users.ts
│ └── verification.ts
├── utils/ # Funções utilitárias e helpers
│ ├── helpers.ts
│ ├── permissions.ts
│ └── storage.ts
├── .env # Variáveis de ambiente
├── .gitignore # Arquivos e pastas a serem ignorados pelo Git
├── app.json
├── babel.config.js
├── eas.json
├── eslint.config.js
├── expo-env.d.ts # Definições de tipo para variáveis de ambiente Expo
├── LICENSE
├── metro.config.js
├── package-lock.json
├── package.json
├── README.md
├── src.rar # Arquivo compactado (deve ser ignorado pelo Git)
├── tsconfig.build.json
└── tsconfig.jsonbackend-LimpeJá/
├── dist/ # Saída compilada
├── node_modules/
├── prisma/ # Esquema Prisma e migrações
│ ├── migrations/
│ └── schema.prisma
├── src/ # Código fonte do NestJS
│ ├── auth/ # Módulo de Autenticação
│ │ ├── decorators/
│ │ ├── dto/
│ │ ├── guards/
│ │ ├── strategies/
│ │ ├── auth.controller.ts
│ │ ├── auth.module.ts
│ │ └── auth.service.ts
│ ├── availability/ # Módulo de Disponibilidade
│ │ ├── dto/
│ │ ├── entities/
│ │ ├── availability.controller.ts
│ │ ├── availability.module.ts
│ │ └── availability.service.ts
│ ├── bookings/ # Módulo de Agendamentos
│ │ ├── dto/
│ │ ├── entities/
│ │ ├── bookings.controller.ts
│ │ ├── bookings.module.ts
│ │ └── bookings.service.ts
│ ├── chat/ # Módulo de Chat
│ │ ├── dto/
│ │ ├── entities/
│ │ ├── gateway/
│ │ ├── chat.controller.ts
│ │ ├── chat.module.ts
│ │ └── chat.service.ts
│ ├── clients/ # Módulo de Clientes
│ │ ├── dto/
│ │ ├── entities/
│ │ ├── clients.controller.ts
│ │ ├── clients.module.ts
│ │ └── clients.service.ts
│ ├── common/ # Componentes comuns (filtros, pipes, etc.)
│ │ ├── constants/
│ │ ├── decorators/
│ │ ├── dto/
│ │ ├── entities/
│ │ ├── filters/
│ │ ├── interceptors/
│ │ └── pipes/
│ ├── config/ # Configurações de ambiente
│ │ ├── config.module.ts
│ │ ├── config.ts
│ │ └── validation-schema.ts
│ ├── notifications/ # Módulo de Notificações
│ │ ├── dto/
│ │ ├── entities/
│ │ ├── notifications.controller.ts
│ │ ├── notifications.module.ts
│ │ └── notifications.service.ts
│ ├── offers/ # Módulo de Ofertas
│ │ ├── dto/
│ │ ├── entities/
│ │ ├── offers.controller.ts
│ │ ├── offers.module.ts
│ │ └── offers.service.ts
│ ├── payments/ # Módulo de Pagamentos
│ │ ├── dto/
│ │ ├── entities/
│ │ ├── payments.controller.ts
│ │ ├── payments.module.ts
│ │ └── payments.service.ts
│ ├── prisma/ # Módulo Prisma para o NestJS
│ │ ├── prisma.module.ts
│ │ └── prisma.service.ts
│ ├── provider-services/ # Módulo de Serviços do Provedor
│ │ ├── dto/
│ │ ├── entities/
│ │ ├── provider-services.controller.ts
│ │ ├── provider-services.module.ts
│ │ └── provider-services.service.ts
│ ├── providers/ # Módulo de Provedores
│ │ ├── dto/
│ │ ├── entities/
│ │ ├── providers.controller.ts
│ │ ├── providers.module.ts
│ │ └── providers.service.ts
│ ├── reviews/ # Módulo de Avaliações
│ │ ├── dto/
│ │ ├── entities/
│ │ ├── reviews.controller.ts
│ │ ├── reviews.module.ts
│ │ └── reviews.service.ts
│ ├── search/ # Módulo de Busca
│ │ ├── dto/
│ │ ├── search.controller.ts
│ │ ├── search.module.ts
│ │ └── search.service.ts
│ ├── services/ # Módulo de Tipos de Serviço (globais)
│ │ ├── dto/
│ │ ├── update-service.dto.ts
│ │ ├── entities/
│ │ ├── services.controller.ts
│ │ ├── services.module.ts
│ │ └── services.service.ts
│ └── verification/ # Módulo de Verificação
│ ├── dto/
│ │ ├── send-cpf.dto.ts
│ │ ├── upload-document.dto.ts
│ │ └── upload-selfie.dto.ts
│ ├── entities/
│ ├── criminal-background-check.service.ts
│ ├── document-processing-service.ts
│ ├── verification.controller.ts
│ ├── verification.module.ts
│ └── verification.service.ts
├── shared/ # Código compartilhado (enums, interfaces, types)
│ ├── enums/
│ ├── interfaces/
│ └── types/
├── users/ # Módulo de Usuários
│ ├── dto/
│ ├── entities/
│ ├── users.controller.ts
│ ├── users.module.ts
│ └── users.service.ts
├── app.controller.spec.ts # Testes para o controlador principal
├── app.controller.ts
├── app.module.ts
├── app.service.ts
├── main.ts # Ponto de entrada da aplicação
└── test/ # Testes e configurações de teste
├── .env
├── .env.example
├── .gitignore
├── .prettierrc
├── eslint.config.mjs
├── nest-cli.json
├── package-lock.json
├── package.json
├── README.md
├── src.rar # Arquivo compactado (deve ser ignorado pelo Git)
├── tsconfig.build.json
└── tsconfig.jsonTo set up and run the project locally, follow the steps below:
Ensure you have the following tools installed:
- Clone o repositório:
git clone https://github.com/techleadevelopers/limpe-ja-app.git cd limpe-ja-app - Instale as dependências do Frontend:
cd LimpeJaApp npm install # ou yarn install cd .. Instalar as dependências do Backend:cd backend-LimpeJá npm install # ou yarn install cd ..Configurar o banco de dados (PostgreSQL com Docker):- Crie um arquivo `.env` na raiz da pasta `backend-LimpeJá` com as variáveis de ambiente do banco de dados e do JWT. Exemplo:
DATABASE_URL="postgresql://user:password@localhost:5432/LimpeJá_db" JWT_SECRET="sua_chave_secreta_jwt_aqui" JWT_EXPIRATION_TIME="1h" PORTA=3000 - Suba o contêiner Docker do PostgreSQL (assumindo que você tem um `docker-compose.yml` configurado para o postgres na raiz do projeto ou em `backend-LimpeJá/`):
docker-compose up -d postgres # Ou o comando específico para seu docker-compose - Execute as migrações do Prisma para criar o esquema do banco de dados e gerar o Prisma Client:
cd backend-LimpeJá npx prisma migrar dev --name init npx prisma gerar cd ..
- Crie um arquivo `.env` na raiz da pasta `backend-LimpeJá` com as variáveis de ambiente do banco de dados e do JWT. Exemplo:
Início do Backend:cd backend-LimpeJá npm run start:dev # ou yarn start:devO backend estará disponível em `http://localhost:3000` (ou na porta configurada em `.env`). A documentação do Swagger estará em `http://localhost:3000/api`.
Início do Frontend:Abra um novo terminal.
cd LimpeJaApp início da exposição npxIsso abrirá o Metro Bundler. Você pode ler o código QR com o aplicativo Expo Go no seu celular, ou usar um emulador/simulador Android Emulador de estúdio / Simulador iOS.
Para gerar um APK de teste para Android, você pode usar o EAS Build, um serviço da Expo para compilação de apps na nuvem.
Certifique-se de estar logado no Expo CLI: `expo login`Na pasta `LimpeJaApp`, execute:construção eas --plataforma android --desenvolvimento de perfilEste comando iniciará um processo de build na nuvem da Expo, utilizando o perfil `development` configurado no `eas.json` para gerar um APK de teste. Ao final, você receberá um link para baixar o APK diretamente.
Contribuições são o que tornam a comunidade de código aberto um lugar incrível para aprender, inspirar e criar. Qualquer contribuição que você fizer será muito apreciada.
Se você tem uma sugestão para melhorar este projeto, por favor, faça um fork do repositório e crie um pull request. Você também pode simplesmente abrir uma edição com a tag "melhoria".
Não se esqueça de dar uma estrela ao projeto! Obrigado novamente!
Faça um Fork do ProjetoCrie seu Feature Branch (`git checkout -b feature/AmazingFeature`)Commit suas mudanças (`git commit -m 'Add some AmazingFeature'`)Enviar para um Branch (`git push origin feature/AmazingFeature`)Abra um Pull Request
Paulo Silas de Campos Filho/ @techleadevelopers - techleadevelopers@gmail.com
Link do Projeto: https://github.com/techleadevelopers/limpe-ja-app
O LimpeJá foi concebido para ser uma plataforma que beneficia tanto os clientes em busca de serviços de limpeza de qualidade quanto os profissionais que desejam ampliar sua base de clientes e gerenciar seus serviços de forma eficiente. Nossa estratégia de monetização é transparente e se baseia no sucesso mútuo, inspirada em modelos de marketplace consolidados como o Airbnb, mas aplicada ao universo dos serviços de limpeza.
A principal fonte de receita do LimpeJá virá de uma comissão percentual cobrada sobre o valor de cada serviço de limpeza que é agendado e efetivamente pago através da plataforma.
Para o Profissional (Prestador de Serviço):- Ao se cadastrar, o profissional define seus preços para os diferentes tipos de serviço que oferece (ex: por hora, por tipo de limpeza, etc.).
- Quando um cliente contrata e paga por um serviço através do LimpeJá, o valor total é processado pela plataforma.
- O LimpeJá repassa o valor ao profissional, deduzindo uma taxa de serviço (comissão) previamente acordada e transparente. Esta taxa será nossa principal fonte de receita.
- Benefícios para o Profissional: Acesso a uma ampla base de clientes, ferramentas de gerenciamento de agenda, marketing de plataforma, segurança no recebimento e processamento de pagamentos, suporte.
Para o Cliente:- O cliente vê o preço total do serviço (que já inclui a porção do profissional e, implicitamente, a margem que permite a comissão do LimpeJá).
- Em alguns modelos de marketplace, uma pequena taxa de conveniência/serviço pode ser adicionada ao cliente, mas o modelo principal geralmente foca na comissão sobre o valor pago ao prestador. Para o LimpeJá, podemos iniciar focando na comissão sobre o credor para manter a atratividade para o cliente.
- Benefícios para o Cliente: Conveniência para encontrar e agenda profissional diversificada, variedade de escolha, sistema de avaliações para confiança, processo de pagamento simplificado e seguro, e a garantia de uma plataforma intermediando o serviço.
É crucial que a taxa de comissão seja clara para os profissionais e que o valor oferecido pela plataforma (marketing, base de clientes, ferramentas, segurança) justifique essa taxa. O sucesso do LimpeJá dependerá da criação de um ecossistema de que tanto clientes quanto profissionais vejam vantagens claras em usar a plataforma, resultando em um volume saudável de agendamentos e, consequentemente, receita para o aplicativo.
Este modelo permite que o LimpeJá cresça conforme o volume de transações na plataforma aumente, alinhando nossos ganhos com o sucesso dos profissionais parceiros.
O projeto LimpeJá atingiu a fase de completa implementação das funcionalidades principais e integrações com APIs reais, estando 100% testado e pronto para a fase de deploy e manutenção. O roteiro a seguir foca em aprimoramentos contínuos, otimização e expansão estratégica.
Otimização de Performance e Refinamento Contínuo:- Backend: Otimizar `include` statements do Prisma para evitar N+1 e carregamento excessivo de dados. Refinar transições de status de agendamento para maior fluidez e consistência. Continuar refinamento da documentação Swagger (`@ApiProperty`).
- Frontend: Aprimorar a experiência do usuário e otimização de performance geral. Revisar avisos de depreciação de estilos e uso de `useNativeDriver` em animações para garantir a compatibilidade e o desempenho otimizado em todas as plataformas e builds.
Expansão de Funcionalidades e Escala:- Backend:
- Implementar o cálculo de `walletBalance` para clientes e provedores.
- Refinar a lógica de permissões no `ChatController` e `ChatService` para maior granularidade.
- Otimizar a recuperação de histórico de mensagens para grandes volumes.
- Assegurar a atomicidade completa para todas as transações financeiras (ex: saques).
- Frontend:
- Implementar UI para gestão de `walletBalance` e fluxos de saque/depósito.
- Desenvolver UI para filtros geoespaciais avançados na busca de provedores.
- Aprimorar o sistema de mensagens com persistência completa e indicadores de status em tempo real (ex: "digitando...", "visto por último").
- Backend:
Manutenção e Suporte:- Documentação: Manter a documentação técnica e de usuário atualizada e abrangente.
- Testes: Implementar e expandir testes de integração e ponta a ponta para garantir a robustez contínua da aplicação.
- Internacionalização (i18n): Adicionar suporte a múltiplos idiomas para uma expansão global futura.
- Monitoramento: Configurar e refinar ferramentas de monitoramento de performance e erros em produção (APM, crash reporting).
Para informações fornecidas e suporte sobre as tecnologias e o ecossistema do projeto LimpeJá, consulte os seguintes recursos oficiais:
| Fluxo/Tela do Frontend | Endpoint do Backend (Método HTTP, Caminho) | DTOs (Requisição/Resposta) |
|---|---|---|
| Fluxo de Autenticação | ||
| Registro de Clientes | `POST /auth/register/client` | `RegisterClientDto` / `AuthResponseDto` |
| Login | `POST /auth/login` | `LoginDto` / `AuthResponseDto` |
| **Solicitar OTP** | `**POST /auth/send-otp**` | `**RequestOtpDto**` / `**MessageResponseDto**` |
| **Verificar OTP** | `**POST /auth/verify-otp**` | `**VerifyOtpDto**` / `**AuthResponseDto**` |
| Gerenciamento de Usuário/Perfil | ||
| Obter Perfil do Usuário | `GET /users/me` | `UserProfileDto` |
| Atualizar Perfil do Cliente | `PATCH /clients/me` | `UpdateClientProfileDto` / `ClientEntity` |
| Fluxo do Cliente | ||
| Buscar Provedores/Serviços | `GET /search` | `SearchQueryDto` / `SearchResultDto` |
| Criar Agenda | `POST /bookings` | `CreateBookingDto` / `BookingDetailsDto` |
| Criar Cobrança PIX | `POST /payments/pix-charge` | `CreatePixChargeDto` / `PixChargeResponseDto` |
| Fluxo do Provedor | ||
| Obter Agendamentos do Provedor | `GET /bookings/me` | `BookingDetailsDto[]` |
| Gerenciar Disponibilidade | `PATCH /providers/:providerId/availability` | `UpdateAvailabilityDto[]` / `AvailabilityDto[]` |
| Fluxo Comum | ||
| Obter Mensagens de Chat | `GET /chat/:chatId/messages` | `GetMessagesDto` / `Message[]` |
| Enviar mensagem de chat | `POST /chat/:chatId/messages` | `EnviarMensagemDpara` / `Mensagem` |
| Enviar Avaliação | `POST /avaliações` | `EnviarAvaliaçãoDpara` / `EntidadeAvaliação` |