Compare commits

...
3 Commits
Author SHA1 Message Date
gabspereira 744868caa1 feat(go-crm): full auth, routing, middleware, and supporting infra
- Add auth handlers (signup, login, logout, account management) with bcrypt
- Add client, customer, service, scheduling, payment, question, answer handlers
- Add dashboard, monthly report, and lead pipeline pages
- Add UTF-8 middleware to force charset on HTML responses
- Add config package with env-based overrides for DB path, secrets, endpoints
- Add parser package for WhatsApp message ingestion
- Add clean-arch layers: pkg/domain, pkg/repo, pkg/usecase for leads
- Add cmd/migrate utility for DB migrations
- Add Makefile, README, run-tests.sh, and dev scripts
- Update docker-compose.yml with memory limits
- Update .air.toml to exclude DB files and stop on errors
- Update whatsapp-sync dependencies and add src/index.js entrypoint
- Add whatsme standalone WhatsApp reader app (source only)
- Untrack .opencode-sandbox/data/go-crm.db from git history
- Expand root .gitignore: ngrok, tmp dirs, sandbox DBs, compiled binaries
2026-05-23 16:55:55 -03:00
gabspereira 57920d45d6 feat(leads): add lead pipeline, keyword/status mapping, and encoding fixes
- Add lead ingestion, review queue, and keyword/status management
- Add DB schema: leads, service_keywords, lead_statuses, processed_messages
- Add migration with default keyword/status seeding per client
- Fix SQLite read/write deadlock in sanitizeEncoding
- Fix UTF-8 corruption: replace byte-iterating replaceAll with strings.ReplaceAll
- Add utf8.ValidString guard to decodeLatin1 to avoid double-encoding
- Remove hardcoded internal-secret; use config.InternalSecret() everywhere
- Add .gitignore for binaries, SQLite DBs, build artifacts, WhatsApp sessions
2026-05-23 16:49:43 -03:00
gabspereira 57e6e5a6fd Add leads handlers, WhatsApp integration, and test files 2026-05-02 17:40:38 +00:00
68 changed files with 8427 additions and 1042 deletions

No files matched your search

+29
View File
@@ -53,3 +53,32 @@ Thumbs.db
# Go CRM data # Go CRM data
data/*.db data/*.db
# Databases (all locations)
*.db
*.db-journal
# WhatsApp session auth
.wwebjs_auth/
# Go build artifacts
apps/go-crm/go-crm
apps/go-crm/tmp/
# Sandbox / generated data
.opencode-sandbox/data/
.opencode-sandbox/*.db
# Binaries / tools
ngrok
apps/go-crm/go-crm
apps/go-crm/main
apps/go-crm/migrate
# Temporary build dirs
tmp/
apps/tmp/
# WhatsApp compiled binaries
apps/whatsme/whatsme
*.log
Binary file not shown.
@@ -0,0 +1,36 @@
---
name: backend-driven-ui
description: Create distinctive, production-grade frontend interfaces using Golang and Hypermedia (HTMX/Templ). Use this skill to build reactive web components and pages that prioritize performance and maintainability without the complexity of modern JavaScript frameworks.
---
This skill guides the creation of high-end, "vibe-coded" interfaces using a **Golang-centric stack**. It avoids the maintenance burden of React/JS frameworks by leveraging **HTMX** and **Templ**, focusing on server-side logic that delivers rich, interactive client experiences.
## Design Thinking & "Vibe Coding"
Before coding, commit to a BOLD aesthetic direction that feels "hand-crafted" rather than "framework-default":
- **Hypermedia First**: Architecture relies on HTML fragments. Every interaction is a server-side transition, making the app feel incredibly fast and robust.
- **Tone**: Since we are avoiding the "React look," lean into distinctive styles: **High-Tech Industrial**, **Neo-Brutalist**, **Swiss International**, or **Terminal-Core**.
- **The "Vibe"**: Aim for the "vibe coding" energy—fast feedback loops, visible data flowing through the terminal, and interfaces that feel like specialized tools rather than generic SaaS dashboards.
## Frontend Aesthetics Guidelines
Focus on:
- **Typography**: Use characterful fonts that reflect the precision of Go. Lean towards high-quality Monospace (e.g., JetBrains Mono, Berkeley Graphics) for a "tooling" feel, or sophisticated Serifs paired with tight Grotesks for an editorial look.
- **Color & Theme**: Use high-contrast themes. Since this is built with **Tailwind CSS**, use specific color scales (e.g., Zinc, Slate, or custom olive/amber palettes) to avoid the "Tailwind default" blue.
- **Motion (CSS-Only)**: Prioritize CSS transitions and HTMX swapping animations (`htmx-settling`, `htmx-requesting`). Use staggered reveals and smooth opacity fades to mask the server-side round trip, making it feel "instant."
- **Interaction**: Use **HTMX attributes** (`hx-get`, `hx-post`, `hx-target`) to create "Active Search," "Infinite Scroll," and "Inline Editing" patterns that surprise users who expect a heavy JS bundle.
## Technical Implementation (The Go Stack)
- **Templ over HTML**: All components must be written in `.templ` files. This ensures type safety and allows you to pass Go structs directly into your UI components.
- **HTMX over JavaScript**: Replace `useState` and `useEffect` with `hx-trigger` and `hx-swap`. Maintain application state in the Go backend or the URL, not in a complex client-side store.
- **Tailwind for Styling**: Use utility classes to keep styles local to the HTML. Avoid external CSS files to maintain the "Locality of Behavior" principle.
- **Zero-JS Interactivity**: If client-side logic is strictly necessary (modals, toggles), use **Alpine.js** for its minimal footprint, keeping the code readable within the HTML.
## What to Avoid
- **No Heavy Frameworks**: Strictly avoid React, Vue, or Angular.
- **No JS "Glue Code"**: Avoid writing custom vanilla JavaScript for things HTMX can handle natively.
- **No "AI Slop" Aesthetics**: Avoid the "Inter font + purple gradient + rounded card" combo.
- **No JSON APIs for the UI**: Do not build internal JSON endpoints for your own frontend; return HTML fragments instead.
**IMPORTANT**: The beauty of this approach lies in its **mechanical elegance**. The code should be as clean and performant as the Go binary itself. Show that a "Vibe" can be achieved through clever hypermedia patterns and rock-solid backend engineering.
+68 -152
View File
@@ -1,195 +1,111 @@
# AGENTS.md - Agent Coding Guidelines # AGENTS.md
This workspace is a monorepo containing data engineering projects and WhatsApp CRM applications.
---
## Project Structure ## Project Structure
``` ```
workspace/ workspace/
├── apps/ ├── apps/
│ ├── whatsapp-crm/ # Next.js CRM with Kanban board (primary app) │ ├── go-crm/ # Go server (Chi), HTML templates, hot-reload via air
│ ├── whatsapp-sync/ # WhatsApp message sync service │ ├── whatsapp-crm/ # Next.js 14 App Router, sql.js (browser SQLite), Kanban
│ ├── whatsapp-reader/ # WhatsApp message reader │ ├── whatsapp-sync/ # Node.js WhatsApp sync service
│ └── timesfm-forecast/ # Time series forecasting app │ ├── whatsapp-reader/ # Standalone message reader
├── data-engineering/ # Udacity DE portfolio projects │ └── timesfm-forecast/ # Streamlit + TimesFM (Python/uv)
├── data/ # SQLite DBs: go-crm.db, whatsapp.db
├── data-engineering/ # Udacity DE portfolio (standalone, no unified build)
└── skills/ # dbt reference templates └── skills/ # dbt reference templates
``` ```
--- ---
## Build / Lint / Test Commands ## Developer Commands
### whatsapp-crm (primary app) ### go-crm (primary)
```bash
cd apps/go-crm
go run main.go # plain dev (no hot-reload)
air # hot-reload dev (uses .air.toml)
go build -o go-crm main.go # binary
./go-crm # run binary
go mod tidy # clean go.mod/go.sum
# DB: /workspace/data/go-crm.db (hardcoded path — do not change)
# WhatsApp session: /workspace/data/whatsapp.db (hardcoded path)
```
### whatsapp-crm
```bash ```bash
cd apps/whatsapp-crm cd apps/whatsapp-crm
npm run dev # Next.js dev server 0.0.0.0:3000
# Development npm run build # production build
npm run dev # Start Next.js dev server on 0.0.0.0:3000 npm run lint # ESLint
npm run build # Production build npm run test # Jest (uses tests/setup.ts)
npm run start # Production server
# Linting
npm run lint # ESLint with Next.js config
# Testing
npm run test # Run all Jest tests
npm run test:watch # Run tests in watch mode
npm run test:coverage # Run tests with coverage
# Single test file
npm run test -- tests/kanban.test.ts
npm run test -- --testPathPattern=kanban
``` ```
### whatsapp-sync ### whatsapp-sync
```bash ```bash
cd apps/whatsapp-sync cd apps/whatsapp-sync
npm run start # node src/index.js
npm run start # node src/index.js npm run dev # node --watch src/index.js
npm run dev # node --watch src/index.js npm run sync # node src/sync.js
npm run sync # node src/sync.js npm run test # Jest (mocks qrcode-terminal + whatsapp-web.js)
npm run test # Jest
npm run test:watch # Jest watch mode
npm run test:coverage # Jest with coverage
``` ```
### whatsapp-reader ### whatsapp-reader
```bash ```bash
cd apps/whatsapp-reader cd apps/whatsapp-reader
# No test script defined node index.js # main script
node index.js # Run main script node sync.js # sync script
node sync.js # Run sync script # no test script
``` ```
### timesfm-forecast (Python/uv) ### timesfm-forecast
```bash ```bash
cd apps/timesfm-forecast cd apps/timesfm-forecast
uv venv && source .venv/bin/activate # Create & activate venv uv venv && source .venv/bin/activate
uv pip install -e . # Install package uv pip install -e .
timesfm-app # Run Streamlit app ruff check . # lint (dev dep)
timesfm-app # run Streamlit app
# See apps/timesfm-forecast/README.md for CUDA/CPU wheel guidance
``` ```
--- ---
## Code Style Guidelines ## Important Quirks
### TypeScript ### WhatsApp auth sessions
- `strict: true` enabled in tsconfig.json - `.wwebjs_auth/` directories store session state — do not commit these
- Always use explicit types for function parameters and return values - `whatsapp-sync` uses `better-sqlite3` for persistence
- Use `interface` for objects, `type` for unions/aliases - `whatsapp-crm` browser-side uses `sql.js` (WebAssembly, no native deps)
```typescript ### go-crm auth
// Good - `X-Internal-Secret` header required on requests (value: `internal-secret`)
interface Contact { - WhatsApp connector init URL: `http://localhost:8080`
id: number
name: string
stage: Stage
}
function getContactById(id: number): Contact | null ### Docker
```bash
// Avoid docker compose up whatsapp-crm # CRM only
const contact = { id: 1, name: 'Test' } // implicit any docker compose --profile sync up # CRM + sync
docker compose --profile test up # test runner
``` ```
### Imports ### go-crm hot-reload
- Use path alias `@/*` for internal imports (configured in tsconfig.json) - Uses `air` (not `go run`) — configured in `.air.toml`
- Order: external → internal → relative - Build excludes `_test.go` and `vendor/`, `tmp/`, `assets/`
- Group by: React imports → other imports → types → components
```typescript ### TypeScript config (whatsapp-crm, whatsapp-sync)
import { useState, useMemo } from 'react' - `strict: true` in tsconfig.json
import { Stage, STAGES, Contact } from '@/lib/types' - Path alias `@/*` maps to `src/*`
import { ContactCard } from '@/components/ContactCard'
```
### Naming Conventions ### Testing mocks
- **Components**: PascalCase (e.g., `KanbanBoard`, `ContactCard`) - `whatsapp-sync` has manual mocks for `qrcode-terminal` and `whatsapp-web.js` in `tests/__mocks__/`
- **Files**: PascalCase for components (`.tsx`), camelCase for utilities (`.ts`)
- **Interfaces/Types**: PascalCase (e.g., `Contact`, `Task`, `CreateContactInput`)
- **Constants**: UPPER_SNAKE_CASE (e.g., `STAGES`, `STAGE_LIST`)
- **React hooks**: camelCase with `use` prefix (e.g., `useContacts`, `useTask`)
- **Boolean variables**: prefix with `is`, `has`, `should` (e.g., `isLoading`, `hasError`)
### Error Handling
- Use Zod for input validation with react-hook-form
- Always wrap async operations in try/catch
- Return proper HTTP status codes in API routes
```typescript
// API route error handling
export async function POST(request: Request) {
try {
const body = await request.json()
const validated = CreateContactInput.parse(body)
} catch (error) {
if (error instanceof ZodError) {
return Response.json({ error: error.errors }, { status: 400 })
}
return Response.json({ error: 'Internal server error' }, { status: 500 })
}
}
```
### Component Structure
- Use `'use client'` directive for client-side components
- Destructure props with explicit typing
- Keep components focused and small
- Extract reusable logic to custom hooks
```typescript
'use client'
interface Props {
contacts: Contact[]
onContactClick: (contact: Contact) => void
}
export default function ComponentName({ contacts, onContactClick }: Props) {
const [state, setState] = useState(false)
return <div>{/* JSX */}</div>
}
```
### Database (sql.js)
- Use Zod schemas for table definitions
- Always validate data before insert/update
- Use transactions for multi-step operations
### Testing
- Test files: `tests/*.test.ts` or `*.test.tsx`
- Use `@testing-library/react` for component tests
- Use `@testing-library/user-event` for user interactions
- Follow AAA pattern: Arrange, Act, Assert
```typescript
test('should update contact stage', async () => {
const user = userEvent.setup()
render(<KanbanBoard {...props} />)
await user.click(screen.getByText('Move to Next Stage'))
expect(onStageChange).toHaveBeenCalledWith(1, 'DECIDINDO')
})
```
### CSS / Styling
- This project uses CSS modules or global CSS
- Follow BEM-like naming: `block-element--modifier`
- Keep styles co-located when possible
### Git Conventions
- Use meaningful commit messages
- Branch naming: `feature/description` or `fix/description`
- Run `npm run lint` and `npm run test` before committing
--- ---
## Important Notes ## What to Avoid
- whatsapp-crm uses Next.js 14 App Router - Do not use `go run main.go` for development — use `air`
- Database is sql.js (WebAssembly SQLite) - runs in browser - Do not commit `.wwebjs_auth/` or `.wwebjs_cache/` directories
- Authentication uses WhatsApp Web.js QR code scanning - Do not change hardcoded DB paths in `main.go`
- STAGES constant defines the Kanban pipeline (defined in `src/lib/types.ts`) - The `data-engineering/` projects are standalone — no shared build or test commands
+7 -7
View File
@@ -4,20 +4,20 @@ tmp_dir = "tmp"
[build] [build]
bin = "./tmp/main" bin = "./tmp/main"
cmd = "go build -buildvcs=false -o ./tmp/main ." cmd = "go build -buildvcs=false -o ./tmp/main ."
delay = 1000 delay = 2000
exclude_dir = ["assets", "tmp", "vendor"] exclude_dir = ["assets", "tmp", "vendor", "data", "node_modules", ".git"]
exclude_file = [] exclude_file = []
exclude_regex = ["_test.go"] exclude_regex = ["_test.go", "\\.db$", "\\.db-journal$", "\\.db-shm$", "\\.db-wal$"]
exclude_unchanged = false exclude_unchanged = true
follow_symlink = false follow_symlink = false
full_screen = false full_screen = false
include_dir = [] include_dir = ["internal"]
include_ext = ["go", "templ"] include_ext = ["go", "templ"]
kill_delay = "0s" kill_delay = "2s"
log = "build-errors.toml" log = "build-errors.toml"
send_exit = false send_exit = false
send_user = false send_user = false
stop_on_error = false stop_on_error = true
[log] [log]
main_only = false main_only = false
+45
View File
@@ -0,0 +1,45 @@
# Binaries
/go-crm
/main
/migrate
/go-crm-test
*.exe
*.dll
*.so
*.dylib
# Build artifacts
tmp/
*.out
*.log
build-errors.*
# SQLite databases
data/
.dev-data/
*.db
*.db-journal
*.db-shm
*.db-wal
*.db.bak
# Test output
*.test
*.cover
*.cov
coverage/
# IDE
.idea/
.vscode/
*.swp
*.swo
*~
# OS
.DS_Store
Thumbs.db
# WhatsApp session files (if ever synced here)
.wwebjs_auth/
.wwebjs_cache/
+6
View File
@@ -6,8 +6,14 @@ RUN pacman -Syu --noconfirm && \
git \ git \
sqlite \ sqlite \
curl \ curl \
nodejs \
npm \
chromium \
&& pacman -Scc --noconfirm && pacman -Scc --noconfirm
ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true
ENV PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium
WORKDIR /tmp WORKDIR /tmp
RUN curl -sSL https://github.com/air-verse/air/releases/download/v1.27.10/air_1.27.10_linux_amd64.tar.gz | tar -xz && \ RUN curl -sSL https://github.com/air-verse/air/releases/download/v1.27.10/air_1.27.10_linux_amd64.tar.gz | tar -xz && \
+24
View File
@@ -0,0 +1,24 @@
.PHONY: test test-watch build clean dev migrate
test:
go test ./... -v
test-watch:
while true; do \
inotifywait -q -e modify -e create -e delete -r internal/ 2>/dev/null || sleep 2; \
go test ./... -v; \
done
build:
go build -o go-crm .
clean:
rm -f go-crm
dev:
./scripts/dev.sh
migrate:
go build -o migrate cmd/migrate/main.go
./migrate
rm -f migrate
+125
View File
@@ -0,0 +1,125 @@
# go-crm (lightweight local dev)
This service is intentionally small so junior Go developers can understand it end-to-end without Docker, hot reloads, or other heavy tooling. The goal: `go run main.go` with a single SQLite file in `.dev-data/`.
## Local development (junior-friendly)
1. Ensure Go 1.25+ is installed and `go` is in your `PATH`.
2. Run the helper script (no Docker):
```bash
./scripts/dev.sh
```
3. The server boots on [http://localhost:8080](http://localhost:8080).
4. The database and WhatsApp store live under `.dev-data/` (auto-created).
There are no file watchers or `air` hot reloads—just the plain Go toolchain so newcomers can focus on code, not tooling.
## Project layout (modern, clean layers)
```
go-crm/
├── cmd/ # optional commands (e.g. migrations)
│ └── migrate/ # lightweight migration CLI (future)
├── config/ # templated configs (kept simple)
├── data/ # production data path (gitignored)
├── internal/ # HTTP handlers (usecases wired to HTTP)
│ ├── handlers/
│ ├── middleware/
│ └── templates/
├── pkg/ # reusable application packages
│ ├── domain/ # entities + repository interfaces
│ ├── usecase/ # application services / business logic
│ └── repo/ # persistence adapters (SQLite, etc.)
├── scripts/ # helper scripts (dev runner, migrations)
├── main.go # application entrypoint (wire handlers → usecases)
├── go.mod
└── go.sum
```
## Recommended architecture / interfaces
### `pkg/domain/lead.go`
```go
package domain
// Lead is the core business entity.
type Lead struct {
LeadID int64
ClientID int64
Name string
PhoneRaw string
PhoneNormalized string
ServiceInterest string
Status string
PaymentStatus string
}
// LeadRepository abstracts persistence.
type LeadRepository interface {
FindAll(ctx context.Context, clientID int64) ([]Lead, error)
FindByID(ctx context.Context, clientID, leadID int64) (*Lead, error)
Update(ctx context.Context, lead Lead) error
}
```
### `pkg/usecase/lead_service.go`
```go
package usecase
import (
"context"
"go-crm/pkg/domain"
)
// LeadService orchestrates business logic.
type LeadService struct {
Repo domain.LeadRepository
}
func (s *LeadService) ListAll(ctx context.Context, clientID int64) ([]domain.Lead, error) {
return s.Repo.FindAll(ctx, clientID)
}
```
### `pkg/repo/sqlite_lead_repo.go`
```go
package repo
import (
"context"
"database/sql"
"go-crm/pkg/domain"
)
// SQLiteLeadRepository implements LeadRepository using sqlite.
type SQLiteLeadRepository struct {
DB *sql.DB
}
func (r *SQLiteLeadRepository) FindAll(ctx context.Context, clientID int64) ([]domain.Lead, error) {
// query leads table, scan rows, return []domain.Lead
}
```
Handlers in `internal/handlers` should accept a clear service layer (`usecase.LeadService`), not raw DB logic. Keep controllers thin: parse request, call service, write HTML/JSON.
## Migration strategy
- Do not scan/clean the entire `leads` table on every startup (that was causing RAM blowups).
- Run the lightweight CLI with `make migrate` (which builds and runs the migration binary) whenever you need to refresh the schema or re-decode legacy Latin-1 data. To target non-default files, run the migration binary directly:
```bash
go build -o migrate cmd/migrate/main.go && ./migrate --db /path/to/go-crm.db
```
## Running tests
```bash
go test ./...
```
## Summary
- No Docker or `air` watchers—just `go run main.go`.
- Clean package boundaries (domain/usecase/repo) improve readability and testability.
- Scripts under `scripts/` orchestrate database setup or helper tasks.
- Use the architecture sketch above to guide future refactors.
+28
View File
@@ -0,0 +1,28 @@
// Command migrate applies schema changes and sanitizes legacy data.
package main
import (
"flag"
"fmt"
"log"
"go-crm/config"
"go-crm/internal/db"
)
func main() {
dbPath := flag.String("db", config.DatabasePath(), "path to SQLite database file")
flag.Parse()
database, err := db.Init(*dbPath)
if err != nil {
log.Fatalf("migration failed: %v", err)
}
defer func() {
if err := database.Close(); err != nil {
log.Printf("warning: closing database: %v", err)
}
}()
fmt.Println("Migration complete. Schema ensured and legacy encodings for lead_statuses & service_keywords fixed.")
}
+110
View File
@@ -0,0 +1,110 @@
package config
import (
"os"
"path/filepath"
)
const (
defaultWorkspaceRoot = "/workspace"
defaultDataDirName = "data"
defaultDatabaseFile = "go-crm.db"
defaultWhatsAppStore = "whatsapp.db"
defaultHTTPEndpoint = "http://localhost:8080"
defaultInternalSecret = "internal-secret"
)
// WorkspaceRoot returns the path to the shared workspace. CRM_WORKSPACE_PATH overrides it.
// When no override is provided, we try to detect the workspace by walking up from the current
// working directory and looking for the typical monorepo layout. If that fails, we fall back
// to `../..` relative to the current directory and ultimately to `/workspace`.
func WorkspaceRoot() string {
if v := os.Getenv("CRM_WORKSPACE_PATH"); v != "" {
return filepath.Clean(v)
}
if candidate := detectWorkspaceRoot(); candidate != "" {
return candidate
}
if fallback := fallbackWorkspaceRoot(); fallback != "" {
return fallback
}
return defaultWorkspaceRoot
}
func detectWorkspaceRoot() string {
wd, err := os.Getwd()
if err != nil {
return ""
}
for dir := wd; ; {
if hasDir(dir, "data") && hasDir(dir, "apps") {
return filepath.Clean(dir)
}
parent := filepath.Dir(dir)
if parent == dir {
break
}
dir = parent
}
return ""
}
func fallbackWorkspaceRoot() string {
wd, err := os.Getwd()
if err != nil {
return ""
}
return filepath.Clean(filepath.Join(wd, "..", ".."))
}
func hasDir(dir, name string) bool {
info, err := os.Stat(filepath.Join(dir, name))
return err == nil && info.IsDir()
}
// DataDir returns the directory that stores SQLite files and related state. CRM_DATA_DIR overrides it.
// If a local ".dev-data" directory exists (for junior-friendly dev), it is preferred.
func DataDir() string {
if v := os.Getenv("CRM_DATA_DIR"); v != "" {
return filepath.Clean(v)
}
// prefer local .dev-data directory if present
if cwd, err := os.Getwd(); err == nil {
if info, err := os.Stat(filepath.Join(cwd, ".dev-data")); err == nil && info.IsDir() {
return filepath.Join(cwd, ".dev-data")
}
}
return filepath.Join(WorkspaceRoot(), defaultDataDirName)
}
// DatabasePath returns the path to the Go CRM SQLite database. CRM_DATABASE_PATH overrides it.
func DatabasePath() string {
if v := os.Getenv("CRM_DATABASE_PATH"); v != "" {
return filepath.Clean(v)
}
return filepath.Join(DataDir(), defaultDatabaseFile)
}
// WhatsAppStorePath returns the path where the Whatsmeow session DB is stored. CRM_WHATSAPP_STORE_PATH overrides it.
func WhatsAppStorePath() string {
if v := os.Getenv("CRM_WHATSAPP_STORE_PATH"); v != "" {
return filepath.Clean(v)
}
return filepath.Join(DataDir(), defaultWhatsAppStore)
}
// HTTPServerEndpoint returns the HTTP endpoint used when WhatsApp events need to call back to the Go server.
func HTTPServerEndpoint() string {
if v := os.Getenv("CRM_HTTP_ENDPOINT"); v != "" {
return v
}
return defaultHTTPEndpoint
}
// InternalSecret returns the internal secret required by the WhatsApp connector.
func InternalSecret() string {
if v := os.Getenv("CRM_INTERNAL_SECRET"); v != "" {
return v
}
return defaultInternalSecret
}
Binary file not shown.
+4
View File
@@ -12,6 +12,10 @@ services:
working_dir: /workspace/apps/go-crm working_dir: /workspace/apps/go-crm
command: air command: air
restart: unless-stopped restart: unless-stopped
deploy:
resources:
limits:
memory: 2G
networks: networks:
crm-network: crm-network:
+25 -6
View File
@@ -1,25 +1,44 @@
module go-crm module go-crm
go 1.22 go 1.25.0
require ( require (
github.com/glebarez/go-sqlite v1.21.2
github.com/glebarez/sqlite v1.11.0 github.com/glebarez/sqlite v1.11.0
github.com/go-chi/chi/v5 v5.1.0 github.com/go-chi/chi/v5 v5.1.0
golang.org/x/crypto v0.27.0 github.com/go-chi/cors v1.2.2
go.mau.fi/whatsmeow v0.0.0-20260427122815-7514259253a7
golang.org/x/crypto v0.50.0
golang.org/x/text v0.37.0
) )
require ( require (
filippo.io/edwards25519 v1.1.0 // indirect
github.com/beeper/argo-go v1.1.2 // indirect
github.com/coder/websocket v1.8.14 // indirect
github.com/dustin/go-humanize v1.0.1 // indirect github.com/dustin/go-humanize v1.0.1 // indirect
github.com/glebarez/go-sqlite v1.21.2 // indirect github.com/elliotchance/orderedmap/v3 v3.1.0 // indirect
github.com/google/uuid v1.3.0 // indirect github.com/google/uuid v1.6.0 // indirect
github.com/jinzhu/inflection v1.0.0 // indirect github.com/jinzhu/inflection v1.0.0 // indirect
github.com/jinzhu/now v1.1.5 // indirect github.com/jinzhu/now v1.1.5 // indirect
github.com/mattn/go-isatty v0.0.17 // indirect github.com/mattn/go-colorable v0.1.14 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/petermattis/goid v0.0.0-20260330135022-df67b199bc81 // indirect
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
golang.org/x/sys v0.25.0 // indirect github.com/rs/zerolog v1.35.0 // indirect
github.com/vektah/gqlparser/v2 v2.5.27 // indirect
go.mau.fi/libsignal v0.2.1 // indirect
go.mau.fi/util v0.9.8 // indirect
golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f // indirect
golang.org/x/net v0.53.0 // indirect
golang.org/x/sync v0.20.0 // indirect
golang.org/x/sys v0.43.0 // indirect
google.golang.org/protobuf v1.36.11 // indirect
gorm.io/gorm v1.25.7 // indirect gorm.io/gorm v1.25.7 // indirect
modernc.org/libc v1.22.5 // indirect modernc.org/libc v1.22.5 // indirect
modernc.org/mathutil v1.5.0 // indirect modernc.org/mathutil v1.5.0 // indirect
modernc.org/memory v1.5.0 // indirect modernc.org/memory v1.5.0 // indirect
modernc.org/sqlite v1.23.1 // indirect modernc.org/sqlite v1.23.1 // indirect
) )
replace go.mau.eu/whatsmeow => go.mau.fi/whatsmeow v0.0.0-20260427122815-7514259253a7
+63 -9
View File
@@ -1,29 +1,83 @@
filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM=
github.com/agnivade/levenshtein v1.2.1/go.mod h1:QVVI16kDrtSuwcpd0p1+xMC6Z/VfhtCyDIjcwga4/DU=
github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ=
github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8=
github.com/beeper/argo-go v1.1.2 h1:UQI2G8F+NLfGTOmTUI0254pGKx/HUU/etbUGTJv91Fs=
github.com/beeper/argo-go v1.1.2/go.mod h1:M+LJAnyowKVQ6Rdj6XYGEn+qcVFkb3R/MUpqkGR0hM4=
github.com/coder/websocket v1.8.14 h1:9L0p0iKiNOibykf283eHkKUHHrpG7f65OE3BhhO7v9g=
github.com/coder/websocket v1.8.14/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/elliotchance/orderedmap/v3 v3.1.0 h1:j4DJ5ObEmMBt/lcwIecKcoRxIQUEnw0L804lXYDt/pg=
github.com/elliotchance/orderedmap/v3 v3.1.0/go.mod h1:G+Hc2RwaZvJMcS4JpGCOyViCnGeKf0bTYCGTO4uhjSo=
github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9gAXWo= github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9gAXWo=
github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k= github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k=
github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw= github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw=
github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ= github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ=
github.com/go-chi/chi/v5 v5.1.0 h1:acVI1TYaD+hhedDJ3r54HyA6sExp3HfXq7QWEEY/xMw= github.com/go-chi/chi/v5 v5.1.0 h1:acVI1TYaD+hhedDJ3r54HyA6sExp3HfXq7QWEEY/xMw=
github.com/go-chi/chi/v5 v5.1.0/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8= github.com/go-chi/chi/v5 v5.1.0/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
github.com/go-chi/cors v1.2.2 h1:Jmey33TE+b+rB7fT8MUy1u0I4L+NARQlK6LhzKPSyQE=
github.com/go-chi/cors v1.2.2/go.mod h1:sSbTewc+6wYHBBCW7ytsFSn836hqM7JxpglAy2Vzc58=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ= github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo= github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng= github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-sqlite3 v1.14.42 h1:MigqEP4ZmHw3aIdIT7T+9TLa90Z6smwcthx+Azv4Cgo=
github.com/mattn/go-sqlite3 v1.14.42/go.mod h1:pjEuOr8IwzLJP2MfGeTb0A35jauH+C2kbHKBr7yXKVQ=
github.com/petermattis/goid v0.0.0-20260330135022-df67b199bc81 h1:WDsQxOJDy0N1VRAjXLpi8sCEZRSGarLWQevDxpTBRrM=
github.com/petermattis/goid v0.0.0-20260330135022-df67b199bc81/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= github.com/rs/zerolog v1.35.0 h1:VD0ykx7HMiMJytqINBsKcbLS+BJ4WYjz+05us+LRTdI=
golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70= github.com/rs/zerolog v1.35.0/go.mod h1:EjML9kdfa/RMA7h/6z6pYmq1ykOuA8/mjWaEvGI+jcw=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34= github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/vektah/gqlparser/v2 v2.5.27 h1:RHPD3JOplpk5mP5JGX8RKZkt2/Vwj/PZv0HxTdwFp0s=
github.com/vektah/gqlparser/v2 v2.5.27/go.mod h1:D1/VCZtV3LPnQrcPBeR/q5jkSQIPti0uYCP/RI0gIeo=
go.mau.fi/libsignal v0.2.1 h1:vRZG4EzTn70XY6Oh/pVKrQGuMHBkAWlGRC22/85m9L0=
go.mau.fi/libsignal v0.2.1/go.mod h1:iVvjrHyfQqWajOUaMEsIfo3IqgVMrhWcPiiEzk7NgoU=
go.mau.fi/util v0.9.8 h1:+/jf8eM2dAT2wx9UidmaneH28r/CSCKCniCyby1qWz8=
go.mau.fi/util v0.9.8/go.mod h1:up/5mbzH2M1pSBNXqRxODn8dg/hEKbLJu92W4/SNAX0=
go.mau.fi/whatsmeow v0.0.0-20260427122815-7514259253a7 h1:jEOI4I7kU+MYUNI1L94rhYXhUg8N9+YUNHVY525aYTc=
go.mau.fi/whatsmeow v0.0.0-20260427122815-7514259253a7/go.mod h1:ijfkzOXauA/Vz/htXEMfOAJSUgglribW5oQeYC9tSSg=
golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI=
golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q=
golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f h1:W3F4c+6OLc6H2lb//N1q4WpJkhzJCK5J6kUi1NTVXfM=
golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f/go.mod h1:J1xhfL/vlindoeF/aINzNzt2Bket5bjo9sdOYzOsU80=
golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=
google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gorm.io/gorm v1.25.7 h1:VsD6acwRjz2zFxGO50gPO6AkNs7KKnvfzUjHQhZDz/A= gorm.io/gorm v1.25.7 h1:VsD6acwRjz2zFxGO50gPO6AkNs7KKnvfzUjHQhZDz/A=
gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8= gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE= modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE=
+332 -25
View File
@@ -2,27 +2,33 @@ package db
import ( import (
"database/sql" "database/sql"
"time"
) )
type Client struct { type Client struct {
ClientID int64 `json:"client_id"` ClientID int64 `json:"client_id"`
AccountID int64 `json:"account_id"` AccountID int64 `json:"account_id"`
Name string `json:"name"` Name string `json:"name"`
Phone string `json:"phone,omitempty"` Phone string `json:"phone,omitempty"`
Email string `json:"email,omitempty"` Email string `json:"email,omitempty"`
Address string `json:"address,omitempty"` Address string `json:"address,omitempty"`
Notes string `json:"notes,omitempty"` Notes string `json:"notes,omitempty"`
CreatedAt int64 `json:"created_at"` WhatsAppNumber string `json:"whatsapp_number,omitempty"`
WhatsAppConnected int `json:"whatsapp_connected"`
WhatsAppJID string `json:"whatsapp_jid,omitempty"`
CreatedAt int64 `json:"created_at"`
} }
type Customer struct { type Customer struct {
CustomerID int64 `json:"customer_id"` CustomerID int64 `json:"customer_id"`
ClientID int64 `json:"client_id"` ClientID int64 `json:"client_id"`
Name string `json:"name"` Name string `json:"name"`
Phone string `json:"phone,omitempty"` Phone string `json:"phone,omitempty"`
BirthDate string `json:"birth_date,omitempty"` BirthDate string `json:"birth_date,omitempty"`
Instagram string `json:"instagram,omitempty"` Instagram string `json:"instagram,omitempty"`
CreatedAt int64 `json:"created_at"` CreatedAt int64 `json:"created_at"`
WhatsAppConnected int `json:"whatsapp_connected"`
WhatsAppNumber string `json:"whatsapp_number,omitempty"`
} }
type Service struct { type Service struct {
@@ -60,8 +66,8 @@ type Payment struct {
func (c *Client) Create(db *sql.DB) error { func (c *Client) Create(db *sql.DB) error {
result, err := db.Exec( result, err := db.Exec(
"INSERT INTO clients (account_id, name, phone, email, address, notes, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)", "INSERT INTO clients (account_id, name, phone, email, address, notes, whatsapp_number, whatsapp_connected, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
c.AccountID, c.Name, c.Phone, c.Email, c.Address, c.Notes, c.CreatedAt, c.AccountID, c.Name, c.Phone, c.Email, c.Address, c.Notes, c.WhatsAppNumber, c.WhatsAppConnected, c.CreatedAt,
) )
if err != nil { if err != nil {
return err return err
@@ -76,15 +82,15 @@ func (c *Client) Create(db *sql.DB) error {
func (c *Client) Read(db *sql.DB, id int64) error { func (c *Client) Read(db *sql.DB, id int64) error {
return db.QueryRow( return db.QueryRow(
"SELECT client_id, account_id, name, COALESCE(phone,''), COALESCE(email,''), COALESCE(address,''), COALESCE(notes,''), created_at FROM clients WHERE client_id = ?", "SELECT client_id, account_id, name, COALESCE(phone,''), COALESCE(email,''), COALESCE(address,''), COALESCE(notes,''), COALESCE(whatsapp_number,''), COALESCE(whatsapp_connected,0), COALESCE(whatsapp_jid,''), created_at FROM clients WHERE client_id = ?",
id, id,
).Scan(&c.ClientID, &c.AccountID, &c.Name, &c.Phone, &c.Email, &c.Address, &c.Notes, &c.CreatedAt) ).Scan(&c.ClientID, &c.AccountID, &c.Name, &c.Phone, &c.Email, &c.Address, &c.Notes, &c.WhatsAppNumber, &c.WhatsAppConnected, &c.WhatsAppJID, &c.CreatedAt)
} }
func (c *Client) Update(db *sql.DB) error { func (c *Client) Update(db *sql.DB) error {
_, err := db.Exec( _, err := db.Exec(
"UPDATE clients SET name = ?, phone = ?, email = ?, address = ?, notes = ? WHERE client_id = ? AND account_id = ?", "UPDATE clients SET name = ?, phone = ?, email = ?, address = ?, notes = ?, whatsapp_number = ?, whatsapp_connected = ?, whatsapp_jid = ? WHERE client_id = ? AND account_id = ?",
c.Name, c.Phone, c.Email, c.Address, c.Notes, c.ClientID, c.AccountID, c.Name, c.Phone, c.Email, c.Address, c.Notes, c.WhatsAppNumber, c.WhatsAppConnected, c.WhatsAppJID, c.ClientID, c.AccountID,
) )
return err return err
} }
@@ -95,7 +101,7 @@ func (c *Client) Delete(db *sql.DB) error {
} }
func ListClients(db *sql.DB, accountID int64, limit, offset int) ([]Client, error) { func ListClients(db *sql.DB, accountID int64, limit, offset int) ([]Client, error) {
query := "SELECT client_id, account_id, name, COALESCE(phone,''), COALESCE(email,''), COALESCE(address,''), COALESCE(notes,''), created_at FROM clients" query := "SELECT client_id, account_id, name, COALESCE(phone,''), COALESCE(email,''), COALESCE(address,''), COALESCE(notes,''), COALESCE(whatsapp_number,''), COALESCE(whatsapp_connected,0), COALESCE(whatsapp_jid,''), created_at FROM clients"
args := []interface{}{} args := []interface{}{}
if accountID > 0 { if accountID > 0 {
query += " WHERE account_id = ?" query += " WHERE account_id = ?"
@@ -113,7 +119,7 @@ func ListClients(db *sql.DB, accountID int64, limit, offset int) ([]Client, erro
var clients []Client var clients []Client
for rows.Next() { for rows.Next() {
var c Client var c Client
if err := rows.Scan(&c.ClientID, &c.AccountID, &c.Name, &c.Phone, &c.Email, &c.Address, &c.Notes, &c.CreatedAt); err != nil { if err := rows.Scan(&c.ClientID, &c.AccountID, &c.Name, &c.Phone, &c.Email, &c.Address, &c.Notes, &c.WhatsAppNumber, &c.WhatsAppConnected, &c.WhatsAppJID, &c.CreatedAt); err != nil {
return nil, err return nil, err
} }
clients = append(clients, c) clients = append(clients, c)
@@ -124,9 +130,9 @@ func ListClients(db *sql.DB, accountID int64, limit, offset int) ([]Client, erro
func GetClientByID(db *sql.DB, accountID, id int64) (*Client, error) { func GetClientByID(db *sql.DB, accountID, id int64) (*Client, error) {
var c Client var c Client
err := db.QueryRow( err := db.QueryRow(
"SELECT client_id, account_id, name, COALESCE(phone,''), COALESCE(email,''), COALESCE(address,''), COALESCE(notes,''), created_at FROM clients WHERE client_id = ? AND account_id = ?", "SELECT client_id, account_id, name, COALESCE(phone,''), COALESCE(email,''), COALESCE(address,''), COALESCE(notes,''), COALESCE(whatsapp_number,''), COALESCE(whatsapp_connected,0), COALESCE(whatsapp_jid,''), created_at FROM clients WHERE client_id = ? AND account_id = ?",
id, accountID, id, accountID,
).Scan(&c.ClientID, &c.AccountID, &c.Name, &c.Phone, &c.Email, &c.Address, &c.Notes, &c.CreatedAt) ).Scan(&c.ClientID, &c.AccountID, &c.Name, &c.Phone, &c.Email, &c.Address, &c.Notes, &c.WhatsAppNumber, &c.WhatsAppConnected, &c.WhatsAppJID, &c.CreatedAt)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -340,6 +346,283 @@ func boolToInt(b bool) int {
return 0 return 0
} }
// ---------------------------------------------------------------------------
// Lead
// ---------------------------------------------------------------------------
type Lead struct {
LeadID int64 `json:"lead_id"`
ClientID int64 `json:"client_id"`
Name string `json:"name"`
PhoneRaw string `json:"phone_raw"`
PhoneNormalized string `json:"phone_normalized"`
ServiceInterest string `json:"service_interest"`
Status string `json:"status"`
NeedsReview bool `json:"needs_review"`
AppointmentDate string `json:"appointment_date,omitempty"`
AppointmentTime string `json:"appointment_time,omitempty"`
PaymentStatus string `json:"payment_status"`
PaymentAmount float64 `json:"payment_amount,omitempty"`
PaymentDate string `json:"payment_date,omitempty"`
CreatedAt int64 `json:"created_at"`
LastContactAt int64 `json:"last_contact_at"`
}
func CreateLead(db *sql.DB, l *Lead) error {
now := time.Now().Unix()
l.CreatedAt = now
l.LastContactAt = now
result, err := db.Exec(
`INSERT INTO leads
(client_id, name, phone_raw, phone_normalized, service_interest, status, needs_review,
appointment_date, appointment_time, payment_status, payment_amount, payment_date, created_at, last_contact_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
l.ClientID, l.Name, l.PhoneRaw, l.PhoneNormalized, l.ServiceInterest, l.Status, boolToInt(l.NeedsReview),
l.AppointmentDate, l.AppointmentTime, l.PaymentStatus, l.PaymentAmount, l.PaymentDate,
l.CreatedAt, l.LastContactAt,
)
if err != nil {
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
l.LeadID = id
return nil
}
func GetLeadByPhone(db *sql.DB, clientID int64, phoneNormalized string) (*Lead, error) {
var l Lead
var needsReview int
err := db.QueryRow(
`SELECT lead_id, client_id, name, phone_raw, phone_normalized, service_interest, status, needs_review,
COALESCE(appointment_date,''), COALESCE(appointment_time,''), payment_status,
COALESCE(payment_amount,0), COALESCE(payment_date,''), created_at, last_contact_at
FROM leads WHERE client_id = ? AND phone_normalized = ?`,
clientID, phoneNormalized,
).Scan(
&l.LeadID, &l.ClientID, &l.Name, &l.PhoneRaw, &l.PhoneNormalized,
&l.ServiceInterest, &l.Status, &needsReview,
&l.AppointmentDate, &l.AppointmentTime, &l.PaymentStatus,
&l.PaymentAmount, &l.PaymentDate, &l.CreatedAt, &l.LastContactAt,
)
if err != nil {
return nil, err
}
l.NeedsReview = needsReview == 1
return &l, nil
}
func GetLeadByID(db *sql.DB, clientID, leadID int64) (*Lead, error) {
var l Lead
var needsReview int
err := db.QueryRow(
`SELECT lead_id, client_id, name, phone_raw, phone_normalized, service_interest, status, needs_review,
COALESCE(appointment_date,''), COALESCE(appointment_time,''), payment_status,
COALESCE(payment_amount,0), COALESCE(payment_date,''), created_at, last_contact_at
FROM leads WHERE lead_id = ? AND client_id = ?`,
leadID, clientID,
).Scan(
&l.LeadID, &l.ClientID, &l.Name, &l.PhoneRaw, &l.PhoneNormalized,
&l.ServiceInterest, &l.Status, &needsReview,
&l.AppointmentDate, &l.AppointmentTime, &l.PaymentStatus,
&l.PaymentAmount, &l.PaymentDate, &l.CreatedAt, &l.LastContactAt,
)
if err != nil {
return nil, err
}
l.NeedsReview = needsReview == 1
return &l, nil
}
func TouchLeadContact(db *sql.DB, leadID int64) error {
_, err := db.Exec(
"UPDATE leads SET last_contact_at = ? WHERE lead_id = ?",
time.Now().Unix(), leadID,
)
return err
}
func UpdateLead(db *sql.DB, l *Lead) error {
_, err := db.Exec(
`UPDATE leads SET name=?, service_interest=?, status=?, needs_review=?,
appointment_date=?, appointment_time=?, payment_status=?, payment_amount=?, payment_date=?
WHERE lead_id=? AND client_id=?`,
l.Name, l.ServiceInterest, l.Status, boolToInt(l.NeedsReview),
l.AppointmentDate, l.AppointmentTime, l.PaymentStatus, l.PaymentAmount, l.PaymentDate,
l.LeadID, l.ClientID,
)
return err
}
func ListLeadsForReview(db *sql.DB, clientID int64, limit, offset int) ([]Lead, error) {
rows, err := db.Query(
`SELECT lead_id, client_id, name, phone_raw, phone_normalized, service_interest, status, needs_review,
COALESCE(appointment_date,''), COALESCE(appointment_time,''), payment_status,
COALESCE(payment_amount,0), COALESCE(payment_date,''), created_at, last_contact_at
FROM leads WHERE client_id = ? AND needs_review = 1
ORDER BY created_at DESC LIMIT ? OFFSET ?`,
clientID, limit, offset,
)
if err != nil {
return nil, err
}
defer rows.Close()
return scanLeads(rows)
}
func ListAllLeads(db *sql.DB, clientID int64, limit, offset int) ([]Lead, error) {
rows, err := db.Query(
`SELECT lead_id, client_id, name, phone_raw, phone_normalized, service_interest, status, needs_review,
COALESCE(appointment_date,''), COALESCE(appointment_time,''), payment_status,
COALESCE(payment_amount,0), COALESCE(payment_date,''), created_at, last_contact_at
FROM leads WHERE client_id = ?
ORDER BY created_at DESC LIMIT ? OFFSET ?`,
clientID, limit, offset,
)
if err != nil {
return nil, err
}
defer rows.Close()
return scanLeads(rows)
}
func CountLeadsNeedingReview(db *sql.DB, clientID int64) (int, error) {
var n int
err := db.QueryRow(
"SELECT COUNT(*) FROM leads WHERE client_id = ? AND needs_review = 1",
clientID,
).Scan(&n)
return n, err
}
func scanLeads(rows *sql.Rows) ([]Lead, error) {
var leads []Lead
for rows.Next() {
var l Lead
var needsReview int
if err := rows.Scan(
&l.LeadID, &l.ClientID, &l.Name, &l.PhoneRaw, &l.PhoneNormalized,
&l.ServiceInterest, &l.Status, &needsReview,
&l.AppointmentDate, &l.AppointmentTime, &l.PaymentStatus,
&l.PaymentAmount, &l.PaymentDate, &l.CreatedAt, &l.LastContactAt,
); err != nil {
return nil, err
}
l.NeedsReview = needsReview == 1
leads = append(leads, l)
}
return leads, rows.Err()
}
// ---------------------------------------------------------------------------
// ServiceKeyword
// ---------------------------------------------------------------------------
type ServiceKeyword struct {
KeywordID int64 `json:"keyword_id"`
ClientID int64 `json:"client_id"`
ServiceName string `json:"service_name"`
Keyword string `json:"keyword"`
CreatedAt int64 `json:"created_at"`
}
func ListServiceKeywords(db *sql.DB, clientID int64) ([]ServiceKeyword, error) {
rows, err := db.Query(
"SELECT keyword_id, client_id, service_name, keyword, created_at FROM service_keywords WHERE client_id = ? ORDER BY service_name, keyword",
clientID,
)
if err != nil {
return nil, err
}
defer rows.Close()
var kws []ServiceKeyword
for rows.Next() {
var kw ServiceKeyword
if err := rows.Scan(&kw.KeywordID, &kw.ClientID, &kw.ServiceName, &kw.Keyword, &kw.CreatedAt); err != nil {
return nil, err
}
kws = append(kws, kw)
}
return kws, rows.Err()
}
func LoadKeywordMapping(db *sql.DB, clientID int64) (map[string]string, error) {
kws, err := ListServiceKeywords(db, clientID)
if err != nil {
return nil, err
}
m := make(map[string]string, len(kws))
for _, kw := range kws {
m[kw.Keyword] = kw.ServiceName
}
return m, nil
}
func AddServiceKeyword(db *sql.DB, clientID int64, serviceName, keyword string) error {
_, err := db.Exec(
"INSERT INTO service_keywords (client_id, service_name, keyword, created_at) VALUES (?, ?, ?, ?)",
clientID, serviceName, keyword, time.Now().Unix(),
)
return err
}
func DeleteServiceKeyword(db *sql.DB, clientID, keywordID int64) error {
_, err := db.Exec(
"DELETE FROM service_keywords WHERE keyword_id = ? AND client_id = ?",
keywordID, clientID,
)
return err
}
// ---------------------------------------------------------------------------
// LeadStatus
// ---------------------------------------------------------------------------
type LeadStatus struct {
StatusID int64 `json:"status_id"`
ClientID int64 `json:"client_id"`
StatusName string `json:"status_name"`
CreatedAt int64 `json:"created_at"`
}
func ListLeadStatuses(db *sql.DB, clientID int64) ([]LeadStatus, error) {
rows, err := db.Query(
"SELECT status_id, client_id, status_name, created_at FROM lead_statuses WHERE client_id = ? ORDER BY created_at",
clientID,
)
if err != nil {
return nil, err
}
defer rows.Close()
var statuses []LeadStatus
for rows.Next() {
var s LeadStatus
if err := rows.Scan(&s.StatusID, &s.ClientID, &s.StatusName, &s.CreatedAt); err != nil {
return nil, err
}
statuses = append(statuses, s)
}
return statuses, rows.Err()
}
func AddLeadStatus(db *sql.DB, clientID int64, statusName string) error {
_, err := db.Exec(
"INSERT INTO lead_statuses (client_id, status_name, created_at) VALUES (?, ?, ?)",
clientID, statusName, time.Now().Unix(),
)
return err
}
func DeleteLeadStatus(db *sql.DB, clientID, statusID int64) error {
_, err := db.Exec(
"DELETE FROM lead_statuses WHERE status_id = ? AND client_id = ?",
statusID, clientID,
)
return err
}
type Question struct { type Question struct {
QuestionID int64 `json:"question_id"` QuestionID int64 `json:"question_id"`
ClientID int64 `json:"client_id"` ClientID int64 `json:"client_id"`
@@ -495,3 +778,27 @@ func ListAnswersWithDetails(db *sql.DB, accountID, questionID int64, limit, offs
} }
return answers, rows.Err() return answers, rows.Err()
} }
// ---------------------------------------------------------------------------
// Processed Messages (dedup)
// ---------------------------------------------------------------------------
func IsMessageProcessed(db *sql.DB, clientID int64, messageID string) (bool, error) {
var count int
err := db.QueryRow(
`SELECT COUNT(*) FROM processed_messages WHERE client_id = ? AND message_id = ?`,
clientID, messageID,
).Scan(&count)
if err != nil {
return false, err
}
return count > 0, nil
}
func RecordProcessedMessage(db *sql.DB, clientID int64, messageID string) error {
_, err := db.Exec(
`INSERT OR IGNORE INTO processed_messages (message_id, client_id) VALUES (?, ?)`,
messageID, clientID,
)
return err
}
+90
View File
@@ -0,0 +1,90 @@
package db
import (
"os"
"testing"
)
func TestClientWhatsAppColumns(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
db, err := Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer db.Close()
client := Client{
AccountID: 1,
Name: "Test Client",
Phone: "+5521987654321",
WhatsAppNumber: "+5521987654321",
WhatsAppConnected: 1,
CreatedAt: 1234567890,
}
if err := client.Create(db); err != nil {
t.Fatalf("failed to create client: %v", err)
}
if client.ClientID == 0 {
t.Error("expected client_id to be set after create")
}
var found Client
if err := found.Read(db, client.ClientID); err != nil {
t.Fatalf("failed to read client: %v", err)
}
if found.WhatsAppNumber != "+5521987654321" {
t.Errorf("expected whatsapp_number to be +5521987654321, got %s", found.WhatsAppNumber)
}
if found.WhatsAppConnected != 1 {
t.Errorf("expected whatsapp_connected to be 1, got %d", found.WhatsAppConnected)
}
}
func TestClientWhatsAppColumnsNullable(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
db, err := Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer db.Close()
client := Client{
AccountID: 1,
Name: "Test Client",
Phone: "+5521987654321",
CreatedAt: 1234567890,
}
if err := client.Create(db); err != nil {
t.Fatalf("failed to create client: %v", err)
}
var found Client
if err := found.Read(db, client.ClientID); err != nil {
t.Fatalf("failed to read client: %v", err)
}
if found.WhatsAppNumber != "" {
t.Errorf("expected whatsapp_number to be empty, got %s", found.WhatsAppNumber)
}
if found.WhatsAppConnected != 0 {
t.Errorf("expected whatsapp_connected to default to 0, got %d", found.WhatsAppConnected)
}
}
+238 -3
View File
@@ -3,9 +3,11 @@ package db
import ( import (
"database/sql" "database/sql"
"fmt" "fmt"
"golang.org/x/text/encoding/charmap"
"os" "os"
"path/filepath" "path/filepath"
"strings" "strings"
"unicode/utf8"
_ "github.com/glebarez/sqlite" _ "github.com/glebarez/sqlite"
) )
@@ -34,7 +36,10 @@ CREATE TABLE IF NOT EXISTS clients (
email TEXT, email TEXT,
address TEXT, address TEXT,
notes TEXT, notes TEXT,
whatsapp_number TEXT,
whatsapp_connected INTEGER DEFAULT 0,
created_at INTEGER NOT NULL, created_at INTEGER NOT NULL,
whatsapp_jid TEXT,
FOREIGN KEY (account_id) REFERENCES accounts(account_id) FOREIGN KEY (account_id) REFERENCES accounts(account_id)
); );
@@ -113,6 +118,47 @@ CREATE TABLE IF NOT EXISTS answers (
FOREIGN KEY (question_id) REFERENCES questions(question_id) FOREIGN KEY (question_id) REFERENCES questions(question_id)
); );
CREATE TABLE IF NOT EXISTS leads (
lead_id INTEGER PRIMARY KEY AUTOINCREMENT,
client_id INTEGER NOT NULL,
name TEXT NOT NULL DEFAULT '',
phone_raw TEXT NOT NULL DEFAULT '',
phone_normalized TEXT NOT NULL DEFAULT '',
service_interest TEXT NOT NULL DEFAULT 'Não especificou',
status TEXT NOT NULL DEFAULT 'Não agendou',
needs_review INTEGER NOT NULL DEFAULT 1,
appointment_date TEXT,
appointment_time TEXT,
payment_status TEXT NOT NULL DEFAULT 'Não pago',
payment_amount REAL,
payment_date TEXT,
created_at INTEGER NOT NULL,
last_contact_at INTEGER NOT NULL,
FOREIGN KEY (client_id) REFERENCES clients(client_id)
);
CREATE TABLE IF NOT EXISTS processed_messages (
message_id TEXT NOT NULL,
client_id INTEGER NOT NULL,
PRIMARY KEY (message_id, client_id)
);
CREATE TABLE IF NOT EXISTS service_keywords (
keyword_id INTEGER PRIMARY KEY AUTOINCREMENT,
client_id INTEGER NOT NULL,
service_name TEXT NOT NULL,
keyword TEXT NOT NULL,
created_at INTEGER NOT NULL,
FOREIGN KEY (client_id) REFERENCES clients(client_id)
);
CREATE TABLE IF NOT EXISTS lead_statuses (
status_id INTEGER PRIMARY KEY AUTOINCREMENT,
client_id INTEGER NOT NULL,
status_name TEXT NOT NULL,
created_at INTEGER NOT NULL,
FOREIGN KEY (client_id) REFERENCES clients(client_id)
);
` `
@@ -124,37 +170,226 @@ func Init(path string) (*sql.DB, error) {
} }
dir := filepath.Dir(dbPath) dir := filepath.Dir(dbPath)
fmt.Println("db.Init: data dir", dir)
if err := os.MkdirAll(dir, 0755); err != nil { if err := os.MkdirAll(dir, 0755); err != nil {
return nil, fmt.Errorf("failed to create data directory: %w", err) return nil, fmt.Errorf("failed to create data directory: %w", err)
} }
database, err := sql.Open("sqlite", dbPath) dsn := fmt.Sprintf("file:%s?mode=rwc&_pragma=encoding(UTF8)", filepath.ToSlash(dbPath))
fmt.Println("db.Init: opening database", dbPath)
database, err := sql.Open("sqlite", dsn)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to open database: %w", err) return nil, fmt.Errorf("failed to open database: %w", err)
} }
fmt.Println("db.Init: ping database")
if err := database.Ping(); err != nil { if err := database.Ping(); err != nil {
return nil, fmt.Errorf("failed to ping database: %w", err) return nil, fmt.Errorf("failed to ping database: %w", err)
} }
fmt.Println("db.Init: executing schema")
if _, err := database.Exec(schema); err != nil { if _, err := database.Exec(schema); err != nil {
return nil, fmt.Errorf("failed to create schema: %w", err) return nil, fmt.Errorf("failed to create schema: %w", err)
} }
fmt.Println("db.Init: running migrate")
if err := migrate(database); err != nil { if err := migrate(database); err != nil {
return nil, fmt.Errorf("failed to migrate: %w", err) return nil, fmt.Errorf("failed to migrate: %w", err)
} }
fmt.Println("db.Init: migration complete")
return database, nil return database, nil
} }
func migrate(db *sql.DB) error { func migrate(db *sql.DB) error {
fmt.Println("db.migrate: add account_id column")
_, err := db.Exec("ALTER TABLE clients ADD COLUMN account_id INTEGER") _, err := db.Exec("ALTER TABLE clients ADD COLUMN account_id INTEGER")
if err != nil { if err != nil {
if strings.Contains(err.Error(), "duplicate column name") { if !strings.Contains(err.Error(), "duplicate column name") {
return nil return err
} }
}
fmt.Println("db.migrate: add whatsapp_number column")
_, err = db.Exec("ALTER TABLE clients ADD COLUMN whatsapp_number TEXT")
if err != nil {
if !strings.Contains(err.Error(), "duplicate column name") {
return err
}
}
fmt.Println("db.migrate: add whatsapp_connected column")
_, err = db.Exec("ALTER TABLE clients ADD COLUMN whatsapp_connected INTEGER DEFAULT 0")
if err != nil {
if !strings.Contains(err.Error(), "duplicate column name") {
return err
}
}
fmt.Println("db.migrate: add whatsapp_jid column")
_, err = db.Exec("ALTER TABLE clients ADD COLUMN whatsapp_jid TEXT")
if err != nil {
if !strings.Contains(err.Error(), "duplicate column name") {
return err
}
}
fmt.Println("db.migrate: seeding default keywords")
// Seed default service keywords per client if none exist yet.
if err := seedDefaultKeywords(db); err != nil {
return err return err
} }
fmt.Println("db.migrate: seeding default statuses")
// Seed default lead statuses per client if none exist yet.
if err := seedDefaultStatuses(db); err != nil {
return err
}
fmt.Println("db.migrate: sanitizing encodings")
// Sanitize mojibake from legacy data: decode Latin1->UTF8
if err := sanitizeEncoding(db); err != nil {
return err
}
return nil
}
func seedDefaultKeywords(db *sql.DB) error {
fmt.Println("seedDefaultKeywords: querying clients")
// Fetch all client IDs.
rows, err := db.Query("SELECT client_id FROM clients")
if err != nil {
return nil // table may not exist yet on very first run — ignore
}
defer rows.Close()
defaults := map[string][]string{
"Head Spa": {"head spa", "head-spa", "headspa"},
"Massagem completa": {"massagem", "massagem completa"},
"Drenagem linfatica": {"drenagem", "linfática", "linfahtica", "drenagem linfatica"},
"Hydra Boost": {"hydra", "hydra boost", "hydraboost"},
"Design Henna": {"henna", "design henna"},
"Masculino": {"masculino", "masc"},
"Não especificou": {"nao especificou", "não especificou"},
}
now := int64(0)
for rows.Next() {
var clientID int64
if err := rows.Scan(&clientID); err != nil {
continue
}
fmt.Println("seedDefaultKeywords: client", clientID)
var count int
db.QueryRow("SELECT COUNT(*) FROM service_keywords WHERE client_id = ?", clientID).Scan(&count)
if count > 0 {
continue
}
for svc, keywords := range defaults {
for _, kw := range keywords {
db.Exec(
"INSERT INTO service_keywords (client_id, service_name, keyword, created_at) VALUES (?, ?, ?, ?)",
clientID, svc, kw, now,
)
}
}
}
return nil return nil
} }
func seedDefaultStatuses(db *sql.DB) error {
rows, err := db.Query("SELECT client_id FROM clients")
if err != nil {
return nil
}
defer rows.Close()
defaults := []string{"Não agendou", "Agendou", "Sem retorno / não evoluiu"}
now := int64(0)
for rows.Next() {
var clientID int64
if err := rows.Scan(&clientID); err != nil {
continue
}
var count int
db.QueryRow("SELECT COUNT(*) FROM lead_statuses WHERE client_id = ?", clientID).Scan(&count)
if count > 0 {
continue
}
for _, s := range defaults {
db.Exec(
"INSERT INTO lead_statuses (client_id, status_name, created_at) VALUES (?, ?, ?)",
clientID, s, now,
)
}
}
return nil
}
func sanitizeEncoding(db *sql.DB) error {
type statusRow struct {
id int64
name string
created int64
}
type keywordRow struct {
id int64
keyword string
created int64
}
// Read all statuses first, then update to avoid SQLite read/write deadlock.
var statuses []statusRow
if rows, err := db.Query("SELECT status_id, status_name, created_at FROM lead_statuses"); err == nil {
for rows.Next() {
var r statusRow
if err := rows.Scan(&r.id, &r.name, &r.created); err == nil && r.created != 0 {
statuses = append(statuses, r)
}
}
rows.Close()
}
for _, r := range statuses {
cleaned := decodeLatin1(r.name)
if cleaned != r.name {
db.Exec("UPDATE lead_statuses SET status_name = ? WHERE status_id = ?", cleaned, r.id)
}
}
// Read all keywords first, then update.
var keywords []keywordRow
if rows2, err := db.Query("SELECT keyword_id, keyword, created_at FROM service_keywords"); err == nil {
for rows2.Next() {
var r keywordRow
if err := rows2.Scan(&r.id, &r.keyword, &r.created); err == nil && r.created != 0 {
keywords = append(keywords, r)
}
}
rows2.Close()
}
for _, r := range keywords {
cleaned := decodeLatin1(r.keyword)
if cleaned != r.keyword {
db.Exec("UPDATE service_keywords SET keyword = ? WHERE keyword_id = ?", cleaned, r.id)
}
}
return nil
}
func decodeLatin1(value string) string {
if utf8.ValidString(value) {
return value
}
dec := charmap.ISO8859_1.NewDecoder()
cleaned := value
for {
next, err := dec.String(cleaned)
if err != nil || next == cleaned {
return cleaned
}
cleaned = next
}
}
+195 -104
View File
@@ -9,8 +9,11 @@ import (
"golang.org/x/crypto/bcrypt" "golang.org/x/crypto/bcrypt"
) )
func SignupPage(w http.ResponseWriter, r *http.Request) { // package-level globals kept for existing tests; App methods use a.DB directly.
w.Header().Set("Content-Type", "text/html") var DB *sql.DB
func (a *App) SignupPage(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html> w.Write([]byte(`<!DOCTYPE html>
<html lang="en"> <html lang="en">
<head> <head>
@@ -30,7 +33,7 @@ func SignupPage(w http.ResponseWriter, r *http.Request) {
</html>`)) </html>`))
} }
func Signup(w http.ResponseWriter, r *http.Request) { func (a *App) Signup(w http.ResponseWriter, r *http.Request) {
r.ParseForm() r.ParseForm()
email := r.FormValue("email") email := r.FormValue("email")
name := r.FormValue("name") name := r.FormValue("name")
@@ -47,21 +50,17 @@ func Signup(w http.ResponseWriter, r *http.Request) {
return return
} }
account := struct { // Use a transaction so account + client + session are atomic.
Email string tx, err := a.DB.Begin()
Name string if err != nil {
Password string http.Error(w, "Failed to start transaction", http.StatusInternalServerError)
CreatedAt int64 return
}{
Email: email,
Name: name,
Password: string(hashedPassword),
CreatedAt: time.Now().Unix(),
} }
defer tx.Rollback()
_, err = DB.Exec( _, err = tx.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)", "INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
account.Email, account.Name, account.Password, account.CreatedAt, email, name, string(hashedPassword), time.Now().Unix(),
) )
if err != nil { if err != nil {
http.Error(w, "Email already exists", http.StatusBadRequest) http.Error(w, "Email already exists", http.StatusBadRequest)
@@ -69,45 +68,40 @@ func Signup(w http.ResponseWriter, r *http.Request) {
} }
var accountID int64 var accountID int64
err = DB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", email).Scan(&accountID) if err = tx.QueryRow("SELECT account_id FROM accounts WHERE email = ?", email).Scan(&accountID); err != nil {
if err != nil {
http.Error(w, "Failed to create account", http.StatusInternalServerError) http.Error(w, "Failed to create account", http.StatusInternalServerError)
return return
} }
client := struct { if _, err = tx.Exec(
AccountID int64
Name string
CreatedAt int64
}{
AccountID: accountID,
Name: name,
CreatedAt: time.Now().Unix(),
}
_, err = DB.Exec(
"INSERT INTO clients (account_id, name, created_at) VALUES (?, ?, ?)", "INSERT INTO clients (account_id, name, created_at) VALUES (?, ?, ?)",
client.AccountID, client.Name, client.CreatedAt, accountID, name, time.Now().Unix(),
) ); err != nil {
if err != nil {
http.Error(w, "Failed to create client", http.StatusInternalServerError) http.Error(w, "Failed to create client", http.StatusInternalServerError)
return return
} }
sessionID := generateSessionID() sessionID := generateSessionID()
expires := time.Now().Add(24 * time.Hour).Unix() expires := time.Now().Add(24 * time.Hour).Unix()
if _, err = tx.Exec(
_, err = DB.Exec("INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)", sessionID, accountID, expires) "INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
if err != nil { sessionID, accountID, expires,
); err != nil {
http.Error(w, "Failed to create session", http.StatusInternalServerError) http.Error(w, "Failed to create session", http.StatusInternalServerError)
return return
} }
if err = tx.Commit(); err != nil {
http.Error(w, "Failed to commit signup", http.StatusInternalServerError)
return
}
http.SetCookie(w, &http.Cookie{Name: "session", Value: sessionID, Path: "/"}) http.SetCookie(w, &http.Cookie{Name: "session", Value: sessionID, Path: "/"})
http.Redirect(w, r, "/", http.StatusFound) http.Redirect(w, r, "/", http.StatusFound)
} }
func LoginPage(w http.ResponseWriter, r *http.Request) { func (a *App) LoginPage(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html> w.Write([]byte(`<!DOCTYPE html>
<html lang="en"> <html lang="en">
<head> <head>
@@ -126,16 +120,14 @@ func LoginPage(w http.ResponseWriter, r *http.Request) {
</html>`)) </html>`))
} }
var DB *sql.DB func (a *App) Login(w http.ResponseWriter, r *http.Request) {
func Login(w http.ResponseWriter, r *http.Request) {
r.ParseForm() r.ParseForm()
email := r.FormValue("email") email := r.FormValue("email")
password := r.FormValue("password") password := r.FormValue("password")
var accountID int64 var accountID int64
var hashedPassword string var hashedPassword string
err := DB.QueryRow("SELECT account_id, password FROM accounts WHERE email = ?", email).Scan(&accountID, &hashedPassword) err := a.DB.QueryRow("SELECT account_id, password FROM accounts WHERE email = ?", email).Scan(&accountID, &hashedPassword)
if err != nil { if err != nil {
http.Error(w, "Invalid credentials", http.StatusUnauthorized) http.Error(w, "Invalid credentials", http.StatusUnauthorized)
return return
@@ -149,7 +141,7 @@ func Login(w http.ResponseWriter, r *http.Request) {
sessionID := generateSessionID() sessionID := generateSessionID()
expires := time.Now().Add(24 * time.Hour).Unix() expires := time.Now().Add(24 * time.Hour).Unix()
_, err = DB.Exec("INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)", sessionID, accountID, expires) _, err = a.DB.Exec("INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)", sessionID, accountID, expires)
if err != nil { if err != nil {
http.Error(w, "Failed to create session", http.StatusInternalServerError) http.Error(w, "Failed to create session", http.StatusInternalServerError)
return return
@@ -159,16 +151,152 @@ func Login(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "/", http.StatusFound) http.Redirect(w, r, "/", http.StatusFound)
} }
func Logout(w http.ResponseWriter, r *http.Request) { func (a *App) Logout(w http.ResponseWriter, r *http.Request) {
cookie, err := r.Cookie("session") cookie, err := r.Cookie("session")
if err == nil { if err == nil {
DB.Exec("DELETE FROM sessions WHERE session_id = ?", cookie.Value) a.DB.Exec("DELETE FROM sessions WHERE session_id = ?", cookie.Value)
} }
http.SetCookie(w, &http.Cookie{Name: "session", Value: "", Path: "/", MaxAge: -1}) http.SetCookie(w, &http.Cookie{Name: "session", Value: "", Path: "/", MaxAge: -1})
http.Redirect(w, r, "/auth/login", http.StatusFound) http.Redirect(w, r, "/auth/login", http.StatusFound)
} }
func (a *App) AccountPage(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
var name, email string
err := a.DB.QueryRow("SELECT name, email FROM accounts WHERE account_id = ?", accountID).Scan(&name, &email)
if err != nil {
http.Error(w, "Account not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><html><head><title>Account</title></head><body><h1>Account Settings</h1><form method="POST" action="/auth/account">
<p>Name: <input type="text" name="name" value="` + name + `"></p>
<p>Email: <input type="email" value="` + email + `" disabled></p>
<p>New Password: <input type="password" name="password" placeholder="Leave blank to keep current"></p>
<button type="submit">Update</button>
</form>
<a href="/">Back to Dashboard</a></body></html>`))
}
func (a *App) UpdateAccount(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
r.ParseForm()
name := r.FormValue("name")
password := r.FormValue("password")
if name != "" {
a.DB.Exec("UPDATE accounts SET name = ? WHERE account_id = ?", name, accountID)
}
if password != "" {
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err == nil {
a.DB.Exec("UPDATE accounts SET password = ? WHERE account_id = ?", string(hashedPassword), accountID)
}
}
http.Redirect(w, r, "/auth/account", http.StatusFound)
}
// --- session helpers on App --------------------------------------------------
func (a *App) getSession(r *http.Request) (int64, error) {
cookie, err := r.Cookie("session")
if err != nil {
return 0, err
}
var accountID int64
err = a.DB.QueryRow(
"SELECT account_id FROM sessions WHERE session_id = ? AND expires > ?",
cookie.Value, time.Now().Unix(),
).Scan(&accountID)
return accountID, err
}
func (a *App) GetAccountID(r *http.Request) (int64, error) {
return a.getSession(r)
}
func (a *App) requireAuth(w http.ResponseWriter, r *http.Request) (int64, bool) {
accountID, err := a.getSession(r)
if err != nil {
if isAPIRequest(r) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(`{"error":"unauthorized"}`))
} else {
http.Redirect(w, r, "/auth/login", http.StatusFound)
}
return 0, false
}
return accountID, true
}
func (a *App) clientIDForAccount(accountID int64) int64 {
var clientID int64
a.DB.QueryRow("SELECT client_id FROM clients WHERE account_id = ? LIMIT 1", accountID).Scan(&clientID)
return clientID
}
// --- package-level shims kept for existing tests that set the global DB ------
func GetAccountID(r *http.Request) (int64, error) {
return getSession(r)
}
func getSession(r *http.Request) (int64, error) {
cookie, err := r.Cookie("session")
if err != nil {
return 0, err
}
var accountID int64
err = DB.QueryRow(
"SELECT account_id FROM sessions WHERE session_id = ? AND expires > ?",
cookie.Value, time.Now().Unix(),
).Scan(&accountID)
return accountID, err
}
func requireAuth(w http.ResponseWriter, r *http.Request) (int64, bool) {
accountID, err := getSession(r)
if err != nil {
if isAPIRequest(r) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(`{"error":"unauthorized"}`))
} else {
http.Redirect(w, r, "/auth/login", http.StatusFound)
}
return 0, false
}
return accountID, true
}
func clientIDForAccount(accountID int64) int64 {
var clientID int64
DB.QueryRow("SELECT client_id FROM clients WHERE account_id = ? LIMIT 1", accountID).Scan(&clientID)
return clientID
}
func isAPIRequest(r *http.Request) bool {
accept := r.Header.Get("Accept")
return accept == "application/json" || r.URL.Path == "/leads/qr"
}
func SetupAuthHandlers(db *sql.DB) {
DB = db
chi.RegisterMethod("GET")
}
// --- session ID generation ---------------------------------------------------
func generateSessionID() string { func generateSessionID() string {
return time.Now().Format("20060102150405") + "-" + randomString(32) return time.Now().Format("20060102150405") + "-" + randomString(32)
} }
@@ -182,78 +310,41 @@ func randomString(n int) string {
return string(b) return string(b)
} }
func getSession(r *http.Request) (int64, error) { // SignupPage, Signup, LoginPage, Login, Logout, AccountPage, UpdateAccount
cookie, err := r.Cookie("session") // are also kept as package-level functions for backward compat with test
if err != nil { // setups that call handlers.Signup directly. They delegate to the globals.
return 0, err
}
var accountID int64 func SignupPage(w http.ResponseWriter, r *http.Request) {
err = DB.QueryRow("SELECT account_id FROM sessions WHERE session_id = ? AND expires > ?", cookie.Value, time.Now().Unix()).Scan(&accountID) a := &App{DB: DB, WAConnector: WAConnector}
return accountID, err a.SignupPage(w, r)
} }
func GetAccountID(r *http.Request) (int64, error) { func Signup(w http.ResponseWriter, r *http.Request) {
return getSession(r) a := &App{DB: DB, WAConnector: WAConnector}
a.Signup(w, r)
} }
func requireAuth(w http.ResponseWriter, r *http.Request) (int64, bool) { func LoginPage(w http.ResponseWriter, r *http.Request) {
accountID, err := getSession(r) a := &App{DB: DB, WAConnector: WAConnector}
if err != nil { a.LoginPage(w, r)
http.Redirect(w, r, "/auth/login", http.StatusFound)
return 0, false
}
return accountID, true
} }
func SetupAuthHandlers(db *sql.DB) { func Login(w http.ResponseWriter, r *http.Request) {
DB = db a := &App{DB: DB, WAConnector: WAConnector}
chi.RegisterMethod("GET") a.Login(w, r)
}
func Logout(w http.ResponseWriter, r *http.Request) {
a := &App{DB: DB, WAConnector: WAConnector}
a.Logout(w, r)
} }
func AccountPage(w http.ResponseWriter, r *http.Request) { func AccountPage(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) a := &App{DB: DB, WAConnector: WAConnector}
if !ok { a.AccountPage(w, r)
return
}
var name, email string
err := DB.QueryRow("SELECT name, email FROM accounts WHERE account_id = ?", accountID).Scan(&name, &email)
if err != nil {
http.Error(w, "Account not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "text/html")
w.Write([]byte(`<!DOCTYPE html><html><head><title>Account</title></head><body><h1>Account Settings</h1><form method="POST" action="/auth/account">
<p>Name: <input type="text" name="name" value="` + name + `"></p>
<p>Email: <input type="email" value="` + email + `" disabled></p>
<p>New Password: <input type="password" name="password" placeholder="Leave blank to keep current"></p>
<button type="submit">Update</button>
</form>
<a href="/">Back to Dashboard</a></body></html>`))
} }
func UpdateAccount(w http.ResponseWriter, r *http.Request) { func UpdateAccount(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) a := &App{DB: DB, WAConnector: WAConnector}
if !ok { a.UpdateAccount(w, r)
return
}
r.ParseForm()
name := r.FormValue("name")
password := r.FormValue("password")
if name != "" {
DB.Exec("UPDATE accounts SET name = ? WHERE account_id = ?", name, accountID)
}
if password != "" {
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err == nil {
DB.Exec("UPDATE accounts SET password = ? WHERE account_id = ?", string(hashedPassword), accountID)
}
}
http.Redirect(w, r, "/auth/account", http.StatusFound)
} }
+85 -29
View File
@@ -10,8 +10,8 @@ import (
"github.com/go-chi/chi/v5" "github.com/go-chi/chi/v5"
) )
func ListClients(w http.ResponseWriter, r *http.Request) { func (a *App) ListClients(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -22,13 +22,13 @@ func ListClients(w http.ResponseWriter, r *http.Request) {
limit = 20 limit = 20
} }
clients, err := db.ListClients(DB, accountID, limit, offset) clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html> w.Write([]byte(`<!DOCTYPE html>
<html> <html>
<head> <head>
@@ -54,15 +54,27 @@ func ListClients(w http.ResponseWriter, r *http.Request) {
</div> </div>
<table> <table>
<thead> <thead>
<tr><th>Name</th><th>Phone</th><th>Email</th><th>Actions</th></tr> <tr><th>Name</th><th>Phone</th><th>WhatsApp</th><th>Actions</th></tr>
</thead> </thead>
<tbody id="clientList"> <tbody id="clientList">
`)) `))
for _, c := range clients { for _, c := range clients {
var whatsappCell string
connected := false
if c.WhatsAppNumber != "" && a.WAConnector != nil {
connected, _ = a.WAConnector.IsConnected(r.Context(), c.ClientID)
}
if connected {
whatsappCell = c.WhatsAppNumber + ` <span style="color:#28a745">&#9679;</span>`
} else if c.WhatsAppConnected == 1 && c.WhatsAppNumber != "" {
whatsappCell = c.WhatsAppNumber + ` <span style="color:#dc3545">&#9675;</span> <a href="/leads/connect?client_id=` + strconv.FormatInt(c.ClientID, 10) + `">Reconnect</a>`
} else {
whatsappCell = `<a href="/leads/connect?client_id=` + strconv.FormatInt(c.ClientID, 10) + `">Connect</a>`
}
w.Write([]byte(`<tr> w.Write([]byte(`<tr>
<td>` + c.Name + `</td> <td>` + c.Name + `</td>
<td>` + c.Phone + `</td> <td>` + c.Phone + `</td>
<td>` + c.Email + `</td> <td>` + whatsappCell + `</td>
<td> <td>
<a href="/clients/` + strconv.FormatInt(c.ClientID, 10) + `">View</a> <a href="/clients/` + strconv.FormatInt(c.ClientID, 10) + `">View</a>
<button type="button" onclick="document.getElementById('editForm` + strconv.FormatInt(c.ClientID, 10) + `').style.display='block'">Edit</button> <button type="button" onclick="document.getElementById('editForm` + strconv.FormatInt(c.ClientID, 10) + `').style.display='block'">Edit</button>
@@ -82,11 +94,13 @@ func ListClients(w http.ResponseWriter, r *http.Request) {
</td> </td>
</tr>`)) </tr>`))
} }
w.Write([]byte(`</tbody></table></body></html>`)) w.Write([]byte(`</tbody></table>
<p><a href="/">Back to Home</a></p>
</body></html>`))
} }
func CreateClient(w http.ResponseWriter, r *http.Request) { func (a *App) CreateClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -98,33 +112,57 @@ func CreateClient(w http.ResponseWriter, r *http.Request) {
Phone: r.FormValue("phone"), Phone: r.FormValue("phone"),
Email: r.FormValue("email"), Email: r.FormValue("email"),
Address: r.FormValue("address"), Address: r.FormValue("address"),
Notes: r.FormValue("notes"), Notes: r.FormValue("notes"),
CreatedAt: time.Now().Unix(), CreatedAt: time.Now().Unix(),
} }
if err := client.Create(DB); err != nil { if err := client.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func ViewClient(w http.ResponseWriter, r *http.Request) { func (a *App) ViewClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
client, err := db.GetClientByID(DB, accountID, id) client, err := db.GetClientByID(a.DB, accountID, id)
if err != nil { if err != nil {
http.Error(w, "Client not found", http.StatusNotFound) http.Error(w, "Client not found", http.StatusNotFound)
return return
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
var whatsappSection string
if client.WhatsAppNumber != "" {
connected := false
if a.WAConnector != nil {
connected, _ = a.WAConnector.IsConnected(r.Context(), client.ClientID)
}
status := "Not connected"
style := "color:#999"
if connected {
status = "Connected"
style = "color:#28a745"
} else if client.WhatsAppConnected == 1 {
status = "Disconnected (was connected)"
style = "color:#dc3545"
}
whatsappSection = `
<p>WhatsApp: <strong>` + client.WhatsAppNumber + `</strong> <span style="` + style + `">(` + status + `)</span></p>
<p><a href="/leads/connect?client_id=` + strconv.FormatInt(client.ClientID, 10) + `">Reconnect WhatsApp</a></p>`
} else {
whatsappSection = `
<p>WhatsApp: Not configured <a href="/leads/connect?client_id=` + strconv.FormatInt(client.ClientID, 10) + `">Connect</a></p>`
}
w.Write([]byte(`<!DOCTYPE html> w.Write([]byte(`<!DOCTYPE html>
<html> <html>
<head></head> <head></head>
@@ -134,13 +172,13 @@ func ViewClient(w http.ResponseWriter, r *http.Request) {
<p>Phone: ` + client.Phone + `</p> <p>Phone: ` + client.Phone + `</p>
<p>Email: ` + client.Email + `</p> <p>Email: ` + client.Email + `</p>
<p>Address: ` + client.Address + `</p> <p>Address: ` + client.Address + `</p>
<p>Notes: ` + client.Notes + `</p> <p>Notes: ` + client.Notes + `</p>` + whatsappSection + `
<a href="/clients">Back</a> <a href="/clients">Back</a>
</body></html>`)) </body></html>`))
} }
func UpdateClient(w http.ResponseWriter, r *http.Request) { func (a *App) UpdateClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -150,14 +188,14 @@ func UpdateClient(w http.ResponseWriter, r *http.Request) {
client := db.Client{ client := db.Client{
ClientID: id, ClientID: id,
AccountID: accountID, AccountID: accountID,
Name: r.FormValue("name"), Name: r.FormValue("name"),
Phone: r.FormValue("phone"), Phone: r.FormValue("phone"),
Email: r.FormValue("email"), Email: r.FormValue("email"),
Address: r.FormValue("address"), Address: r.FormValue("address"),
Notes: r.FormValue("notes"), Notes: r.FormValue("notes"),
} }
if err := client.Update(DB); err != nil { if err := client.Update(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
} }
@@ -165,19 +203,37 @@ func UpdateClient(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func DeleteClient(w http.ResponseWriter, r *http.Request) { func (a *App) DeleteClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
client := &db.Client{ClientID: id, AccountID: accountID} client := &db.Client{ClientID: id, AccountID: accountID}
if err := client.Delete(DB); err != nil { if err := client.Delete(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte("OK")) w.Write([]byte("OK"))
} }
// --- package-level shims kept for existing tests ---
func ListClients(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListClients(w, r)
}
func CreateClient(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreateClient(w, r)
}
func ViewClient(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewClient(w, r)
}
func UpdateClient(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateClient(w, r)
}
func DeleteClient(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteClient(w, r)
}
@@ -0,0 +1,337 @@
package handlers
import (
"database/sql"
"net/http"
"net/http/httptest"
"os"
"strconv"
"strings"
"testing"
"time"
"go-crm/internal/db"
"go-crm/internal/whatsapp"
"golang.org/x/crypto/bcrypt"
)
func TestListClientsWhatsAppDisplay(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
testDB, err := db.Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer testDB.Close()
DB = testDB
WAConnector = whatsapp.NewFakeConnector()
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
_, err = testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create account: %v", err)
}
var accountID int64
err = testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
if err != nil {
t.Fatalf("failed to get account id: %v", err)
}
sessionID := "test-session"
expires := time.Now().Add(time.Hour).Unix()
_, err = testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
)
if err != nil {
t.Fatalf("failed to create session: %v", err)
}
_, err = testDB.Exec(
"INSERT INTO clients (account_id, name, phone, created_at) VALUES (?, ?, ?, ?)",
accountID, "Client Without WhatsApp", "+5521987654321", time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create client without wa: %v", err)
}
_, err = testDB.Exec(
"INSERT INTO clients (account_id, name, phone, whatsapp_number, whatsapp_connected, created_at) VALUES (?, ?, ?, ?, ?, ?)",
accountID, "Client With WhatsApp", "+5521987654322", "+5521987654322", 1, time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create client with wa: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/clients", nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
ListClients(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, "Client Without WhatsApp") {
t.Error("expected to find client without wa in response")
}
if !strings.Contains(body, "Connect") {
t.Error("expected Connect button for client without WhatsApp")
}
if !strings.Contains(body, "Client With WhatsApp") {
t.Error("expected to find client with wa in response")
}
if !strings.Contains(body, "+5521987654322") {
t.Error("expected WhatsApp number displayed for connected client")
}
}
func SetupTestDB(t *testing.T) (*sql.DB, func()) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
tmpfile.Close()
testDB, err := db.Init(tmpfile.Name())
if err != nil {
os.Remove(tmpfile.Name())
t.Fatalf("failed to init db: %v", err)
}
cleanup := func() {
testDB.Close()
os.Remove(tmpfile.Name())
}
return testDB, cleanup
}
func TestLeadsConnectPage(t *testing.T) {
testDB, cleanup := SetupTestDB(t)
defer cleanup()
DB = testDB
WAConnector = whatsapp.NewFakeConnector()
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
var accountID int64
testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
sessionID := "test-session"
testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, time.Now().Add(time.Hour).Unix(),
)
var clientID int64
testDB.QueryRow(
"INSERT INTO clients (account_id, name, phone, created_at) VALUES (?, ?, ?, ?) RETURNING client_id",
accountID, "Test Client", "+5521987654321", time.Now().Unix(),
).Scan(&clientID)
req := httptest.NewRequest(http.MethodGet, "/leads/connect?client_id="+strconv.FormatInt(clientID, 10), nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
LeadsConnectPage(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, "Scan to Connect") && !strings.Contains(body, "WhatsApp") {
t.Error("expected QR connection page with WhatsApp messaging")
}
if !strings.Contains(strconv.FormatInt(clientID, 10), "") {
t.Log("client_id passed to page")
}
}
func TestLeadsQRPolling(t *testing.T) {
testDB, cleanup := SetupTestDB(t)
defer cleanup()
DB = testDB
WAConnector = whatsapp.NewFakeConnector()
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
var accountID int64
testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
sessionID := "test-session"
testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, time.Now().Add(time.Hour).Unix(),
)
var clientID int64
testDB.QueryRow(
"INSERT INTO clients (account_id, name, phone, created_at) VALUES (?, ?, ?, ?) RETURNING client_id",
accountID, "Test Client", "+5521987654321", time.Now().Unix(),
).Scan(&clientID)
req := httptest.NewRequest(http.MethodGet, "/leads/qr?client_id="+strconv.FormatInt(clientID, 10), nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
LeadsQR(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
}
func TestListClientsHasBackToHomeLink(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
testDB, err := db.Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer testDB.Close()
DB = testDB
WAConnector = whatsapp.NewFakeConnector()
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
_, err = testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create account: %v", err)
}
var accountID int64
err = testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
if err != nil {
t.Fatalf("failed to get account id: %v", err)
}
sessionID := "test-session-nav"
expires := time.Now().Add(time.Hour).Unix()
_, err = testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
)
if err != nil {
t.Fatalf("failed to create session: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/clients", nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
ListClients(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, `href="/"`) {
t.Error("expected clients page to have Back to Home link")
}
}
func TestListClientsShowsConnectButtonForUnconnectedClients(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
testDB, err := db.Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer testDB.Close()
DB = testDB
WAConnector = whatsapp.NewFakeConnector()
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
_, err = testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create account: %v", err)
}
var accountID int64
err = testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
if err != nil {
t.Fatalf("failed to get account id: %v", err)
}
var clientID int64
testDB.QueryRow(
"INSERT INTO clients (account_id, name, phone, created_at) VALUES (?, ?, ?, ?) RETURNING client_id",
accountID, "Unconnected Client", "+5521987654321", time.Now().Unix(),
).Scan(&clientID)
sessionID := "test-session-connect-btn"
expires := time.Now().Add(time.Hour).Unix()
_, err = testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
)
if err != nil {
t.Fatalf("failed to create session: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/clients", nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
ListClients(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, "leads/connect?client_id=") {
t.Error("expected clients page to show Connect link for unconnected clients")
}
}
+87 -30
View File
@@ -5,13 +5,14 @@ import (
"strconv" "strconv"
"time" "time"
"go-crm/config"
"go-crm/internal/db" "go-crm/internal/db"
"github.com/go-chi/chi/v5" "github.com/go-chi/chi/v5"
) )
func ListCustomers(w http.ResponseWriter, r *http.Request) { func (a *App) ListCustomers(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -23,13 +24,13 @@ func ListCustomers(w http.ResponseWriter, r *http.Request) {
limit = 20 limit = 20
} }
customers, err := db.ListCustomers(DB, accountID, clientID, limit, offset) customers, err := db.ListCustomers(a.DB, accountID, clientID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
} }
clients, err := db.ListClients(DB, accountID, limit, offset) clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
@@ -40,7 +41,7 @@ func ListCustomers(w http.ResponseWriter, r *http.Request) {
clientOptions += `<option value="` + strconv.FormatInt(c.ClientID, 10) + `">` + c.Name + `</option>` clientOptions += `<option value="` + strconv.FormatInt(c.ClientID, 10) + `">` + c.Name + `</option>`
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/[email protected]"></script><style>.edit-form{display:none;margin-top:0.5rem;padding:0.5rem;border:1px solid #ccc}</style></head><body><h1>Customers</h1><button class="btn" onclick="document.getElementById('customerForm').style.display='block'">Add Customer</button><div id="customerForm" style="display:none; margin-top:1rem;"><form hx-post="/customers" hx-target="#customerList"><input type="text" name="name" placeholder="Name" required><input type="tel" name="phone" placeholder="Phone"><input type="date" name="birth_date" placeholder="Birth Date"><input type="text" name="instagram" placeholder="Instagram"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><button type="submit">Add</button></form></div><table><thead><tr><th>Name</th><th>Phone</th><th>Birth Date</th><th>Instagram</th><th>Actions</th></tr></thead><tbody id="customerList">`)) w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/[email protected]"></script><style>.edit-form{display:none;margin-top:0.5rem;padding:0.5rem;border:1px solid #ccc}</style></head><body><h1>Customers</h1><button class="btn" onclick="document.getElementById('customerForm').style.display='block'">Add Customer</button><div id="customerForm" style="display:none; margin-top:1rem;"><form hx-post="/customers" hx-target="#customerList"><input type="text" name="name" placeholder="Name" required><input type="tel" name="phone" placeholder="Phone"><input type="date" name="birth_date" placeholder="Birth Date"><input type="text" name="instagram" placeholder="Instagram"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><button type="submit">Add</button></form></div><table><thead><tr><th>Name</th><th>Phone</th><th>Birth Date</th><th>Instagram</th><th>Actions</th></tr></thead><tbody id="customerList">`))
for _, c := range customers { for _, c := range customers {
w.Write([]byte(`<tr><td>` + c.Name + `</td><td>` + c.Phone + `</td><td>` + c.BirthDate + `</td><td>` + c.Instagram + `</td><td><a href="/customers/` + strconv.FormatInt(c.CustomerID, 10) + `">View</a><button type="button" onclick="document.getElementById('editCust` + strconv.FormatInt(c.CustomerID, 10) + `').style.display='block'">Edit</button><form method="DELETE" style="display:inline" hx-delete="/customers/` + strconv.FormatInt(c.CustomerID, 10) + `" hx-target="closest tr"><button type="submit">Delete</button></form></td></tr><tr id="editCust` + strconv.FormatInt(c.CustomerID, 10) + `" style="display:none"><td colspan="5"><form hx-put="/customers/` + strconv.FormatInt(c.CustomerID, 10) + `" hx-target="#customerList" hx-swap="innerHTML"><input type="text" name="name" value="` + c.Name + `"><input type="tel" name="phone" value="` + c.Phone + `"><input type="date" name="birth_date" value="` + c.BirthDate + `"><input type="text" name="instagram" value="` + c.Instagram + `"><select name="client_id"><option value="` + strconv.FormatInt(c.ClientID, 10) + `">` + c.Name + `</option>` + clientOptions + `</select><button type="submit">Save</button></form></td></tr>`)) w.Write([]byte(`<tr><td>` + c.Name + `</td><td>` + c.Phone + `</td><td>` + c.BirthDate + `</td><td>` + c.Instagram + `</td><td><a href="/customers/` + strconv.FormatInt(c.CustomerID, 10) + `">View</a><button type="button" onclick="document.getElementById('editCust` + strconv.FormatInt(c.CustomerID, 10) + `').style.display='block'">Edit</button><form method="DELETE" style="display:inline" hx-delete="/customers/` + strconv.FormatInt(c.CustomerID, 10) + `" hx-target="closest tr"><button type="submit">Delete</button></form></td></tr><tr id="editCust` + strconv.FormatInt(c.CustomerID, 10) + `" style="display:none"><td colspan="5"><form hx-put="/customers/` + strconv.FormatInt(c.CustomerID, 10) + `" hx-target="#customerList" hx-swap="innerHTML"><input type="text" name="name" value="` + c.Name + `"><input type="tel" name="phone" value="` + c.Phone + `"><input type="date" name="birth_date" value="` + c.BirthDate + `"><input type="text" name="instagram" value="` + c.Instagram + `"><select name="client_id"><option value="` + strconv.FormatInt(c.ClientID, 10) + `">` + c.Name + `</option>` + clientOptions + `</select><button type="submit">Save</button></form></td></tr>`))
@@ -48,32 +49,70 @@ func ListCustomers(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`</tbody></table></body></html>`)) w.Write([]byte(`</tbody></table></body></html>`))
} }
func CreateCustomer(w http.ResponseWriter, r *http.Request) { func (a *App) CreateCustomer(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) isInternal := r.Header.Get("X-Internal-Secret") == config.InternalSecret()
var accountID int64
var clientID int64
var ok bool
if isInternal {
clientID, _ = strconv.ParseInt(r.FormValue("client_id"), 10, 64)
accountID = clientID
ok = true
} else {
accountID, ok = a.requireAuth(w, r)
if ok {
clientID, _ = strconv.ParseInt(r.FormValue("client_id"), 10, 64)
}
}
if !ok { if !ok {
return return
} }
r.ParseForm() r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64) if clientID == 0 {
clientID, _ = strconv.ParseInt(r.FormValue("client_id"), 10, 64)
}
var checkID int64 if !isInternal {
err := DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID) var checkID int64
if err != nil { err := a.DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID)
http.Error(w, "Invalid client", http.StatusBadRequest) if err != nil {
return http.Error(w, "Invalid client", http.StatusBadRequest)
return
}
} }
customer := db.Customer{ customer := db.Customer{
ClientID: clientID, ClientID: clientID,
Name: r.FormValue("name"), Name: r.FormValue("name"),
Phone: r.FormValue("phone"), Phone: r.FormValue("phone"),
BirthDate: r.FormValue("birth_date"), BirthDate: r.FormValue("birth_date"),
Instagram: r.FormValue("instagram"), Instagram: r.FormValue("instagram"),
CreatedAt: time.Now().Unix(), CreatedAt: time.Now().Unix(),
} }
if err := customer.Create(DB); err != nil { if phone := r.FormValue("phone"); phone != "" {
var existingID int64
err := a.DB.QueryRow(
"SELECT customer_id FROM customers WHERE client_id = ? AND phone = ?",
clientID, phone,
).Scan(&existingID)
if err == nil {
_, err = a.DB.Exec(
"UPDATE customers SET name = ?, birth_date = ?, instagram = ? WHERE customer_id = ?",
r.FormValue("name"), r.FormValue("birth_date"), r.FormValue("instagram"), existingID,
)
if err == nil {
w.Header().Set("HX-Refresh", "true")
return
}
}
}
if err := customer.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
} }
@@ -81,26 +120,26 @@ func CreateCustomer(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func ViewCustomer(w http.ResponseWriter, r *http.Request) { func (a *App) ViewCustomer(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
var c db.Customer var c db.Customer
err := DB.QueryRow("SELECT customer_id, client_id, name, phone, birth_date, instagram, created_at FROM customers WHERE customer_id = ?", id).Scan(&c.CustomerID, &c.ClientID, &c.Name, &c.Phone, &c.BirthDate, &c.Instagram, &c.CreatedAt) err := a.DB.QueryRow("SELECT customer_id, client_id, name, phone, birth_date, instagram, created_at FROM customers WHERE customer_id = ?", id).Scan(&c.CustomerID, &c.ClientID, &c.Name, &c.Phone, &c.BirthDate, &c.Instagram, &c.CreatedAt)
if err != nil { if err != nil {
http.Error(w, "Customer not found", http.StatusNotFound) http.Error(w, "Customer not found", http.StatusNotFound)
return return
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><body><h1>` + c.Name + `</h1><p>Phone: ` + c.Phone + `</p><p>Birth Date: ` + c.BirthDate + `</p><p>Instagram: ` + c.Instagram + `</p><a href="/customers">Back</a></body></html>`)) w.Write([]byte(`<!DOCTYPE html><body><h1>` + c.Name + `</h1><p>Phone: ` + c.Phone + `</p><p>Birth Date: ` + c.BirthDate + `</p><p>Instagram: ` + c.Instagram + `</p><a href="/customers">Back</a></body></html>`))
} }
func UpdateCustomer(w http.ResponseWriter, r *http.Request) { func (a *App) UpdateCustomer(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -108,7 +147,7 @@ func UpdateCustomer(w http.ResponseWriter, r *http.Request) {
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm() r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64) clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
_, err := DB.Exec("UPDATE customers SET client_id=?, name=?, phone=?, birth_date=?, instagram=? WHERE customer_id=?", clientID, r.FormValue("name"), r.FormValue("phone"), r.FormValue("birth_date"), r.FormValue("instagram"), id) _, err := a.DB.Exec("UPDATE customers SET client_id=?, name=?, phone=?, birth_date=?, instagram=? WHERE customer_id=?", clientID, r.FormValue("name"), r.FormValue("phone"), r.FormValue("birth_date"), r.FormValue("instagram"), id)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
@@ -116,12 +155,30 @@ func UpdateCustomer(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func DeleteCustomer(w http.ResponseWriter, r *http.Request) { func (a *App) DeleteCustomer(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
DB.Exec("DELETE FROM customers WHERE customer_id = ?", id) a.DB.Exec("DELETE FROM customers WHERE customer_id = ?", id)
}
// --- package-level shims kept for existing tests ---
func ListCustomers(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListCustomers(w, r)
}
func CreateCustomer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreateCustomer(w, r)
}
func ViewCustomer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewCustomer(w, r)
}
func UpdateCustomer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateCustomer(w, r)
}
func DeleteCustomer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteCustomer(w, r)
} }
@@ -0,0 +1,49 @@
package handlers
import (
"net/http"
"net/http/httptest"
"testing"
"time"
"golang.org/x/crypto/bcrypt"
)
func TestCreateCustomerInternalSecret(t *testing.T) {
testDB, cleanup := SetupTestDB(t)
defer cleanup()
DB = testDB
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
var accountID int64
testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
var clientID int64
testDB.QueryRow(
"INSERT INTO clients (account_id, name, phone, created_at) VALUES (?, ?, ?, ?) RETURNING client_id",
accountID, "Test Client", "+5521987654321", time.Now().Unix(),
).Scan(&clientID)
req := httptest.NewRequest(http.MethodPost, "/customers", nil)
req.PostForm = map[string][]string{
"name": {"+5521987654321"},
"phone": {"+5521987654321"},
"client_id": {string(rune(clientID))},
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
req.Header.Set("X-Internal-Secret", "internal-secret")
w := httptest.NewRecorder()
CreateCustomer(w, req)
if w.Code != http.StatusOK && w.Code != http.StatusFound {
t.Fatalf("expected success with internal secret, got %d", w.Code)
}
}
@@ -0,0 +1,85 @@
package handlers
import (
"fmt"
"net/http"
)
func (a *App) Dashboard(w http.ResponseWriter, r *http.Request) {
accountID, err := a.getSession(r)
if err != nil {
http.Redirect(w, r, "/auth/login", http.StatusFound)
return
}
var clientID int64
a.DB.QueryRow("SELECT client_id FROM clients WHERE account_id = ? LIMIT 1", accountID).Scan(&clientID)
var reviewCount int
if clientID > 0 {
a.DB.QueryRow("SELECT COUNT(*) FROM leads WHERE client_id = ? AND needs_review = 1", clientID).Scan(&reviewCount)
}
waStatus := "disconnected"
waStyle := "color:#dc3545"
connectLink := ""
if a.WAConnector != nil {
if connected, _ := a.WAConnector.IsConnected(r.Context(), clientID); connected {
waStatus = "connected"
waStyle = "color:#28a745"
} else if clientID > 0 {
// Fallback: check DB column when in-memory state not available.
var dbConnected int
a.DB.QueryRow("SELECT whatsapp_connected FROM clients WHERE client_id = ?", clientID).Scan(&dbConnected)
if dbConnected == 1 {
waStatus = "connected"
waStyle = "color:#28a745"
} else {
connectLink = fmt.Sprintf(` <a href="/leads/connect?client_id=%d" style="color:#28a745">Connect</a>`, clientID)
}
} else {
connectLink = ` <a href="/clients" style="color:#28a745">Create client to connect</a>`
}
}
badge := ""
if reviewCount > 0 {
badge = fmt.Sprintf(` <span style="background:#dc3545;color:#fff;border-radius:1rem;padding:0.15rem 0.5rem;font-size:0.8rem">%d</span>`, reviewCount)
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprintf(w, `<!DOCTYPE html>
<html>
<head>
<title>Dashboard</title>
<style>
body { font-family: sans-serif; padding: 1.5rem; }
nav a { margin-right: 1rem; text-decoration: none; color: #2c7be5; }
nav a:hover { text-decoration: underline; }
.wa-status { font-size: 0.9rem; }
</style>
</head>
<body>
<h1>CRM Dashboard</h1>
<p class="wa-status">WhatsApp: <strong style="%s">%s</strong>%s</p>
<nav>
<a href="/leads/review">Review Queue%s</a>
<a href="/leads/all">All Leads</a>
<a href="/report">Monthly Report</a>
<a href="/leads/keywords">Keyword Mapping</a>
<a href="/clients">Clients</a>
<a href="/services">Services</a>
<a href="/scheduling">Scheduling</a>
<a href="/payments">Payments</a>
<a href="/auth/account">Account</a>
<form method="POST" action="/auth/logout" style="display:inline">
<button type="submit">Logout</button>
</form>
</nav>
</body></html>`, waStyle, waStatus, connectLink, badge)
}
// --- package-level shim kept for existing tests ---
func Dashboard(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).Dashboard(w, r)
}
@@ -0,0 +1,291 @@
package handlers
import (
"net/http"
"net/http/httptest"
"os"
"strings"
"testing"
"time"
"go-crm/internal/db"
"go-crm/internal/whatsapp"
"golang.org/x/crypto/bcrypt"
)
func TestDashboardHidesConnectLinkWhenDBConnected(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
testDB, err := db.Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer testDB.Close()
// FakeConnector NOT marked connected — only DB column is set.
DB = testDB
WAConnector = whatsapp.NewFakeConnector()
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
_, err = testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create account: %v", err)
}
var accountID int64
err = testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
if err != nil {
t.Fatalf("failed to get account id: %v", err)
}
var clientID int64
testDB.QueryRow(
"INSERT INTO clients (account_id, name, phone, whatsapp_connected, created_at) VALUES (?, ?, ?, ?, ?) RETURNING client_id",
accountID, "DB Connected Client", "+5521987654321", 1, time.Now().Unix(),
).Scan(&clientID)
sessionID := "test-session-db-connected"
expires := time.Now().Add(time.Hour).Unix()
_, err = testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
)
if err != nil {
t.Fatalf("failed to create session: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/", nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
Dashboard(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, "connected") {
t.Error("expected dashboard to show 'connected' status from DB column")
}
if strings.Contains(body, "/leads/connect") {
t.Error("expected dashboard to NOT show Connect link when DB column indicates connected")
}
}
func TestDashboardShowsConnectLinkWhenDisconnected(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
testDB, err := db.Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer testDB.Close()
DB = testDB
WAConnector = whatsapp.NewFakeConnector()
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
_, err = testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create account: %v", err)
}
var accountID int64
err = testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
if err != nil {
t.Fatalf("failed to get account id: %v", err)
}
sessionID := "test-session-dashboard"
expires := time.Now().Add(time.Hour).Unix()
_, err = testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
)
if err != nil {
t.Fatalf("failed to create session: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/", nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
Dashboard(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, "disconnected") {
t.Error("expected dashboard to show 'disconnected' status")
}
if !strings.Contains(body, "/clients") {
t.Error("expected dashboard to show link to create client when no client exists")
}
}
func TestDashboardShowsConnectedStatus(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
testDB, err := db.Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer testDB.Close()
fakeWA := whatsapp.NewFakeConnector()
fakeWA.MarkConnected(1)
DB = testDB
WAConnector = fakeWA
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
_, err = testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create account: %v", err)
}
var accountID int64
err = testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
if err != nil {
t.Fatalf("failed to get account id: %v", err)
}
_, err = testDB.Exec(
"INSERT INTO clients (account_id, name, phone, created_at) VALUES (?, ?, ?, ?)",
accountID, "Test Client", "+5521987654321", time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create client: %v", err)
}
sessionID := "test-session-connected"
expires := time.Now().Add(time.Hour).Unix()
_, err = testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
)
if err != nil {
t.Fatalf("failed to create session: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/", nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
Dashboard(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, "connected") {
t.Error("expected dashboard to show 'connected' status")
}
if strings.Contains(body, "/leads/connect") {
t.Error("expected dashboard to NOT show Connect link when WhatsApp is connected")
}
}
func TestDashboardShowsConnectLinkWithClientID(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
testDB, err := db.Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer testDB.Close()
DB = testDB
WAConnector = whatsapp.NewFakeConnector()
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
_, err = testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create account: %v", err)
}
var accountID int64
err = testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
if err != nil {
t.Fatalf("failed to get account id: %v", err)
}
var clientID int64
testDB.QueryRow(
"INSERT INTO clients (account_id, name, phone, created_at) VALUES (?, ?, ?, ?) RETURNING client_id",
accountID, "Test Client", "+5521987654321", time.Now().Unix(),
).Scan(&clientID)
sessionID := "test-session-disconnected-client"
expires := time.Now().Add(time.Hour).Unix()
_, err = testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
)
if err != nil {
t.Fatalf("failed to create session: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/", nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
Dashboard(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, "disconnected") {
t.Error("expected dashboard to show 'disconnected' status")
}
if !strings.Contains(body, "/leads/connect?client_id=") {
t.Error("expected dashboard to show Connect link with client_id when client exists")
}
}
@@ -0,0 +1,151 @@
package handlers
import (
"database/sql"
"encoding/json"
"log"
"net/http"
"go-crm/config"
"go-crm/internal/db"
"go-crm/internal/parser"
)
// ingestRequest is the JSON body sent by the WhatsApp adapter.
type ingestRequest struct {
ClientID int64 `json:"client_id"`
Name string `json:"name"`
Phone string `json:"phone"`
Message string `json:"message"`
MessageID string `json:"message_id"`
}
// IngestLead is the internal-only endpoint called by the WhatsApp adapter.
// POST /leads/ingest (X-Internal-Secret required)
func (a *App) IngestLead(w http.ResponseWriter, r *http.Request) {
if r.Header.Get("X-Internal-Secret") != config.InternalSecret() {
http.Error(w, "forbidden", http.StatusForbidden)
return
}
var req ingestRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "bad request", http.StatusBadRequest)
return
}
if req.ClientID == 0 || req.Phone == "" {
http.Error(w, "client_id and phone required", http.StatusBadRequest)
return
}
phoneNorm := parser.NormalizePhone(req.Phone)
// Dedup: skip if this message was already processed.
if req.MessageID != "" {
processed, err := db.IsMessageProcessed(a.DB, req.ClientID, req.MessageID)
if err != nil {
log.Printf("IngestLead: db error checking processed message: %v", err)
}
if processed {
w.WriteHeader(http.StatusOK)
return
}
}
// Check if lead already exists for this phone.
existing, err := db.GetLeadByPhone(a.DB, req.ClientID, phoneNorm)
if err != nil && err != sql.ErrNoRows {
log.Printf("IngestLead: db error checking existing lead: %v", err)
http.Error(w, "db error", http.StatusInternalServerError)
return
}
if existing != nil {
// Known lead — just update last contact timestamp.
if terr := db.TouchLeadContact(a.DB, existing.LeadID); terr != nil {
log.Printf("IngestLead: failed to touch lead %d: %v", existing.LeadID, terr)
}
if req.MessageID != "" {
if err := db.RecordProcessedMessage(a.DB, req.ClientID, req.MessageID); err != nil {
log.Printf("IngestLead: failed to record processed message: %v", err)
}
}
w.WriteHeader(http.StatusOK)
return
}
// New lead — extract service from message text.
mapping, err := db.LoadKeywordMapping(a.DB, req.ClientID)
if err != nil {
log.Printf("IngestLead: failed to load keyword mapping: %v", err)
mapping = map[string]string{}
}
serviceInterest := parser.ExtractService(req.Message, mapping)
needsReview := serviceInterest == "Não especificou"
lead := &db.Lead{
ClientID: req.ClientID,
Name: req.Name,
PhoneRaw: req.Phone,
PhoneNormalized: phoneNorm,
ServiceInterest: serviceInterest,
Status: "Não agendou",
NeedsReview: needsReview,
PaymentStatus: "Não pago",
}
if err := db.CreateLead(a.DB, lead); err != nil {
log.Printf("IngestLead: failed to create lead: %v", err)
http.Error(w, "db error", http.StatusInternalServerError)
return
}
if req.MessageID != "" {
if err := db.RecordProcessedMessage(a.DB, req.ClientID, req.MessageID); err != nil {
log.Printf("IngestLead: failed to record processed message: %v", err)
}
}
// Seed default statuses/keywords for this client if first lead.
go seedClientDefaults(a.DB, req.ClientID)
w.WriteHeader(http.StatusCreated)
}
// seedClientDefaults seeds default statuses and keywords for a client on first lead.
// It accepts the DB as a parameter so it can be called from both the App method
// and the legacy package-level shim without touching global state.
func seedClientDefaults(database *sql.DB, clientID int64) {
statuses, _ := db.ListLeadStatuses(database, clientID)
if len(statuses) == 0 {
defaults := []string{"Não agendou", "Agendou", "Sem retorno / não evoluiu"}
for _, s := range defaults {
db.AddLeadStatus(database, clientID, s)
}
}
kws, _ := db.ListServiceKeywords(database, clientID)
if len(kws) == 0 {
defaultKWs := map[string][]string{
"Head Spa": {"head spa", "head-spa", "headspa"},
"Massagem completa": {"massagem", "massagem completa"},
"Drenagem linfatica": {"drenagem", "linfática", "drenagem linfatica"},
"Hydra Boost": {"hydra", "hydra boost"},
"Design Henna": {"henna", "design henna"},
"Masculino": {"masculino", "masc"},
}
for svc, keywords := range defaultKWs {
for _, kw := range keywords {
db.AddServiceKeyword(database, clientID, svc, kw)
}
}
}
}
// --- package-level shim kept for existing tests ---
func IngestLead(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).IngestLead(w, r)
}
@@ -0,0 +1,242 @@
package handlers
import (
"fmt"
"net/http"
"strconv"
"go-crm/internal/db"
"github.com/go-chi/chi/v5"
)
// LeadKeywordsPage renders the keyword mapping management screen.
// GET /leads/keywords
func (a *App) LeadKeywordsPage(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID := a.clientIDForAccount(accountID)
if clientID == 0 {
http.Error(w, "No client found for account", http.StatusBadRequest)
return
}
kws, err := db.ListServiceKeywords(a.DB, clientID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
statuses, _ := db.ListLeadStatuses(a.DB, clientID)
services := a.serviceNames(clientID)
pendingCount, _ := db.CountLeadsNeedingReview(a.DB, clientID)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprintf(w, `<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Keyword Mapping</title>
<script src="https://unpkg.com/[email protected]"></script>
<style>
body { font-family: sans-serif; padding: 1rem; }
table { border-collapse: collapse; width: 100%%; margin-bottom: 2rem; }
th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
th { background: #f5f5f5; }
.badge { background: #dc3545; color: #fff; border-radius: 1rem; padding: 0.2rem 0.6rem; font-size: 0.8rem; }
.section { margin-top: 2rem; }
form.inline { display: inline; }
</style>
</head>
<body>
<h1>Keyword Mapping</h1>
<nav>
<a href="/">Home</a> |
<a href="/leads/review">Review Queue <span class="badge">%d</span></a> |
<a href="/leads/all">All Leads</a> |
<a href="/report">Monthly Report</a>
</nav>
<br>
<h2>Service Keywords</h2>
<p>Add keywords that trigger automatic service detection. Case and accent insensitive.</p>
<form hx-post="/leads/keywords" hx-target="#keywordTable" hx-swap="outerHTML">
<select name="service_name">%s</select>
<input type="text" name="keyword" placeholder="Keyword (e.g. massagem)" required>
<button type="submit">Add Keyword</button>
</form>
<br><br>
%s
<div class="section">
<h2>Lead Statuses</h2>
<p>Manage the status options available for leads.</p>
<form hx-post="/leads/statuses" hx-target="#statusTable" hx-swap="outerHTML">
<input type="text" name="status_name" placeholder="New status name" required>
<button type="submit">Add Status</button>
</form>
<br><br>
%s
</div>
</body></html>`,
pendingCount,
buildServiceSelectOptions(services),
renderKeywordTable(kws),
renderStatusTable(statuses),
)
}
// AddServiceKeyword adds a new keyword mapping.
// POST /leads/keywords
func (a *App) AddServiceKeyword(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID := a.clientIDForAccount(accountID)
r.ParseForm()
svc := r.FormValue("service_name")
kw := r.FormValue("keyword")
if svc == "" || kw == "" {
http.Error(w, "service_name and keyword required", http.StatusBadRequest)
return
}
db.AddServiceKeyword(a.DB, clientID, svc, kw)
kws, _ := db.ListServiceKeywords(a.DB, clientID)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprint(w, renderKeywordTable(kws))
}
// DeleteServiceKeywordHandler removes a keyword mapping.
// DELETE /leads/keywords/{id}
func (a *App) DeleteServiceKeywordHandler(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID := a.clientIDForAccount(accountID)
kwID, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
db.DeleteServiceKeyword(a.DB, clientID, kwID)
kws, _ := db.ListServiceKeywords(a.DB, clientID)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprint(w, renderKeywordTable(kws))
}
// AddLeadStatusHandler adds a new custom lead status.
// POST /leads/statuses
func (a *App) AddLeadStatusHandler(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID := a.clientIDForAccount(accountID)
r.ParseForm()
statusName := r.FormValue("status_name")
if statusName == "" {
http.Error(w, "status_name required", http.StatusBadRequest)
return
}
db.AddLeadStatus(a.DB, clientID, statusName)
statuses, _ := db.ListLeadStatuses(a.DB, clientID)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprint(w, renderStatusTable(statuses))
}
// DeleteLeadStatusHandler removes a lead status.
// DELETE /leads/statuses/{id}
func (a *App) DeleteLeadStatusHandler(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID := a.clientIDForAccount(accountID)
statusID, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
db.DeleteLeadStatus(a.DB, clientID, statusID)
statuses, _ := db.ListLeadStatuses(a.DB, clientID)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprint(w, renderStatusTable(statuses))
}
// --- rendering helpers -------------------------------------------------------
func buildServiceSelectOptions(services []string) string {
out := ""
for _, s := range services {
if s == "Não especificou" {
continue // don't map keywords to the fallback
}
out += fmt.Sprintf(`<option value="%s">%s</option>`, htmlEscape(s), htmlEscape(s))
}
return out
}
func renderKeywordTable(kws []db.ServiceKeyword) string {
out := `<table id="keywordTable">
<thead><tr><th>Service</th><th>Keyword</th><th>Actions</th></tr></thead>
<tbody>`
if len(kws) == 0 {
out += `<tr><td colspan="3">No keywords defined.</td></tr>`
}
for _, kw := range kws {
out += fmt.Sprintf(`
<tr>
<td>%s</td>
<td>%s</td>
<td>
<form hx-delete="/leads/keywords/%d" hx-target="#keywordTable" hx-swap="outerHTML" style="display:inline">
<button type="submit">Remove</button>
</form>
</td>
</tr>`, htmlEscape(kw.ServiceName), htmlEscape(kw.Keyword), kw.KeywordID)
}
out += `</tbody></table>`
return out
}
func renderStatusTable(statuses []db.LeadStatus) string {
out := `<table id="statusTable">
<thead><tr><th>Status</th><th>Actions</th></tr></thead>
<tbody>`
if len(statuses) == 0 {
out += `<tr><td colspan="2">No statuses defined.</td></tr>`
}
for _, s := range statuses {
out += fmt.Sprintf(`
<tr>
<td>%s</td>
<td>
<form hx-delete="/leads/statuses/%d" hx-target="#statusTable" hx-swap="outerHTML" style="display:inline">
<button type="submit">Remove</button>
</form>
</td>
</tr>`, htmlEscape(s.StatusName), s.StatusID)
}
out += `</tbody></table>`
return out
}
// --- package-level shims kept for existing tests ---
func LeadKeywordsPage(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).LeadKeywordsPage(w, r)
}
func AddServiceKeyword(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).AddServiceKeyword(w, r)
}
func DeleteServiceKeywordHandler(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteServiceKeywordHandler(w, r)
}
func AddLeadStatusHandler(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).AddLeadStatusHandler(w, r)
}
func DeleteLeadStatusHandler(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteLeadStatusHandler(w, r)
}
@@ -0,0 +1,423 @@
package handlers
import (
"fmt"
"net/http"
"strconv"
"strings"
"time"
"go-crm/internal/db"
"github.com/go-chi/chi/v5"
)
// LeadReviewQueue renders the review queue: leads where needs_review = 1.
// GET /leads/review
func (a *App) LeadReviewQueue(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID := a.clientIDForAccount(accountID)
if clientID == 0 {
http.Error(w, "No client found for account", http.StatusBadRequest)
return
}
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
if limit == 0 {
limit = 50
}
leads, err := db.ListLeadsForReview(a.DB, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
statuses, _ := db.ListLeadStatuses(a.DB, clientID)
services := a.serviceNames(clientID)
pendingCount := len(leads)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprintf(w, `<!DOCTYPE html>
<html>
<head>
<title>Review Queue (%d pending)</title>
<script src="https://unpkg.com/[email protected]"></script>
<style>
body { font-family: sans-serif; padding: 1rem; }
h1 { display: flex; align-items: center; gap: 0.5rem; }
.badge { background: #dc3545; color: #fff; border-radius: 1rem; padding: 0.2rem 0.6rem; font-size: 0.85rem; }
table { border-collapse: collapse; width: 100%%; }
th, td { border: 1px solid #ddd; padding: 8px; text-align: left; vertical-align: top; }
th { background: #f5f5f5; }
form { display: inline; }
select, input[type=text] { width: 100%%; box-sizing: border-box; }
.actions button { margin-right: 4px; }
.empty { padding: 2rem; color: #888; text-align: center; }
</style>
</head>
<body>
<h1>Review Queue <span class="badge">%d</span></h1>
<p>Leads with service interest not yet identified. Confirm or correct each entry.</p>
<nav><a href="/">Home</a> | <a href="/leads/all">All Leads</a> | <a href="/leads/keywords">Keyword Mapping</a> | <a href="/report">Monthly Report</a></nav>
<br>
`, pendingCount, pendingCount)
if len(leads) == 0 {
fmt.Fprintf(w, `<div class="empty">No leads pending review.</div>`)
} else {
fmt.Fprintf(w, `<table>
<thead>
<tr>
<th>Phone</th>
<th>Name</th>
<th>Service Interest</th>
<th>Status</th>
<th>Arrived</th>
<th>Actions</th>
</tr>
</thead>
<tbody id="reviewList">`)
for _, l := range leads {
arrived := time.Unix(l.CreatedAt, 0).Format("02/01 15:04")
fmt.Fprintf(w, `
<tr id="row-%d">
<td>%s</td>
<td>%s</td>
<td>
<form hx-put="/leads/%d/review" hx-target="#row-%d" hx-swap="outerHTML">
<select name="service_interest">%s</select>
<select name="status">%s</select>
<input type="text" name="name" value="%s" placeholder="Name">
<div class="actions">
<button type="submit">Confirm</button>
</div>
</form>
</td>
<td>%s</td>
<td>%s</td>
<td>
<form hx-delete="/leads/%d" hx-target="#row-%d" hx-swap="outerHTML">
<button type="submit" onclick="return confirm('Delete this lead?')">Delete</button>
</form>
</td>
</tr>`,
l.LeadID,
htmlEscape(l.PhoneNormalized),
htmlEscape(l.Name),
l.LeadID, l.LeadID,
buildServiceOptions(services, l.ServiceInterest),
buildStatusOptions(statuses, l.Status),
htmlEscape(l.Name),
htmlEscape(l.Status),
arrived,
l.LeadID, l.LeadID,
)
}
fmt.Fprintf(w, `</tbody></table>`)
}
fmt.Fprintf(w, `</body></html>`)
}
// ConfirmLeadReview handles the form submission from the review queue.
// PUT /leads/{id}/review
func (a *App) ConfirmLeadReview(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID := a.clientIDForAccount(accountID)
if clientID == 0 {
http.Error(w, "No client found", http.StatusBadRequest)
return
}
leadID, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm()
lead, err := db.GetLeadByID(a.DB, clientID, leadID)
if err != nil {
http.Error(w, "Lead not found", http.StatusNotFound)
return
}
lead.Name = r.FormValue("name")
lead.ServiceInterest = r.FormValue("service_interest")
lead.Status = r.FormValue("status")
lead.NeedsReview = false
if err := db.UpdateLead(a.DB, lead); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprintf(w, `<tr id="row-%d" style="display:none"></tr>`, leadID)
}
// LeadAllList renders all leads (not just review queue).
// GET /leads/all
func (a *App) LeadAllList(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID := a.clientIDForAccount(accountID)
if clientID == 0 {
http.Error(w, "No client found for account", http.StatusBadRequest)
return
}
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
if limit == 0 {
limit = 50
}
var leads []db.Lead
var err error
if a.LeadService != nil {
domainLeads, svcErr := a.LeadService.ListAllLeads(r.Context(), clientID, limit, offset)
if svcErr != nil {
http.Error(w, svcErr.Error(), http.StatusInternalServerError)
return
}
// convert domain.Leaf to db.Lead
leads = make([]db.Lead, len(domainLeads))
for i, dl := range domainLeads {
leads[i] = db.Lead{
LeadID: dl.LeadID,
ClientID: dl.ClientID,
Name: dl.Name,
PhoneRaw: dl.PhoneRaw,
PhoneNormalized: dl.PhoneNormalized,
ServiceInterest: dl.ServiceInterest,
Status: dl.Status,
NeedsReview: dl.NeedsReview,
AppointmentDate: dl.AppointmentDate,
AppointmentTime: dl.AppointmentTime,
PaymentStatus: dl.PaymentStatus,
PaymentAmount: dl.PaymentAmount,
PaymentDate: dl.PaymentDate,
CreatedAt: dl.CreatedAt,
LastContactAt: dl.LastContactAt,
}
}
} else {
leads, err = db.ListAllLeads(a.DB, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
pendingCount, _ := db.CountLeadsNeedingReview(a.DB, clientID)
statuses, _ := db.ListLeadStatuses(a.DB, clientID)
services := a.serviceNames(clientID)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprintf(w, `<!DOCTYPE html>
<html>
<head>
<title>All Leads</title>
<script src="https://unpkg.com/[email protected]"></script>
<style>
body { font-family: sans-serif; padding: 1rem; }
table { border-collapse: collapse; width: 100%%; }
th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
th { background: #f5f5f5; }
.badge { background: #dc3545; color: #fff; border-radius: 1rem; padding: 0.2rem 0.6rem; font-size: 0.8rem; }
.needs-review { background: #fff3cd; }
select, input[type=text] { width: 100%%; box-sizing: border-box; }
</style>
</head>
<body>
<h1>All Leads</h1>
<nav>
<a href="/">Home</a> |
<a href="/leads/review">Review Queue <span class="badge">%d</span></a> |
<a href="/leads/keywords">Keyword Mapping</a> |
<a href="/report">Monthly Report</a>
</nav>
<br>
<table>
<thead>
<tr>
<th>Phone</th><th>Name</th><th>Service</th><th>Status</th>
<th>Payment</th><th>Arrived</th><th>Last Contact</th><th>Actions</th>
</tr>
</thead>
<tbody id="leadsList">
`, pendingCount)
for _, l := range leads {
arrived := time.Unix(l.CreatedAt, 0).Format("02/01/2006 15:04")
lastContact := time.Unix(l.LastContactAt, 0).Format("02/01/2006 15:04")
rowClass := ""
if l.NeedsReview {
rowClass = `class="needs-review"`
}
fmt.Fprintf(w, `
<tr %s id="lead-%d">
<td>%s</td>
<td>%s</td>
<td>%s</td>
<td>%s</td>
<td>%s</td>
<td>%s</td>
<td>%s</td>
<td>
<button onclick="document.getElementById('edit-%d').style.display='table-row'">Edit</button>
<form hx-delete="/leads/%d" hx-target="#lead-%d" hx-swap="outerHTML" style="display:inline">
<button onclick="return confirm('Delete?')">Delete</button>
</form>
</td>
</tr>
<tr id="edit-%d" style="display:none">
<td colspan="8">
<form hx-put="/leads/%d/review" hx-target="#lead-%d" hx-swap="outerHTML">
<input type="text" name="name" value="%s" placeholder="Name">
<select name="service_interest">%s</select>
<select name="status">%s</select>
<button type="submit">Save</button>
<button type="button" onclick="document.getElementById('edit-%d').style.display='none'">Cancel</button>
</form>
</td>
</tr>`,
rowClass, l.LeadID,
htmlEscape(l.PhoneNormalized),
htmlEscape(l.Name),
htmlEscape(l.ServiceInterest),
htmlEscape(l.Status),
htmlEscape(l.PaymentStatus),
arrived,
lastContact,
l.LeadID,
l.LeadID, l.LeadID,
l.LeadID,
l.LeadID, l.LeadID,
htmlEscape(l.Name),
buildServiceOptions(services, l.ServiceInterest),
buildStatusOptions(statuses, l.Status),
l.LeadID,
)
}
fmt.Fprintf(w, `</tbody></table></body></html>`)
}
// DeleteLeadNew handles DELETE /leads/{id}
func (a *App) DeleteLeadNew(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID := a.clientIDForAccount(accountID)
leadID, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
a.DB.Exec("DELETE FROM leads WHERE lead_id = ? AND client_id = ?", leadID, clientID)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(""))
}
// serviceNames returns the list of service names for the review/all-leads dropdowns.
// It reads from the DB-backed services table first, then falls back to the
// hardcoded defaults so the dropdown is never empty on a fresh install.
func (a *App) serviceNames(clientID int64) []string {
rows, err := a.DB.Query(
"SELECT DISTINCT name FROM services WHERE client_id = ? ORDER BY name",
clientID,
)
if err == nil {
defer rows.Close()
var names []string
for rows.Next() {
var n string
if rows.Scan(&n) == nil {
names = append(names, n)
}
}
if len(names) > 0 {
// Ensure "Não especificou" is always first.
hasDefault := false
for _, n := range names {
if n == "Não especificou" {
hasDefault = true
break
}
}
if !hasDefault {
names = append([]string{"Não especificou"}, names...)
}
return names
}
}
// Fallback: hardcoded defaults for a fresh install with no services yet.
return []string{
"Não especificou",
"Head Spa",
"Massagem completa",
"Drenagem linfatica",
"Hydra Boost",
"Design Henna",
"Masculino",
}
}
// --- rendering helpers -------------------------------------------------------
func buildServiceOptions(services []string, selected string) string {
out := ""
for _, s := range services {
sel := ""
if s == selected {
sel = ` selected`
}
out += fmt.Sprintf(`<option value="%s"%s>%s</option>`, htmlEscape(s), sel, htmlEscape(s))
}
return out
}
func buildStatusOptions(statuses []db.LeadStatus, selected string) string {
out := ""
for _, s := range statuses {
sel := ""
if s.StatusName == selected {
sel = ` selected`
}
out += fmt.Sprintf(`<option value="%s"%s>%s</option>`, htmlEscape(s.StatusName), sel, htmlEscape(s.StatusName))
}
return out
}
func htmlEscape(s string) string {
s = strings.ReplaceAll(s, "&", "&amp;")
s = strings.ReplaceAll(s, "<", "&lt;")
s = strings.ReplaceAll(s, ">", "&gt;")
s = strings.ReplaceAll(s, `"`, "&#34;")
return s
}
// --- package-level shims kept for existing tests ---
func LeadReviewQueue(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).LeadReviewQueue(w, r)
}
func ConfirmLeadReview(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ConfirmLeadReview(w, r)
}
func LeadAllList(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).LeadAllList(w, r)
}
func DeleteLeadNew(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteLeadNew(w, r)
}
+384
View File
@@ -0,0 +1,384 @@
package handlers
import (
"context"
"encoding/json"
"log"
"net/http"
"strconv"
"strings"
"time"
"go-crm/internal/db"
"go-crm/internal/whatsapp"
"github.com/go-chi/chi/v5"
)
func (a *App) ListLeads(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
search := r.URL.Query().Get("search")
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
if limit == 0 {
limit = 20
}
query := "SELECT cu.customer_id, cu.client_id, cu.name, cu.phone, cu.birth_date, cu.instagram, cu.created_at, COALESCE(cl.whatsapp_connected,0), COALESCE(cl.whatsapp_number,'') FROM customers cu JOIN clients cl ON cu.client_id = cl.client_id WHERE cl.account_id = ?"
args := []interface{}{accountID}
if search != "" {
query += " AND (name LIKE ? OR phone LIKE ?)"
searchPat := "%" + search + "%"
args = append(args, searchPat, searchPat)
}
query += " ORDER BY cu.created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
rows, err := a.DB.Query(query, args...)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
defer rows.Close()
var customers []db.Customer
for rows.Next() {
var c db.Customer
if err := rows.Scan(&c.CustomerID, &c.ClientID, &c.Name, &c.Phone, &c.BirthDate, &c.Instagram, &c.CreatedAt, &c.WhatsAppConnected, &c.WhatsAppNumber); err != nil {
continue
}
customers = append(customers, c)
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html>
<html>
<head>
<title>Leads</title>
<script src="https://unpkg.com/[email protected]"></script>
<style>
body { font-family: sans-serif; padding: 1rem; }
table { border-collapse: collapse; width: 100%; }
th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
th { background: #f5f5f5; }
.search-box { margin-bottom: 1rem; }
.edit-row { display: none; }
</style>
</head>
<body>
<h1>Leads</h1>
<div class="search-box">
<form hx-get="/leads" hx-target="#leadList" hx-swap="innerHTML">
<input type="text" name="search" placeholder="Search by name or phone" value="` + search + `">
<button type="submit">Search</button>
</form>
</div>
<table>
<thead>
<tr><th>Name</th><th>Phone</th><th>Birth Date</th><th>Instagram</th><th>WhatsApp</th><th>Actions</th></tr>
</thead>
<tbody id="leadList">
`))
for _, c := range customers {
waStatus := "Not connected"
waStyle := "color: #999;"
if c.WhatsAppConnected == 1 && c.WhatsAppNumber != "" {
waStatus = c.WhatsAppNumber
waStyle = "color: #28a745; font-weight: 600;"
}
w.Write([]byte(`<tr>
<td>` + c.Name + `</td>
<td>` + c.Phone + `</td>
<td>` + c.BirthDate + `</td>
<td>` + c.Instagram + `</td>
<td style="` + waStyle + `">` + waStatus + `</td>
<td>
<button type="button" onclick="document.getElementById('editLead` + strconv.FormatInt(c.CustomerID, 10) + `').style.display='table-row'">Edit</button>
<form method="DELETE" style="display:inline" hx-delete="/leads/` + strconv.FormatInt(c.CustomerID, 10) + `" hx-target="closest tr">
<button type="submit">Delete</button>
</form>
</td>
</tr>
<tr id="editLead` + strconv.FormatInt(c.CustomerID, 10) + `" class="edit-row">
<td colspan="6">
<form hx-put="/leads/` + strconv.FormatInt(c.CustomerID, 10) + `" hx-target="#leadList" hx-swap="innerHTML">
<input type="text" name="name" value="` + c.Name + `">
<input type="tel" name="phone" value="` + c.Phone + `">
<input type="date" name="birth_date" value="` + c.BirthDate + `">
<input type="text" name="instagram" value="` + c.Instagram + `">
<button type="submit">Save</button>
</form>
</td>
</tr>`))
}
w.Write([]byte(`</tbody></table>
<p><a href="/">Back to Home</a> | <a href="/clients">Back to Clients</a></p>
</body></html>`))
}
func (a *App) UpdateLead(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm()
_, err := a.DB.Exec(
"UPDATE customers SET name = ?, phone = ?, birth_date = ?, instagram = ? WHERE customer_id = ? AND client_id IN (SELECT client_id FROM clients WHERE account_id = ?)",
r.FormValue("name"), r.FormValue("phone"), r.FormValue("birth_date"), r.FormValue("instagram"), id, accountID,
)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
a.ListLeads(w, r)
}
func (a *App) DeleteLead(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
_, err := a.DB.Exec(
"DELETE FROM customers WHERE customer_id = ? AND client_id IN (SELECT client_id FROM clients WHERE account_id = ?)",
id, accountID,
)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte("OK"))
}
func (a *App) LeadsConnectPage(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID, _ := strconv.ParseInt(r.URL.Query().Get("client_id"), 10, 64)
client, err := db.GetClientByID(a.DB, accountID, clientID)
if err != nil {
http.Error(w, "Client not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html>
<html>
<head>
<title>Connect WhatsApp</title>
<script src="https://unpkg.com/[email protected]"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/qrcodejs/1.0.0/qrcode.min.js"></script>
<style>
body { font-family: sans-serif; padding: 2rem; text-align: center; }
#qrcode { margin: 2rem auto; display: flex; justify-content: center; }
#status { padding: 1rem; }
</style>
</head>
<body>
<h1>Connect WhatsApp</h1>
<p>Scan the QR code below with your WhatsApp app to connect</p>
<div id="qrcode"></div>
<p id="status">Loading...</p>
<script>
var lastQR = '';
function pollQR() {
fetch('/leads/qr?client_id=` + strconv.FormatInt(client.ClientID, 10) + `')
.then(r => r.json())
.then(data => {
if (data.qr) {
if (data.qr !== lastQR) {
lastQR = data.qr;
document.getElementById('qrcode').innerHTML = '';
new QRCode(document.getElementById('qrcode'), {
text: data.qr,
width: 256,
height: 256
});
}
document.getElementById('status').textContent = 'Scan with WhatsApp';
setTimeout(pollQR, 5000);
} else if (data.status === 'ready') {
document.getElementById('status').textContent = 'Connected! Verifying phone...';
document.getElementById('qrcode').innerHTML = '&#10003;';
setTimeout(() => {
fetch('/leads/verify/` + strconv.FormatInt(client.ClientID, 10) + `')
.then(r => r.json())
.then(v => {
var msg = 'WhatsApp: ' + (v.wa_phone || 'unknown');
if (v.match === 'yes') {
document.getElementById('status').textContent = msg + ' — matches ' + (v.client_phone || '') + ' ✓';
document.getElementById('status').style.color = '#28a745';
} else if (v.match === 'no') {
document.getElementById('status').textContent = msg + ' — does NOT match client phone ' + (v.client_phone || '') + ' ⚠';
document.getElementById('status').style.color = '#dc3545';
} else {
document.getElementById('status').textContent = msg + ' (client phone unknown — verify manually)';
}
})
.catch(() => {
document.getElementById('status').textContent = 'Connected! (could not verify phone)';
});
}, 1500);
} else if (data.status === 'error') {
document.getElementById('status').textContent = 'Error: ' + (data.error || 'Unknown') + ' — retrying...';
setTimeout(pollQR, 8000);
} else {
document.getElementById('status').textContent = 'Status: ' + data.status;
setTimeout(pollQR, 5000);
}
})
.catch(err => {
document.getElementById('status').textContent = 'Connection error — retrying...';
setTimeout(pollQR, 5000);
});
}
pollQR();
</script>
<p><a href="/">Back to Home</a> | <a href="/clients">Back to Clients</a></p>
</body></html>`))
}
func jsonEscape(s string) string {
b, _ := json.Marshal(s)
return string(b)
}
func (a *App) LeadsQR(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID, _ := strconv.ParseInt(r.URL.Query().Get("client_id"), 10, 64)
client, err := db.GetClientByID(a.DB, accountID, clientID)
if err != nil {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(http.StatusNotFound)
w.Write([]byte(`{"status":"error","error":"client not found"}`))
return
}
if a.WAConnector == nil {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(http.StatusServiceUnavailable)
w.Write([]byte(`{"status":"error","error":"WhatsApp not configured - contact admin"}`))
return
}
connected, err := a.WAConnector.IsConnected(r.Context(), clientID)
if err != nil {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(`{"client_id":` + strconv.FormatInt(client.ClientID, 10) + `,"status":"error","error":` + jsonEscape(err.Error()) + `}`))
return
}
if connected {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(`{"client_id":` + strconv.FormatInt(client.ClientID, 10) + `,"status":"ready"}`))
return
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
log.Printf("QR: Starting Connect for client %d", clientID)
qrChan, err := a.WAConnector.Connect(context.Background(), clientID)
if err != nil {
log.Printf("QR: Connect returned error for client %d: %v", clientID, err)
w.Write([]byte(`{"client_id":` + strconv.FormatInt(client.ClientID, 10) + `,"status":"error","error":` + jsonEscape(err.Error()) + `}`))
return
}
timeout := time.After(30 * time.Second)
for {
select {
case <-timeout:
log.Printf("QR: Timeout waiting for client %d", clientID)
w.Write([]byte(`{"client_id":` + strconv.FormatInt(client.ClientID, 10) + `,"status":"error","error":` + jsonEscape("timeout waiting for QR code") + `}`))
return
case frame, ok := <-qrChan:
if !ok {
w.Write([]byte(`{"client_id":` + strconv.FormatInt(client.ClientID, 10) + `,"status":"error","error":"connection closed"}`))
return
}
if frame.QR != "" {
w.Write([]byte(`{"client_id":` + strconv.FormatInt(client.ClientID, 10) + `,"qr":` + jsonEscape(frame.QR) + `,"status":"waiting"}`))
return
}
if frame.State == whatsapp.StateConnected {
w.Write([]byte(`{"client_id":` + strconv.FormatInt(client.ClientID, 10) + `,"status":"ready"}`))
return
}
if frame.State == whatsapp.StateFailed {
w.Write([]byte(`{"client_id":` + strconv.FormatInt(client.ClientID, 10) + `,"status":"error","error":` + jsonEscape(frame.Error) + `}`))
return
}
}
}
}
func (a *App) VerifyLead(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID, _ := strconv.ParseInt(chi.URLParam(r, "client_id"), 10, 64)
client, err := db.GetClientByID(a.DB, accountID, clientID)
if err != nil {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(`{"status":"error","error":"client not found"}`))
return
}
match := "unknown"
if client.WhatsAppNumber != "" && client.Phone != "" {
cleanWA := strings.TrimPrefix(client.WhatsAppNumber, "+")
cleanClient := strings.TrimPrefix(client.Phone, "+")
if cleanWA == cleanClient {
match = "yes"
} else {
match = "no"
}
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(`{"status":"ok","wa_phone":"` + jsonEscape(client.WhatsAppNumber) + `","client_phone":"` + jsonEscape(client.Phone) + `","match":"` + match + `","client_name":"` + jsonEscape(client.Name) + `"}`))
}
// --- package-level shims kept for existing tests ---
func ListLeads(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListLeads(w, r)
}
func UpdateLead(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateLead(w, r)
}
func DeleteLead(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteLead(w, r)
}
func LeadsConnectPage(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).LeadsConnectPage(w, r)
}
func LeadsQR(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).LeadsQR(w, r)
}
func VerifyLead(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).VerifyLead(w, r)
}
@@ -0,0 +1,245 @@
package handlers
import (
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"testing"
"time"
"go-crm/internal/whatsapp"
"golang.org/x/crypto/bcrypt"
)
func newQRTestEnv(t *testing.T) (clientID int64, sessionID string, cleanup func()) {
t.Helper()
testDB, cleanupDB := SetupTestDB(t)
DB = testDB
WAConnector = whatsapp.NewFakeConnector()
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "QR Test Account", string(hashedPassword), time.Now().Unix(),
)
var accountID int64
testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
sessionID = "qr-test-session"
testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, time.Now().Add(time.Hour).Unix(),
)
testDB.QueryRow(
"INSERT INTO clients (account_id, name, phone, created_at) VALUES (?, ?, ?, ?) RETURNING client_id",
accountID, "QR Test Client", "+5521999999999", time.Now().Unix(),
).Scan(&clientID)
return clientID, sessionID, cleanupDB
}
func TestLeadsQR_FirstPollReturnsQRCode(t *testing.T) {
clientID, sessionID, cleanup := newQRTestEnv(t)
defer cleanup()
req := httptest.NewRequest(http.MethodGet, "/leads/qr?client_id="+strconv.FormatInt(clientID, 10), nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
LeadsQR(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
}
var resp map[string]interface{}
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("invalid JSON: %v — body: %s", err, w.Body.String())
}
if resp["qr"] == nil || resp["qr"] == "" {
t.Errorf("expected non-empty qr field, got: %v", resp)
}
if resp["status"] != "waiting" {
t.Errorf("expected status=waiting, got: %v", resp["status"])
}
}
func TestLeadsQR_AlreadyConnectedReturnsReady(t *testing.T) {
clientID, sessionID, cleanup := newQRTestEnv(t)
defer cleanup()
// Mark the client as connected in the fake connector.
WAConnector.(*whatsapp.FakeConnector).MarkConnected(clientID)
req := httptest.NewRequest(http.MethodGet, "/leads/qr?client_id="+strconv.FormatInt(clientID, 10), nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
LeadsQR(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
}
var resp map[string]interface{}
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("invalid JSON: %v", err)
}
if resp["status"] != "ready" {
t.Errorf("expected status=ready, got: %v", resp["status"])
}
if resp["qr"] != nil {
t.Errorf("expected no qr field when already connected, got: %v", resp["qr"])
}
}
func TestLeadsQR_ConnectorErrorReturnsErrorStatus(t *testing.T) {
clientID, sessionID, cleanup := newQRTestEnv(t)
defer cleanup()
fake := whatsapp.NewFakeConnector()
fake.SetConnectError(fmt.Errorf("connector unavailable"))
WAConnector = fake
req := httptest.NewRequest(http.MethodGet, "/leads/qr?client_id="+strconv.FormatInt(clientID, 10), nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
LeadsQR(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
var resp map[string]interface{}
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("invalid JSON: %v", err)
}
if resp["status"] != "error" {
t.Errorf("expected status=error, got: %v", resp["status"])
}
if resp["error"] == nil || resp["error"] == "" {
t.Errorf("expected non-empty error field")
}
}
func TestLeadsQR_UnknownClientReturnsNotFound(t *testing.T) {
_, sessionID, cleanup := newQRTestEnv(t)
defer cleanup()
req := httptest.NewRequest(http.MethodGet, "/leads/qr?client_id=99999", nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
LeadsQR(w, req)
if w.Code != http.StatusNotFound {
t.Errorf("expected 404, got %d: %s", w.Code, w.Body.String())
}
}
func TestLeadsQR_NoSessionReturnsUnauthorized(t *testing.T) {
clientID, _, cleanup := newQRTestEnv(t)
defer cleanup()
req := httptest.NewRequest(http.MethodGet, "/leads/qr?client_id="+strconv.FormatInt(clientID, 10), nil)
// No session cookie.
w := httptest.NewRecorder()
LeadsQR(w, req)
// /leads/qr is API-mode: returns JSON {"error":"unauthorized"}, not a redirect.
body := w.Body.String()
if !strings.Contains(body, "unauthorized") {
t.Errorf("expected unauthorized in response body, got: %s", body)
}
// Must not return a QR code or ready status.
if strings.Contains(body, `"qr"`) || strings.Contains(body, `"ready"`) {
t.Errorf("unauthenticated response must not contain qr or ready: %s", body)
}
}
func TestLeadsQR_WAConnectorNilReturns503(t *testing.T) {
clientID, sessionID, cleanup := newQRTestEnv(t)
defer cleanup()
WAConnector = nil
req := httptest.NewRequest(http.MethodGet, "/leads/qr?client_id="+strconv.FormatInt(clientID, 10), nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
LeadsQR(w, req)
if w.Code != http.StatusServiceUnavailable {
t.Errorf("expected 503, got %d: %s", w.Code, w.Body.String())
}
}
func TestLeadsQR_SecondPollBeforeScanStillReturnsQR(t *testing.T) {
clientID, sessionID, cleanup := newQRTestEnv(t)
defer cleanup()
// Pre-queue two QR frames so both polls have something to read from the shared channel.
fake := WAConnector.(*whatsapp.FakeConnector)
fake.QueueQR(clientID,
whatsapp.QRFrame{QR: "qr-code-poll-1", State: whatsapp.StateWaitingQR},
whatsapp.QRFrame{QR: "qr-code-poll-2", State: whatsapp.StateWaitingQR},
)
// First poll.
req1 := httptest.NewRequest(http.MethodGet, "/leads/qr?client_id="+strconv.FormatInt(clientID, 10), nil)
req1.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w1 := httptest.NewRecorder()
LeadsQR(w1, req1)
var resp1 map[string]interface{}
json.Unmarshal(w1.Body.Bytes(), &resp1)
if resp1["status"] != "waiting" {
t.Fatalf("first poll: expected waiting, got %v — body: %s", resp1["status"], w1.Body.String())
}
// Second poll — same channel reused, second QR frame available.
req2 := httptest.NewRequest(http.MethodGet, "/leads/qr?client_id="+strconv.FormatInt(clientID, 10), nil)
req2.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w2 := httptest.NewRecorder()
LeadsQR(w2, req2)
var resp2 map[string]interface{}
if err := json.Unmarshal(w2.Body.Bytes(), &resp2); err != nil {
t.Fatalf("second poll: invalid JSON: %v — body: %s", err, w2.Body.String())
}
if resp2["status"] == "ready" {
t.Errorf("second poll: got ready before scan — IsConnected/IsLoggedIn mismatch bug present")
}
if resp2["qr"] == nil || resp2["qr"] == "" {
t.Errorf("second poll: expected QR code, got: %v", resp2)
}
}
func TestLeadsQR_QRCodeResponseContainsClientID(t *testing.T) {
clientID, sessionID, cleanup := newQRTestEnv(t)
defer cleanup()
req := httptest.NewRequest(http.MethodGet, "/leads/qr?client_id="+strconv.FormatInt(clientID, 10), nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
LeadsQR(w, req)
body := w.Body.String()
if !strings.Contains(body, strconv.FormatInt(clientID, 10)) {
t.Errorf("response missing client_id: %s", body)
}
}
+35 -24
View File
@@ -10,8 +10,8 @@ import (
"github.com/go-chi/chi/v5" "github.com/go-chi/chi/v5"
) )
func ListPayments(w http.ResponseWriter, r *http.Request) { func (a *App) ListPayments(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -23,19 +23,19 @@ func ListPayments(w http.ResponseWriter, r *http.Request) {
limit = 20 limit = 20
} }
payments, err := db.ListPayments(DB, clientID, limit, offset) payments, err := db.ListPayments(a.DB, clientID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
} }
clients, err := db.ListClients(DB, accountID, limit, offset) clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
} }
customers, err := db.ListCustomers(DB, accountID, clientID, limit, offset) customers, err := db.ListCustomers(a.DB, accountID, clientID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
@@ -53,7 +53,7 @@ func ListPayments(w http.ResponseWriter, r *http.Request) {
customerNames[cu.CustomerID] = cu.Name customerNames[cu.CustomerID] = cu.Name
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/[email protected]"></script><style>.edit-row{display:none}</style></head><body><h1>Payments</h1><button class="btn" onclick="document.getElementById('paymentForm').style.display='block'">Add Payment</button><div id="paymentForm" style="display:none; margin-top:1rem;"><form hx-post="/payments" hx-target="#paymentList"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><select name="customer_id" required><option value="">Select Customer</option>` + customerOptions + `</select><input type="checkbox" name="has_paid"><label>Paid</label><input type="number" name="amount" placeholder="Amount" step="0.01"><input type="date" name="payment_date"><select name="payment_method"><option value="">Select Payment Method</option><option value="PIX">PIX</option><option value="Dinheiro">Dinheiro</option><option value="Débito">Débito</option><option value="Crédito à Vista">Crédito à Vista</option><option value="Parcelado">Parcelado</option><option value="Boleto">Boleto</option><option value="Transferência Bancária">Transferência Bancária</option></select><button type="submit">Add</button></form></div><table><thead><tr><th>Client</th><th>Customer</th><th>Amount</th><th>Paid</th><th>Date</th><th>Method</th><th>Actions</th></tr></thead><tbody id="paymentList">`)) w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/[email protected]"></script><style>.edit-row{display:none}</style></head><body><h1>Payments</h1><button class="btn" onclick="document.getElementById('paymentForm').style.display='block'">Add Payment</button><div id="paymentForm" style="display:none; margin-top:1rem;"><form hx-post="/payments" hx-target="#paymentList"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><select name="customer_id" required><option value="">Select Customer</option>` + customerOptions + `</select><input type="checkbox" name="has_paid"><label>Paid</label><input type="number" name="amount" placeholder="Amount" step="0.01"><input type="date" name="payment_date"><select name="payment_method"><option value="">Select Payment Method</option><option value="PIX">PIX</option><option value="Dinheiro">Dinheiro</option><option value="Débito">Débito</option><option value="Crédito à Vista">Crédito à Vista</option><option value="Parcelado">Parcelado</option><option value="Boleto">Boleto</option><option value="Transferência Bancária">Transferência Bancária</option></select><button type="submit">Add</button></form></div><table><thead><tr><th>Client</th><th>Customer</th><th>Amount</th><th>Paid</th><th>Date</th><th>Method</th><th>Actions</th></tr></thead><tbody id="paymentList">`))
for _, p := range payments { for _, p := range payments {
paid := "No" paid := "No"
@@ -73,8 +73,8 @@ func ListPayments(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`</tbody></table></body></html>`)) w.Write([]byte(`</tbody></table></body></html>`))
} }
func CreatePayment(w http.ResponseWriter, r *http.Request) { func (a *App) CreatePayment(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -97,7 +97,7 @@ func CreatePayment(w http.ResponseWriter, r *http.Request) {
CreatedAt: time.Now().Unix(), CreatedAt: time.Now().Unix(),
} }
if err := payment.Create(DB); err != nil { if err := payment.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
} }
@@ -105,8 +105,8 @@ func CreatePayment(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func ViewPayment(w http.ResponseWriter, r *http.Request) { func (a *App) ViewPayment(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -114,19 +114,19 @@ func ViewPayment(w http.ResponseWriter, r *http.Request) {
id, _ := strconv.ParseInt(r.URL.Query().Get("id"), 10, 64) id, _ := strconv.ParseInt(r.URL.Query().Get("id"), 10, 64)
var p db.Payment var p db.Payment
var hasPaid int var hasPaid int
err := DB.QueryRow("SELECT payment_id, client_id, customer_id, schedule_id, has_paid, amount, payment_date, payment_method, created_at FROM payments WHERE payment_id = ?", id).Scan(&p.PaymentID, &p.ClientID, &p.CustomerID, &p.ScheduleID, &hasPaid, &p.Amount, &p.PaymentDate, &p.PaymentMethod, &p.CreatedAt) err := a.DB.QueryRow("SELECT payment_id, client_id, customer_id, schedule_id, has_paid, amount, payment_date, payment_method, created_at FROM payments WHERE payment_id = ?", id).Scan(&p.PaymentID, &p.ClientID, &p.CustomerID, &p.ScheduleID, &hasPaid, &p.Amount, &p.PaymentDate, &p.PaymentMethod, &p.CreatedAt)
if err != nil { if err != nil {
http.Error(w, "Payment not found", http.StatusNotFound) http.Error(w, "Payment not found", http.StatusNotFound)
return return
} }
p.HasPaid = hasPaid == 1 p.HasPaid = hasPaid == 1
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><body><h1>Payment</h1><p>Amount: ` + strconv.FormatFloat(p.Amount, 'f', 2, 64) + `</p><p>Paid: ` + strconv.FormatBool(p.HasPaid) + `</p><p>Method: ` + p.PaymentMethod + `</p><a href="/payments">Back</a></body></html>`)) w.Write([]byte(`<!DOCTYPE html><body><h1>Payment</h1><p>Amount: ` + strconv.FormatFloat(p.Amount, 'f', 2, 64) + `</p><p>Paid: ` + strconv.FormatBool(p.HasPaid) + `</p><p>Method: ` + p.PaymentMethod + `</p><a href="/payments">Back</a></body></html>`))
} }
func UpdatePayment(w http.ResponseWriter, r *http.Request) { func (a *App) UpdatePayment(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -137,7 +137,7 @@ func UpdatePayment(w http.ResponseWriter, r *http.Request) {
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64) customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
amount, _ := strconv.ParseFloat(r.FormValue("amount"), 64) amount, _ := strconv.ParseFloat(r.FormValue("amount"), 64)
hasPaid := r.FormValue("has_paid") == "on" hasPaid := r.FormValue("has_paid") == "on"
_, err := DB.Exec("UPDATE payments SET client_id=?, customer_id=?, has_paid=?, amount=?, payment_date=?, payment_method=? WHERE payment_id=?", clientID, customerID, hasPaid, amount, r.FormValue("payment_date"), r.FormValue("payment_method"), id) _, err := a.DB.Exec("UPDATE payments SET client_id=?, customer_id=?, has_paid=?, amount=?, payment_date=?, payment_method=? WHERE payment_id=?", clientID, customerID, hasPaid, amount, r.FormValue("payment_date"), r.FormValue("payment_method"), id)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
@@ -145,19 +145,30 @@ func UpdatePayment(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func DeletePayment(w http.ResponseWriter, r *http.Request) { func (a *App) DeletePayment(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(r.URL.Query().Get("id"), 10, 64) id, _ := strconv.ParseInt(r.URL.Query().Get("id"), 10, 64)
DB.Exec("DELETE FROM payments WHERE payment_id = ?", id) a.DB.Exec("DELETE FROM payments WHERE payment_id = ?", id)
} }
func boolToStr(b bool) string { // --- package-level shims kept for existing tests ---
if b {
return "Yes" func ListPayments(w http.ResponseWriter, r *http.Request) {
} (&App{DB: DB, WAConnector: WAConnector}).ListPayments(w, r)
return "No" }
func CreatePayment(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreatePayment(w, r)
}
func ViewPayment(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewPayment(w, r)
}
func UpdatePayment(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdatePayment(w, r)
}
func DeletePayment(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeletePayment(w, r)
} }
+96 -63
View File
@@ -10,8 +10,8 @@ import (
"github.com/go-chi/chi/v5" "github.com/go-chi/chi/v5"
) )
func ListQuestions(w http.ResponseWriter, r *http.Request) { func (a *App) ListQuestions(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -23,19 +23,19 @@ func ListQuestions(w http.ResponseWriter, r *http.Request) {
limit = 20 limit = 20
} }
questions, err := db.ListQuestions(DB, clientID, limit, offset) questions, err := db.ListQuestions(a.DB, clientID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
} }
clients, err := db.ListClients(DB, accountID, limit, offset) clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
} }
customers, err := db.ListCustomers(DB, accountID, clientID, limit, offset) customers, err := db.ListCustomers(a.DB, accountID, clientID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
@@ -53,7 +53,7 @@ func ListQuestions(w http.ResponseWriter, r *http.Request) {
customerNames[cu.CustomerID] = cu.Name customerNames[cu.CustomerID] = cu.Name
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/[email protected]"></script><style>.edit-row{display:none}</style></head><body><h1>Questions</h1><button class="btn" onclick="document.getElementById('questionForm').style.display='block'">Add Question</button><div id="questionForm" style="display:none; margin-top:1rem;"><form hx-post="/questions" hx-target="#questionList"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><select name="customer_id" required><option value="">Select Customer</option>` + customerOptions + `</select><textarea name="question" placeholder="Question" required></textarea><select name="status"><option value="pending">Pending</option><option value="answered">Answered</option></select><button type="submit">Add</button></form></div><table><thead><tr><th>Client</th><th>Customer</th><th>Question</th><th>Status</th><th>Actions</th></tr></thead><tbody id="questionList">`)) w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/[email protected]"></script><style>.edit-row{display:none}</style></head><body><h1>Questions</h1><button class="btn" onclick="document.getElementById('questionForm').style.display='block'">Add Question</button><div id="questionForm" style="display:none; margin-top:1rem;"><form hx-post="/questions" hx-target="#questionList"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><select name="customer_id" required><option value="">Select Customer</option>` + customerOptions + `</select><textarea name="question" placeholder="Question" required></textarea><select name="status"><option value="pending">Pending</option><option value="answered">Answered</option></select><button type="submit">Add</button></form></div><table><thead><tr><th>Client</th><th>Customer</th><th>Question</th><th>Status</th><th>Actions</th></tr></thead><tbody id="questionList">`))
for _, q := range questions { for _, q := range questions {
clientName := clientNames[q.ClientID] clientName := clientNames[q.ClientID]
@@ -69,8 +69,8 @@ func ListQuestions(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`</tbody></table></body></html>`)) w.Write([]byte(`</tbody></table></body></html>`))
} }
func CreateQuestion(w http.ResponseWriter, r *http.Request) { func (a *App) CreateQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -81,13 +81,13 @@ func CreateQuestion(w http.ResponseWriter, r *http.Request) {
question := db.Question{ question := db.Question{
ClientID: clientID, ClientID: clientID,
CustomerID: customerID, CustomerID: customerID,
Question: r.FormValue("question"), Question: r.FormValue("question"),
Timestamp: time.Now().Unix(), Timestamp: time.Now().Unix(),
Status: r.FormValue("status"), Status: r.FormValue("status"),
CreatedAt: time.Now().Unix(), CreatedAt: time.Now().Unix(),
} }
if err := question.Create(DB); err != nil { if err := question.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
} }
@@ -95,26 +95,26 @@ func CreateQuestion(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func ViewQuestion(w http.ResponseWriter, r *http.Request) { func (a *App) ViewQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
var q db.Question var q db.Question
err := DB.QueryRow("SELECT question_id, client_id, customer_id, question, timestamp, status, created_at FROM questions WHERE question_id = ?", id).Scan(&q.QuestionID, &q.ClientID, &q.CustomerID, &q.Question, &q.Timestamp, &q.Status, &q.CreatedAt) err := a.DB.QueryRow("SELECT question_id, client_id, customer_id, question, timestamp, status, created_at FROM questions WHERE question_id = ?", id).Scan(&q.QuestionID, &q.ClientID, &q.CustomerID, &q.Question, &q.Timestamp, &q.Status, &q.CreatedAt)
if err != nil { if err != nil {
http.Error(w, "Question not found", http.StatusNotFound) http.Error(w, "Question not found", http.StatusNotFound)
return return
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><body><h1>Question</h1><p>Client ID: ` + strconv.FormatInt(q.ClientID, 10) + `</p><p>Customer ID: ` + strconv.FormatInt(q.CustomerID, 10) + `</p><p>Question: ` + q.Question + `</p><p>Status: ` + q.Status + `</p><a href="/questions">Back</a></body></html>`)) w.Write([]byte(`<!DOCTYPE html><body><h1>Question</h1><p>Client ID: ` + strconv.FormatInt(q.ClientID, 10) + `</p><p>Customer ID: ` + strconv.FormatInt(q.CustomerID, 10) + `</p><p>Question: ` + q.Question + `</p><p>Status: ` + q.Status + `</p><a href="/questions">Back</a></body></html>`))
} }
func UpdateQuestion(w http.ResponseWriter, r *http.Request) { func (a *App) UpdateQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -123,7 +123,7 @@ func UpdateQuestion(w http.ResponseWriter, r *http.Request) {
r.ParseForm() r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64) clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64) customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
_, err := DB.Exec("UPDATE questions SET client_id=?, customer_id=?, question=?, status=? WHERE question_id=?", clientID, customerID, r.FormValue("question"), r.FormValue("status"), id) _, err := a.DB.Exec("UPDATE questions SET client_id=?, customer_id=?, question=?, status=? WHERE question_id=?", clientID, customerID, r.FormValue("question"), r.FormValue("status"), id)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
@@ -131,18 +131,18 @@ func UpdateQuestion(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func DeleteQuestion(w http.ResponseWriter, r *http.Request) { func (a *App) DeleteQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
DB.Exec("DELETE FROM questions WHERE question_id = ?", id) a.DB.Exec("DELETE FROM questions WHERE question_id = ?", id)
} }
func ListAnswers(w http.ResponseWriter, r *http.Request) { func (a *App) ListAnswers(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -154,13 +154,13 @@ func ListAnswers(w http.ResponseWriter, r *http.Request) {
limit = 20 limit = 20
} }
answers, err := db.ListAnswersWithDetails(DB, accountID, questionID, limit, offset) answers, err := db.ListAnswersWithDetails(a.DB, accountID, questionID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
} }
questions, err := db.ListQuestions(DB, 0, limit, offset) questions, err := db.ListQuestions(a.DB, 0, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
@@ -173,7 +173,7 @@ func ListAnswers(w http.ResponseWriter, r *http.Request) {
questionText[q.QuestionID] = q.Question questionText[q.QuestionID] = q.Question
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html> w.Write([]byte(`<!DOCTYPE html>
<html> <html>
<head> <head>
@@ -202,19 +202,19 @@ func ListAnswers(w http.ResponseWriter, r *http.Request) {
</thead> </thead>
<tbody id="answerList"> <tbody id="answerList">
`)) `))
for _, a := range answers { for _, a2 := range answers {
qText := a.QuestionText qText := a2.QuestionText
if qText == "" { if qText == "" {
qText = questionText[a.QuestionID] qText = questionText[a2.QuestionID]
if qText == "" { if qText == "" {
qText = strconv.FormatInt(a.QuestionID, 10) qText = strconv.FormatInt(a2.QuestionID, 10)
} }
} }
clientName := a.ClientName clientName := a2.ClientName
if clientName == "" { if clientName == "" {
clientName = strconv.FormatInt(a.ClientID, 10) clientName = strconv.FormatInt(a2.ClientID, 10)
} }
customerName := a.CustomerName customerName := a2.CustomerName
if customerName == "" { if customerName == "" {
customerName = "Unknown" customerName = "Unknown"
} }
@@ -223,24 +223,24 @@ func ListAnswers(w http.ResponseWriter, r *http.Request) {
<td>` + clientName + `</td> <td>` + clientName + `</td>
<td>` + customerName + `</td> <td>` + customerName + `</td>
<td>` + qText + `</td> <td>` + qText + `</td>
<td>` + a.Answer + `</td> <td>` + a2.Answer + `</td>
<td>` + a.Status + `</td> <td>` + a2.Status + `</td>
<td> <td>
<a href="/answers/` + strconv.FormatInt(a.AnswerID, 10) + `">View</a> <a href="/answers/` + strconv.FormatInt(a2.AnswerID, 10) + `">View</a>
<button type="button" onclick="document.getElementById('editA`+strconv.FormatInt(a.AnswerID, 10)+`').style.display='table-row'">Edit</button> <button type="button" onclick="document.getElementById('editA` + strconv.FormatInt(a2.AnswerID, 10) + `').style.display='table-row'">Edit</button>
<form method="DELETE" style="display:inline" hx-delete="/answers/`+strconv.FormatInt(a.AnswerID, 10)+`" hx-target="closest tr"> <form method="DELETE" style="display:inline" hx-delete="/answers/` + strconv.FormatInt(a2.AnswerID, 10) + `" hx-target="closest tr">
<button type="submit">Delete</button> <button type="submit">Delete</button>
</form> </form>
</td> </td>
</tr> </tr>
<tr id="editA`+strconv.FormatInt(a.AnswerID, 10)+`" class="edit-row" style="display:none"> <tr id="editA` + strconv.FormatInt(a2.AnswerID, 10) + `" class="edit-row" style="display:none">
<td colspan="6"> <td colspan="6">
<form hx-put="/answers/`+strconv.FormatInt(a.AnswerID, 10)+`" hx-target="#answerList" hx-swap="innerHTML"> <form hx-put="/answers/` + strconv.FormatInt(a2.AnswerID, 10) + `" hx-target="#answerList" hx-swap="innerHTML">
<select name="question_id"> <select name="question_id">
<option value="`+strconv.FormatInt(a.QuestionID, 10)+`">`+qText+`</option> <option value="` + strconv.FormatInt(a2.QuestionID, 10) + `">` + qText + `</option>
`+questionOptions+` ` + questionOptions + `
</select> </select>
<textarea name="answer">`+a.Answer+`</textarea> <textarea name="answer">` + a2.Answer + `</textarea>
<button type="submit">Save</button> <button type="submit">Save</button>
</form> </form>
</td> </td>
@@ -253,8 +253,8 @@ func ListAnswers(w http.ResponseWriter, r *http.Request) {
</html>`)) </html>`))
} }
func CreateAnswer(w http.ResponseWriter, r *http.Request) { func (a *App) CreateAnswer(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -263,14 +263,14 @@ func CreateAnswer(w http.ResponseWriter, r *http.Request) {
questionID, _ := strconv.ParseInt(r.FormValue("question_id"), 10, 64) questionID, _ := strconv.ParseInt(r.FormValue("question_id"), 10, 64)
var clientID int64 var clientID int64
err := DB.QueryRow("SELECT client_id FROM questions WHERE question_id = ?", questionID).Scan(&clientID) err := a.DB.QueryRow("SELECT client_id FROM questions WHERE question_id = ?", questionID).Scan(&clientID)
if err != nil { if err != nil {
http.Error(w, "Question not found", http.StatusBadRequest) http.Error(w, "Question not found", http.StatusBadRequest)
return return
} }
var checkID int64 var checkID int64
err = DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID) err = a.DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID)
if err != nil { if err != nil {
http.Error(w, "Invalid question", http.StatusBadRequest) http.Error(w, "Invalid question", http.StatusBadRequest)
return return
@@ -282,10 +282,10 @@ func CreateAnswer(w http.ResponseWriter, r *http.Request) {
Answer: r.FormValue("answer"), Answer: r.FormValue("answer"),
Timestamp: time.Now().Unix(), Timestamp: time.Now().Unix(),
Status: "active", Status: "active",
CreatedAt: time.Now().Unix(), CreatedAt: time.Now().Unix(),
} }
if err := answer.Create(DB); err != nil { if err := answer.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
} }
@@ -293,26 +293,26 @@ func CreateAnswer(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func ViewAnswer(w http.ResponseWriter, r *http.Request) { func (a *App) ViewAnswer(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
var a db.Answer var ans db.Answer
err := DB.QueryRow("SELECT answer_id, client_id, question_id, answer, timestamp, status, created_at FROM answers WHERE answer_id = ?", id).Scan(&a.AnswerID, &a.ClientID, &a.QuestionID, &a.Answer, &a.Timestamp, &a.Status, &a.CreatedAt) err := a.DB.QueryRow("SELECT answer_id, client_id, question_id, answer, timestamp, status, created_at FROM answers WHERE answer_id = ?", id).Scan(&ans.AnswerID, &ans.ClientID, &ans.QuestionID, &ans.Answer, &ans.Timestamp, &ans.Status, &ans.CreatedAt)
if err != nil { if err != nil {
http.Error(w, "Answer not found", http.StatusNotFound) http.Error(w, "Answer not found", http.StatusNotFound)
return return
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><body><h1>Answer</h1><p>Question ID: ` + strconv.FormatInt(a.QuestionID, 10) + `</p><p>Answer: ` + a.Answer + `</p><a href="/answers">Back</a></body></html>`)) w.Write([]byte(`<!DOCTYPE html><body><h1>Answer</h1><p>Question ID: ` + strconv.FormatInt(ans.QuestionID, 10) + `</p><p>Answer: ` + ans.Answer + `</p><a href="/answers">Back</a></body></html>`))
} }
func UpdateAnswer(w http.ResponseWriter, r *http.Request) { func (a *App) UpdateAnswer(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -320,7 +320,7 @@ func UpdateAnswer(w http.ResponseWriter, r *http.Request) {
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm() r.ParseForm()
questionID, _ := strconv.ParseInt(r.FormValue("question_id"), 10, 64) questionID, _ := strconv.ParseInt(r.FormValue("question_id"), 10, 64)
_, err := DB.Exec("UPDATE answers SET question_id=?, answer=? WHERE answer_id=?", questionID, r.FormValue("answer"), id) _, err := a.DB.Exec("UPDATE answers SET question_id=?, answer=? WHERE answer_id=?", questionID, r.FormValue("answer"), id)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
@@ -328,12 +328,45 @@ func UpdateAnswer(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func DeleteAnswer(w http.ResponseWriter, r *http.Request) { func (a *App) DeleteAnswer(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
DB.Exec("DELETE FROM answers WHERE answer_id = ?", id) a.DB.Exec("DELETE FROM answers WHERE answer_id = ?", id)
}
// --- package-level shims kept for existing tests ---
func ListQuestions(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListQuestions(w, r)
}
func CreateQuestion(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreateQuestion(w, r)
}
func ViewQuestion(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewQuestion(w, r)
}
func UpdateQuestion(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateQuestion(w, r)
}
func DeleteQuestion(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteQuestion(w, r)
}
func ListAnswers(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListAnswers(w, r)
}
func CreateAnswer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreateAnswer(w, r)
}
func ViewAnswer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewAnswer(w, r)
}
func UpdateAnswer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateAnswer(w, r)
}
func DeleteAnswer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteAnswer(w, r)
} }
+219
View File
@@ -0,0 +1,219 @@
package handlers
import (
"fmt"
"math"
"net/http"
"time"
)
type serviceCount struct {
Name string
Count int
}
type reportData struct {
TotalLeads int
ServiceCounts []serviceCount
StatusCounts []serviceCount
TotalScheduled int
ConversionRate float64
TotalRevenue float64
TotalSales int
AverageTicket float64
TopServices []serviceCount
MonthLabel string
}
// MonthlyReport renders the monthly performance report for the current month.
// GET /report
func (a *App) MonthlyReport(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID := a.clientIDForAccount(accountID)
if clientID == 0 {
http.Error(w, "No client found for account", http.StatusBadRequest)
return
}
now := time.Now()
monthStart := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location()).Unix()
nextMonth := time.Date(now.Year(), now.Month()+1, 1, 0, 0, 0, 0, now.Location()).Unix()
rd := reportData{MonthLabel: now.Format("January 2006")}
a.DB.QueryRow(
"SELECT COUNT(*) FROM leads WHERE client_id = ? AND created_at >= ? AND created_at < ?",
clientID, monthStart, nextMonth,
).Scan(&rd.TotalLeads)
rows, err := a.DB.Query(
`SELECT service_interest, COUNT(*) as cnt FROM leads
WHERE client_id = ? AND created_at >= ? AND created_at < ?
GROUP BY service_interest ORDER BY cnt DESC`,
clientID, monthStart, nextMonth,
)
if err == nil {
defer rows.Close()
for rows.Next() {
var sc serviceCount
rows.Scan(&sc.Name, &sc.Count)
rd.ServiceCounts = append(rd.ServiceCounts, sc)
}
}
statusRows, err := a.DB.Query(
`SELECT status, COUNT(*) as cnt FROM leads
WHERE client_id = ? AND created_at >= ? AND created_at < ?
GROUP BY status ORDER BY cnt DESC`,
clientID, monthStart, nextMonth,
)
if err == nil {
defer statusRows.Close()
for statusRows.Next() {
var sc serviceCount
statusRows.Scan(&sc.Name, &sc.Count)
rd.StatusCounts = append(rd.StatusCounts, sc)
}
}
a.DB.QueryRow(
"SELECT COUNT(*) FROM leads WHERE client_id = ? AND status = 'Agendou' AND created_at >= ? AND created_at < ?",
clientID, monthStart, nextMonth,
).Scan(&rd.TotalScheduled)
if rd.TotalLeads > 0 {
rd.ConversionRate = math.Round(float64(rd.TotalScheduled)/float64(rd.TotalLeads)*100*10) / 10
}
a.DB.QueryRow(
`SELECT COALESCE(SUM(amount),0), COUNT(*) FROM payments
WHERE client_id = ? AND has_paid = 1 AND created_at >= ? AND created_at < ?`,
clientID, monthStart, nextMonth,
).Scan(&rd.TotalRevenue, &rd.TotalSales)
if rd.TotalSales > 0 {
rd.AverageTicket = math.Round(rd.TotalRevenue/float64(rd.TotalSales)*100) / 100
}
topRows, err := a.DB.Query(
`SELECT s.name, COUNT(*) as cnt
FROM payments p
JOIN scheduling sch ON p.schedule_id = sch.schedule_id
JOIN services s ON sch.service_id = s.service_id
WHERE p.client_id = ? AND p.has_paid = 1 AND p.created_at >= ? AND p.created_at < ?
GROUP BY s.name ORDER BY cnt DESC LIMIT 5`,
clientID, monthStart, nextMonth,
)
if err == nil {
defer topRows.Close()
for topRows.Next() {
var sc serviceCount
topRows.Scan(&sc.Name, &sc.Count)
rd.TopServices = append(rd.TopServices, sc)
}
}
var reviewCount int
a.DB.QueryRow("SELECT COUNT(*) FROM leads WHERE client_id = ? AND needs_review = 1", clientID).Scan(&reviewCount)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprintf(w, `<!DOCTYPE html>
<html>
<head>
<title>Monthly Report — %s</title>
<style>
body { font-family: sans-serif; padding: 1rem; max-width: 900px; margin: 0 auto; }
h1, h2 { color: #333; }
.grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
.card { border: 1px solid #ddd; border-radius: 8px; padding: 1rem; background: #fafafa; }
.card .value { font-size: 2rem; font-weight: bold; color: #2c7be5; }
.card .label { color: #666; font-size: 0.9rem; margin-top: 0.25rem; }
table { border-collapse: collapse; width: 100%%; margin-bottom: 1.5rem; }
th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
th { background: #f5f5f5; }
.badge { background: #dc3545; color: #fff; border-radius: 1rem; padding: 0.2rem 0.6rem; font-size: 0.8rem; }
nav { margin-bottom: 1rem; }
</style>
</head>
<body>
<h1>Monthly Report — %s</h1>
<nav>
<a href="/">Home</a> |
<a href="/leads/review">Review Queue <span class="badge">%d</span></a> |
<a href="/leads/all">All Leads</a> |
<a href="/leads/keywords">Keyword Mapping</a>
</nav>
<h2>Overview</h2>
<div class="grid">
<div class="card"><div class="value">%d</div><div class="label">Total Leads</div></div>
<div class="card"><div class="value">%d</div><div class="label">Agendamentos</div></div>
<div class="card"><div class="value">%.1f%%</div><div class="label">Conversion Rate</div></div>
</div>
<h2>Revenue</h2>
<div class="grid">
<div class="card"><div class="value">R$ %.2f</div><div class="label">Total Month Revenue</div></div>
<div class="card"><div class="value">%d</div><div class="label">Total Sales</div></div>
<div class="card"><div class="value">R$ %.2f</div><div class="label">Average Ticket</div></div>
</div>
<h2>Leads by Service Interest</h2>
%s
<h2>Leads by Status</h2>
%s
<h2>Top 5 Services Sold</h2>
%s
</body></html>`,
rd.MonthLabel,
rd.MonthLabel,
reviewCount,
rd.TotalLeads, rd.TotalScheduled, rd.ConversionRate,
rd.TotalRevenue, rd.TotalSales, rd.AverageTicket,
renderServiceTable(rd.ServiceCounts, rd.TotalLeads),
renderServiceTable(rd.StatusCounts, rd.TotalLeads),
renderTopServicesTable(rd.TopServices),
)
}
func renderServiceTable(counts []serviceCount, total int) string {
if len(counts) == 0 {
return `<p style="color:#888">No data for this month.</p>`
}
out := `<table><thead><tr><th>Name</th><th>Quantity</th><th>%</th></tr></thead><tbody>`
for _, sc := range counts {
pct := 0.0
if total > 0 {
pct = math.Round(float64(sc.Count)/float64(total)*100*10) / 10
}
out += fmt.Sprintf(`<tr><td>%s</td><td>%d</td><td>%.1f%%</td></tr>`,
htmlEscape(sc.Name), sc.Count, pct)
}
out += `</tbody></table>`
return out
}
func renderTopServicesTable(counts []serviceCount) string {
if len(counts) == 0 {
return `<p style="color:#888">No sales data for this month.</p>`
}
out := `<table><thead><tr><th>Service</th><th>Sales</th></tr></thead><tbody>`
for _, sc := range counts {
out += fmt.Sprintf(`<tr><td>%s</td><td>%d</td></tr>`, htmlEscape(sc.Name), sc.Count)
}
out += `</tbody></table>`
return out
}
// --- package-level shim kept for existing tests ---
func MonthlyReport(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).MonthlyReport(w, r)
}
+42 -24
View File
@@ -10,8 +10,8 @@ import (
"github.com/go-chi/chi/v5" "github.com/go-chi/chi/v5"
) )
func ListSchedules(w http.ResponseWriter, r *http.Request) { func (a *App) ListSchedules(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -24,25 +24,25 @@ func ListSchedules(w http.ResponseWriter, r *http.Request) {
limit = 20 limit = 20
} }
schedules, err := db.ListSchedules(DB, clientID, customerID, limit, offset) schedules, err := db.ListSchedules(a.DB, clientID, customerID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
} }
clients, err := db.ListClients(DB, accountID, limit, offset) clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
} }
customers, err := db.ListCustomers(DB, accountID, clientID, limit, offset) customers, err := db.ListCustomers(a.DB, accountID, clientID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
} }
services, err := db.ListServices(DB, accountID, clientID, limit, offset) services, err := db.ListServices(a.DB, accountID, clientID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
@@ -65,7 +65,7 @@ func ListSchedules(w http.ResponseWriter, r *http.Request) {
serviceNames[s.ServiceID] = s.Name serviceNames[s.ServiceID] = s.Name
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/[email protected]"></script><style>.edit-row{display:none}</style></head><body><h1>Scheduling</h1><button class="btn" onclick="document.getElementById('scheduleForm').style.display='block'">Add Schedule</button><div id="scheduleForm" style="display:none; margin-top:1rem;"><form hx-post="/scheduling" hx-target="#scheduleList"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><select name="customer_id" required><option value="">Select Customer</option>` + customerOptions + `</select><select name="service_id" required><option value="">Select Service</option>` + serviceOptions + `</select><input type="date" name="plan_date"><input type="time" name="time"><select name="status"><option value="pending">Pending</option><option value="confirmed">Confirmed</option><option value="cancelled">Cancelled</option></select><button type="submit">Add</button></form></div><table><thead><tr><th>Client</th><th>Customer</th><th>Service</th><th>Date</th><th>Hour</th><th>Status</th><th>Actions</th></tr></thead><tbody id="scheduleList">`)) w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/[email protected]"></script><style>.edit-row{display:none}</style></head><body><h1>Scheduling</h1><button class="btn" onclick="document.getElementById('scheduleForm').style.display='block'">Add Schedule</button><div id="scheduleForm" style="display:none; margin-top:1rem;"><form hx-post="/scheduling" hx-target="#scheduleList"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><select name="customer_id" required><option value="">Select Customer</option>` + customerOptions + `</select><select name="service_id" required><option value="">Select Service</option>` + serviceOptions + `</select><input type="date" name="plan_date"><input type="time" name="time"><select name="status"><option value="pending">Pending</option><option value="confirmed">Confirmed</option><option value="cancelled">Cancelled</option></select><button type="submit">Add</button></form></div><table><thead><tr><th>Client</th><th>Customer</th><th>Service</th><th>Date</th><th>Hour</th><th>Status</th><th>Actions</th></tr></thead><tbody id="scheduleList">`))
for _, s := range schedules { for _, s := range schedules {
clientName := clientNames[s.ClientID] clientName := clientNames[s.ClientID]
@@ -85,8 +85,8 @@ func ListSchedules(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`</tbody></table></body></html>`)) w.Write([]byte(`</tbody></table></body></html>`))
} }
func CreateSchedule(w http.ResponseWriter, r *http.Request) { func (a *App) CreateSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -96,16 +96,16 @@ func CreateSchedule(w http.ResponseWriter, r *http.Request) {
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64) customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
serviceID, _ := strconv.ParseInt(r.FormValue("service_id"), 10, 64) serviceID, _ := strconv.ParseInt(r.FormValue("service_id"), 10, 64)
schedule := db.Schedule{ schedule := db.Schedule{
ClientID: clientID, ClientID: clientID,
CustomerID: customerID, CustomerID: customerID,
ServiceID: serviceID, ServiceID: serviceID,
PlanDate: r.FormValue("plan_date"), PlanDate: r.FormValue("plan_date"),
Time: r.FormValue("time"), Time: r.FormValue("time"),
Status: r.FormValue("status"), Status: r.FormValue("status"),
CreatedAt: time.Now().Unix(), CreatedAt: time.Now().Unix(),
} }
if err := schedule.Create(DB); err != nil { if err := schedule.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
} }
@@ -113,26 +113,26 @@ func CreateSchedule(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func ViewSchedule(w http.ResponseWriter, r *http.Request) { func (a *App) ViewSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
var sch db.Schedule var sch db.Schedule
err := DB.QueryRow("SELECT schedule_id, client_id, customer_id, service_id, plan_date, time, status, created_at FROM scheduling WHERE schedule_id = ?", id).Scan(&sch.ScheduleID, &sch.ClientID, &sch.CustomerID, &sch.ServiceID, &sch.PlanDate, &sch.Time, &sch.Status, &sch.CreatedAt) err := a.DB.QueryRow("SELECT schedule_id, client_id, customer_id, service_id, plan_date, time, status, created_at FROM scheduling WHERE schedule_id = ?", id).Scan(&sch.ScheduleID, &sch.ClientID, &sch.CustomerID, &sch.ServiceID, &sch.PlanDate, &sch.Time, &sch.Status, &sch.CreatedAt)
if err != nil { if err != nil {
http.Error(w, "Schedule not found", http.StatusNotFound) http.Error(w, "Schedule not found", http.StatusNotFound)
return return
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><body><h1>Schedule</h1><p>Client ID: ` + strconv.FormatInt(sch.ClientID, 10) + `</p><p>Customer ID: ` + strconv.FormatInt(sch.CustomerID, 10) + `</p><p>Service ID: ` + strconv.FormatInt(sch.ServiceID, 10) + `</p><p>Date: ` + sch.PlanDate + `</p><p>Time: ` + sch.Time + `</p><p>Status: ` + sch.Status + `</p><a href="/scheduling">Back</a></body></html>`)) w.Write([]byte(`<!DOCTYPE html><body><h1>Schedule</h1><p>Client ID: ` + strconv.FormatInt(sch.ClientID, 10) + `</p><p>Customer ID: ` + strconv.FormatInt(sch.CustomerID, 10) + `</p><p>Service ID: ` + strconv.FormatInt(sch.ServiceID, 10) + `</p><p>Date: ` + sch.PlanDate + `</p><p>Time: ` + sch.Time + `</p><p>Status: ` + sch.Status + `</p><a href="/scheduling">Back</a></body></html>`))
} }
func UpdateSchedule(w http.ResponseWriter, r *http.Request) { func (a *App) UpdateSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -142,7 +142,7 @@ func UpdateSchedule(w http.ResponseWriter, r *http.Request) {
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64) clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64) customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
serviceID, _ := strconv.ParseInt(r.FormValue("service_id"), 10, 64) serviceID, _ := strconv.ParseInt(r.FormValue("service_id"), 10, 64)
_, err := DB.Exec("UPDATE scheduling SET client_id=?, customer_id=?, service_id=?, plan_date=?, time=?, status=? WHERE schedule_id=?", clientID, customerID, serviceID, r.FormValue("plan_date"), r.FormValue("time"), r.FormValue("status"), id) _, err := a.DB.Exec("UPDATE scheduling SET client_id=?, customer_id=?, service_id=?, plan_date=?, time=?, status=? WHERE schedule_id=?", clientID, customerID, serviceID, r.FormValue("plan_date"), r.FormValue("time"), r.FormValue("status"), id)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
@@ -150,12 +150,30 @@ func UpdateSchedule(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func DeleteSchedule(w http.ResponseWriter, r *http.Request) { func (a *App) DeleteSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
DB.Exec("DELETE FROM scheduling WHERE schedule_id = ?", id) a.DB.Exec("DELETE FROM scheduling WHERE schedule_id = ?", id)
}
// --- package-level shims kept for existing tests ---
func ListSchedules(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListSchedules(w, r)
}
func CreateSchedule(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreateSchedule(w, r)
}
func ViewSchedule(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewSchedule(w, r)
}
func UpdateSchedule(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateSchedule(w, r)
}
func DeleteSchedule(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteSchedule(w, r)
} }
+41 -23
View File
@@ -10,8 +10,8 @@ import (
"github.com/go-chi/chi/v5" "github.com/go-chi/chi/v5"
) )
func ListServices(w http.ResponseWriter, r *http.Request) { func (a *App) ListServices(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -23,13 +23,13 @@ func ListServices(w http.ResponseWriter, r *http.Request) {
limit = 20 limit = 20
} }
services, err := db.ListServices(DB, accountID, clientID, limit, offset) services, err := db.ListServices(a.DB, accountID, clientID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
} }
clients, err := db.ListClients(DB, accountID, limit, offset) clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError) http.Error(w, err.Error(), http.StatusInternalServerError)
return return
@@ -40,7 +40,7 @@ func ListServices(w http.ResponseWriter, r *http.Request) {
clientOptions += `<option value="` + strconv.FormatInt(c.ClientID, 10) + `">` + c.Name + `</option>` clientOptions += `<option value="` + strconv.FormatInt(c.ClientID, 10) + `">` + c.Name + `</option>`
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/[email protected]"></script></head><body><h1>Services</h1><button class="btn" onclick="document.getElementById('serviceForm').style.display='block'">Add Service</button><div id="serviceForm" style="display:none; margin-top:1rem;"><form hx-post="/services" hx-target="#serviceList"><input type="text" name="name" placeholder="Service Name" required><input type="number" name="price" placeholder="Price" step="0.01"><textarea name="description" placeholder="Description"></textarea><input type="text" name="duration" placeholder="Duration"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><button type="submit">Add</button></form></div><table><thead><tr><th>Name</th><th>Price</th><th>Duration</th><th>Actions</th></tr></thead><tbody id="serviceList">`)) w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/[email protected]"></script></head><body><h1>Services</h1><button class="btn" onclick="document.getElementById('serviceForm').style.display='block'">Add Service</button><div id="serviceForm" style="display:none; margin-top:1rem;"><form hx-post="/services" hx-target="#serviceList"><input type="text" name="name" placeholder="Service Name" required><input type="number" name="price" placeholder="Price" step="0.01"><textarea name="description" placeholder="Description"></textarea><input type="text" name="duration" placeholder="Duration"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><button type="submit">Add</button></form></div><table><thead><tr><th>Name</th><th>Price</th><th>Duration</th><th>Actions</th></tr></thead><tbody id="serviceList">`))
for _, s := range services { for _, s := range services {
w.Write([]byte(`<tr><td>` + s.Name + `</td><td>` + strconv.FormatFloat(s.Price, 'f', 2, 64) + `</td><td>` + s.Duration + `</td><td><a href="/services/` + strconv.FormatInt(s.ServiceID, 10) + `">View</a><button type="button" onclick="document.getElementById('editServ` + strconv.FormatInt(s.ServiceID, 10) + `').style.display='table-row'">Edit</button><form method="DELETE" style="display:inline" hx-delete="/services/` + strconv.FormatInt(s.ServiceID, 10) + `" hx-target="closest tr"><button type="submit">Delete</button></form></td></tr><tr id="editServ` + strconv.FormatInt(s.ServiceID, 10) + `" style="display:none"><td colspan="4"><form hx-put="/services/` + strconv.FormatInt(s.ServiceID, 10) + `" hx-target="#serviceList" hx-swap="innerHTML"><input type="text" name="name" value="` + s.Name + `"><input type="number" name="price" value="` + strconv.FormatFloat(s.Price, 'f', 2, 64) + `"><textarea name="description">` + s.Description + `</textarea><input type="text" name="duration" value="` + s.Duration + `"><select name="client_id"><option value="` + strconv.FormatInt(s.ClientID, 10) + `">` + s.Name + `</option>` + clientOptions + `</select><button type="submit">Save</button></form></td></tr>`)) w.Write([]byte(`<tr><td>` + s.Name + `</td><td>` + strconv.FormatFloat(s.Price, 'f', 2, 64) + `</td><td>` + s.Duration + `</td><td><a href="/services/` + strconv.FormatInt(s.ServiceID, 10) + `">View</a><button type="button" onclick="document.getElementById('editServ` + strconv.FormatInt(s.ServiceID, 10) + `').style.display='table-row'">Edit</button><form method="DELETE" style="display:inline" hx-delete="/services/` + strconv.FormatInt(s.ServiceID, 10) + `" hx-target="closest tr"><button type="submit">Delete</button></form></td></tr><tr id="editServ` + strconv.FormatInt(s.ServiceID, 10) + `" style="display:none"><td colspan="4"><form hx-put="/services/` + strconv.FormatInt(s.ServiceID, 10) + `" hx-target="#serviceList" hx-swap="innerHTML"><input type="text" name="name" value="` + s.Name + `"><input type="number" name="price" value="` + strconv.FormatFloat(s.Price, 'f', 2, 64) + `"><textarea name="description">` + s.Description + `</textarea><input type="text" name="duration" value="` + s.Duration + `"><select name="client_id"><option value="` + strconv.FormatInt(s.ClientID, 10) + `">` + s.Name + `</option>` + clientOptions + `</select><button type="submit">Save</button></form></td></tr>`))
@@ -48,8 +48,8 @@ func ListServices(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`</tbody></table></body></html>`)) w.Write([]byte(`</tbody></table></body></html>`))
} }
func CreateService(w http.ResponseWriter, r *http.Request) { func (a *App) CreateService(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r) accountID, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -58,7 +58,7 @@ func CreateService(w http.ResponseWriter, r *http.Request) {
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64) clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
var checkID int64 var checkID int64
err := DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID) err := a.DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID)
if err != nil { if err != nil {
http.Error(w, "Invalid client", http.StatusBadRequest) http.Error(w, "Invalid client", http.StatusBadRequest)
return return
@@ -67,14 +67,14 @@ func CreateService(w http.ResponseWriter, r *http.Request) {
price, _ := strconv.ParseFloat(r.FormValue("price"), 64) price, _ := strconv.ParseFloat(r.FormValue("price"), 64)
service := db.Service{ service := db.Service{
ClientID: clientID, ClientID: clientID,
Name: r.FormValue("name"), Name: r.FormValue("name"),
Price: price, Price: price,
Description: r.FormValue("description"), Description: r.FormValue("description"),
Duration: r.FormValue("duration"), Duration: r.FormValue("duration"),
CreatedAt: time.Now().Unix(), CreatedAt: time.Now().Unix(),
} }
if err := service.Create(DB); err != nil { if err := service.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
} }
@@ -82,26 +82,26 @@ func CreateService(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func ViewService(w http.ResponseWriter, r *http.Request) { func (a *App) ViewService(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
var s db.Service var s db.Service
err := DB.QueryRow("SELECT service_id, client_id, name, price, description, duration, created_at FROM services WHERE service_id = ?", id).Scan(&s.ServiceID, &s.ClientID, &s.Name, &s.Price, &s.Description, &s.Duration, &s.CreatedAt) err := a.DB.QueryRow("SELECT service_id, client_id, name, price, description, duration, created_at FROM services WHERE service_id = ?", id).Scan(&s.ServiceID, &s.ClientID, &s.Name, &s.Price, &s.Description, &s.Duration, &s.CreatedAt)
if err != nil { if err != nil {
http.Error(w, "Service not found", http.StatusNotFound) http.Error(w, "Service not found", http.StatusNotFound)
return return
} }
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><body><h1>` + s.Name + `</h1><p>Price: ` + strconv.FormatFloat(s.Price, 'f', 2, 64) + `</p><p>Description: ` + s.Description + `</p><p>Duration: ` + s.Duration + `</p><a href="/services">Back</a></body></html>`)) w.Write([]byte(`<!DOCTYPE html><body><h1>` + s.Name + `</h1><p>Price: ` + strconv.FormatFloat(s.Price, 'f', 2, 64) + `</p><p>Description: ` + s.Description + `</p><p>Duration: ` + s.Duration + `</p><a href="/services">Back</a></body></html>`))
} }
func UpdateService(w http.ResponseWriter, r *http.Request) { func (a *App) UpdateService(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
@@ -110,7 +110,7 @@ func UpdateService(w http.ResponseWriter, r *http.Request) {
r.ParseForm() r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64) clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
price, _ := strconv.ParseFloat(r.FormValue("price"), 64) price, _ := strconv.ParseFloat(r.FormValue("price"), 64)
_, err := DB.Exec("UPDATE services SET client_id=?, name=?, price=?, description=?, duration=? WHERE service_id=?", clientID, r.FormValue("name"), price, r.FormValue("description"), r.FormValue("duration"), id) _, err := a.DB.Exec("UPDATE services SET client_id=?, name=?, price=?, description=?, duration=? WHERE service_id=?", clientID, r.FormValue("name"), price, r.FormValue("description"), r.FormValue("duration"), id)
if err != nil { if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest) http.Error(w, err.Error(), http.StatusBadRequest)
return return
@@ -118,12 +118,30 @@ func UpdateService(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true") w.Header().Set("HX-Refresh", "true")
} }
func DeleteService(w http.ResponseWriter, r *http.Request) { func (a *App) DeleteService(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r) _, ok := a.requireAuth(w, r)
if !ok { if !ok {
return return
} }
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
DB.Exec("DELETE FROM services WHERE service_id = ?", id) a.DB.Exec("DELETE FROM services WHERE service_id = ?", id)
}
// --- package-level shims kept for existing tests ---
func ListServices(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListServices(w, r)
}
func CreateService(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreateService(w, r)
}
func ViewService(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewService(w, r)
}
func UpdateService(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateService(w, r)
}
func DeleteService(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteService(w, r)
} }
+24 -1
View File
@@ -3,10 +3,33 @@ package handlers
import ( import (
"database/sql" "database/sql"
"time" "time"
"go-crm/internal/whatsapp"
"go-crm/pkg/usecase"
) )
func SetupHandlers(db *sql.DB) { // App holds the application dependencies injected at startup.
// All handler methods live on *App, eliminating package-level global state.
type App struct {
DB *sql.DB
LeadService *usecase.LeadService
WAConnector whatsapp.Connector
}
// NewApp constructs an App with the given database, lead service, and WhatsApp connector.
func NewApp(db *sql.DB, leadSvc *usecase.LeadService, wa whatsapp.Connector) *App {
return &App{DB: db, LeadService: leadSvc, WAConnector: wa}
}
// WAConnector is a package-level global kept for backward-compat with existing tests.
// New code should use App.WAConnector via NewApp.
var WAConnector whatsapp.Connector
// SetupHandlers is kept for backward compatibility with existing tests.
// New code should use NewApp directly.
func SetupHandlers(db *sql.DB, wa whatsapp.Connector) {
DB = db DB = db
WAConnector = wa
} }
func getCurrentTimestamp() int64 { func getCurrentTimestamp() int64 {
@@ -0,0 +1,118 @@
package handlers
import (
"net/http"
"net/http/httptest"
"os"
"strings"
"testing"
"time"
"go-crm/internal/db"
"go-crm/internal/whatsapp"
"golang.org/x/crypto/bcrypt"
)
func TestListClientsWhatsAppStatusIndicators(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
testDB, err := db.Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer testDB.Close()
fakeWA := whatsapp.NewFakeConnector()
fakeWA.MarkConnected(1)
DB = testDB
WAConnector = fakeWA
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
_, err = testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create account: %v", err)
}
var accountID int64
err = testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
if err != nil {
t.Fatalf("failed to get account id: %v", err)
}
_, err = testDB.Exec(
"INSERT INTO clients (account_id, name, phone, whatsapp_number, whatsapp_connected, created_at) VALUES (?, ?, ?, ?, ?, ?)",
accountID, "Connected Client", "+5521987654321", "+5521987654321", 1, time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create connected client: %v", err)
}
_, err = testDB.Exec(
"INSERT INTO clients (account_id, name, phone, whatsapp_number, whatsapp_connected, created_at) VALUES (?, ?, ?, ?, ?, ?)",
accountID, "Disconnected Client", "+5521987654322", "+5521987654322", 1, time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create disconnected client: %v", err)
}
_, err = testDB.Exec(
"INSERT INTO clients (account_id, name, phone, created_at) VALUES (?, ?, ?, ?)",
accountID, "No WhatsApp Client", "+5521987654323", time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create no-wa client: %v", err)
}
sessionID := "test-session-status"
expires := time.Now().Add(time.Hour).Unix()
_, err = testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
)
if err != nil {
t.Fatalf("failed to create session: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/clients", nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
ListClients(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, "Connected Client") {
t.Error("expected to find connected client")
}
if !strings.Contains(body, "Disconnected Client") {
t.Error("expected to find disconnected client")
}
if !strings.Contains(body, "No WhatsApp Client") {
t.Error("expected to find no-wa client")
}
if !strings.Contains(body, "Connect") {
t.Error("expected Connect link for clients without active connection")
}
greenDot := `color:#28a745`
if !strings.Contains(body, greenDot) {
t.Error("expected green dot for connected client")
}
}
@@ -0,0 +1,165 @@
package handlers
import (
"context"
"net/http"
"net/http/httptest"
"os"
"strconv"
"strings"
"testing"
"time"
"go-crm/internal/db"
"go-crm/internal/whatsapp"
"github.com/go-chi/chi/v5"
"golang.org/x/crypto/bcrypt"
)
func TestViewClientShowsWhatsAppInfo(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
testDB, err := db.Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer testDB.Close()
fakeWA := whatsapp.NewFakeConnector()
fakeWA.MarkConnected(1)
DB = testDB
WAConnector = fakeWA
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
_, err = testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create account: %v", err)
}
var accountID int64
err = testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
if err != nil {
t.Fatalf("failed to get account id: %v", err)
}
var clientID int64
testDB.QueryRow(
"INSERT INTO clients (account_id, name, phone, whatsapp_number, whatsapp_connected, created_at) VALUES (?, ?, ?, ?, ?, ?) RETURNING client_id",
accountID, "WA Client", "+5521987654321", "+5521987654321", 1, time.Now().Unix(),
).Scan(&clientID)
sessionID := "test-session-viewclient"
expires := time.Now().Add(time.Hour).Unix()
_, err = testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
)
if err != nil {
t.Fatalf("failed to create session: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/clients/"+strconv.FormatInt(clientID, 10), nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
rctx := chi.NewRouteContext()
rctx.URLParams.Add("id", strconv.FormatInt(clientID, 10))
req = req.WithContext(context.WithValue(req.Context(), chi.RouteCtxKey, rctx))
w := httptest.NewRecorder()
ViewClient(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, "+5521987654321") {
t.Error("expected ViewClient to show WhatsApp number")
}
if !strings.Contains(body, "WhatsApp") {
t.Error("expected ViewClient to show WhatsApp label")
}
}
func TestViewClientShowsNotConnected(t *testing.T) {
tmpfile, err := os.CreateTemp("", "test_*.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(tmpfile.Name())
tmpfile.Close()
testDB, err := db.Init(tmpfile.Name())
if err != nil {
t.Fatalf("failed to init db: %v", err)
}
defer testDB.Close()
DB = testDB
WAConnector = whatsapp.NewFakeConnector()
hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
_, err = testDB.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
"[email protected]", "Test Account", string(hashedPassword), time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create account: %v", err)
}
var accountID int64
err = testDB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", "[email protected]").Scan(&accountID)
if err != nil {
t.Fatalf("failed to get account id: %v", err)
}
var clientID int64
testDB.QueryRow(
"INSERT INTO clients (account_id, name, phone, created_at) VALUES (?, ?, ?, ?) RETURNING client_id",
accountID, "No WA Client", "+5521987654322", time.Now().Unix(),
).Scan(&clientID)
sessionID := "test-session-viewclient-no-wa"
expires := time.Now().Add(time.Hour).Unix()
_, err = testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
)
if err != nil {
t.Fatalf("failed to create session: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/clients/"+strconv.FormatInt(clientID, 10), nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
rctx := chi.NewRouteContext()
rctx.URLParams.Add("id", strconv.FormatInt(clientID, 10))
req = req.WithContext(context.WithValue(req.Context(), chi.RouteCtxKey, rctx))
w := httptest.NewRecorder()
ViewClient(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, "WhatsApp") {
t.Error("expected ViewClient to show WhatsApp section even when not connected")
}
if !strings.Contains(body, "Connect") {
t.Error("expected ViewClient to show Connect link when not connected")
}
}
+11
View File
@@ -0,0 +1,11 @@
package middleware
import "net/http"
// ForceUTF8Middleware forces the browser to interpret HTML as UTF-8 for all responses.
func ForceUTF8Middleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
next.ServeHTTP(w, r)
})
}
+73
View File
@@ -0,0 +1,73 @@
// Package parser provides message text parsing utilities for the CRM.
// It extracts structured lead information from raw WhatsApp message text.
package parser
import (
"regexp"
"strings"
"unicode"
"golang.org/x/text/unicode/norm"
)
// ExtractService scans msg for any keyword in the mapping (case-insensitive,
// accent-insensitive) and returns the corresponding service name.
// If no keyword matches, it returns "Não especificou".
//
// mapping is a map[keyword]serviceName loaded from the service_keywords table.
func ExtractService(msg string, mapping map[string]string) string {
normalized := normalizeText(msg)
// Sort by keyword length descending so longer phrases match before shorter ones.
// We iterate the map which has no order, so we do two passes:
// first collect all matches, then pick the longest keyword match.
type match struct {
keyword string
service string
}
var best match
for kw, svc := range mapping {
normKW := normalizeText(kw)
if strings.Contains(normalized, normKW) {
if len(kw) > len(best.keyword) {
best = match{keyword: kw, service: svc}
}
}
}
if best.service != "" {
return best.service
}
return "Não especificou"
}
// NormalizePhone converts a raw WhatsApp phone string to E.164 format (+countrycode...).
// It strips the @s.whatsapp.net suffix, removes non-digit characters, and prepends "+".
func NormalizePhone(raw string) string {
// Strip WhatsApp JID suffix.
if idx := strings.Index(raw, "@"); idx != -1 {
raw = raw[:idx]
}
// Keep only digits.
digits := regexp.MustCompile(`\D`).ReplaceAllString(raw, "")
if digits == "" {
return raw
}
return "+" + digits
}
// normalizeText lowercases and removes accents from s for fuzzy comparison.
func normalizeText(s string) string {
// NFD decomposition splits accented characters into base + combining marks.
t := norm.NFD.String(strings.ToLower(s))
// Remove combining marks (Unicode category Mn).
var b strings.Builder
for _, r := range t {
if unicode.Is(unicode.Mn, r) {
continue
}
b.WriteRune(r)
}
return b.String()
}
+117
View File
@@ -0,0 +1,117 @@
package parser_test
import (
"testing"
"go-crm/internal/parser"
)
func TestExtractService_KnownKeywords(t *testing.T) {
keywords := map[string]string{
"head spa": "Head Spa",
"head-spa": "Head Spa",
"headspa": "Head Spa",
"massagem": "Massagem completa",
"massagem completa": "Massagem completa",
"drenagem": "Drenagem linfatica",
"linfática": "Drenagem linfatica",
"hydra": "Hydra Boost",
"hydra boost": "Hydra Boost",
"henna": "Design Henna",
"design henna": "Design Henna",
"masculino": "Masculino",
"masc": "Masculino",
}
mapping := map[string]string{
"head spa": "Head Spa",
"head-spa": "Head Spa",
"headspa": "Head Spa",
"massagem": "Massagem completa",
"massagem completa": "Massagem completa",
"drenagem": "Drenagem linfatica",
"linfática": "Drenagem linfatica",
"hydra": "Hydra Boost",
"hydra boost": "Hydra Boost",
"henna": "Design Henna",
"design henna": "Design Henna",
"masculino": "Masculino",
"masc": "Masculino",
}
for kw, expected := range keywords {
// Build messages in Portuguese with the keyword embedded in natural phrasing.
messages := []string{
"Olá, gostaria de agendar um " + kw,
"Boa tarde! Quero fazer " + kw + " por favor",
"Quanto custa " + kw + "?",
kw,
}
for _, msg := range messages {
got := parser.ExtractService(msg, mapping)
if got != expected {
t.Errorf("message %q with keyword %q: got %q, want %q", msg, kw, got, expected)
}
}
}
}
func TestExtractService_UnknownMessage_ReturnsNaoEspecificou(t *testing.T) {
mapping := map[string]string{
"massagem": "Massagem completa",
}
messages := []string{
"Olá, tudo bem?",
"Qual o horário de funcionamento?",
"Vocês atendem no sábado?",
"",
}
for _, msg := range messages {
got := parser.ExtractService(msg, mapping)
if got != "Não especificou" {
t.Errorf("message %q: got %q, want %q", msg, got, "Não especificou")
}
}
}
func TestExtractService_CaseInsensitive(t *testing.T) {
mapping := map[string]string{
"head spa": "Head Spa",
"henna": "Design Henna",
}
cases := map[string]string{
"Quero HEAD SPA": "Head Spa",
"HENNA por favor": "Design Henna",
"Head Spa agora": "Head Spa",
}
for msg, expected := range cases {
got := parser.ExtractService(msg, mapping)
if got != expected {
t.Errorf("message %q: got %q, want %q", msg, got, expected)
}
}
}
func TestNormalizePhone(t *testing.T) {
cases := []struct {
raw string
want string
}{
{"[email protected]", "+5511999999999"},
{"5511999999999", "+5511999999999"},
{"+5511999999999", "+5511999999999"},
{"55 11 99999-9999", "+5511999999999"},
{"11999999999", "+11999999999"},
}
for _, c := range cases {
got := parser.NormalizePhone(c.raw)
if got != c.want {
t.Errorf("NormalizePhone(%q) = %q, want %q", c.raw, got, c.want)
}
}
}
+1
View File
@@ -52,6 +52,7 @@ func Layout(title, content string) *template.Template {
<nav> <nav>
<ul> <ul>
<li><a href="/">Home</a></li> <li><a href="/">Home</a></li>
<li><a href="/leads">Leads</a></li>
<li><a href="/clients">Clients</a></li> <li><a href="/clients">Clients</a></li>
<li><a href="/customers">Customers</a></li> <li><a href="/customers">Customers</a></li>
<li><a href="/services">Services</a></li> <li><a href="/services">Services</a></li>
@@ -0,0 +1,41 @@
package whatsapp
import (
"context"
"time"
)
type ConnectionState string
const (
StateDisconnected ConnectionState = "disconnected"
StateConnecting ConnectionState = "connecting"
StateWaitingQR ConnectionState = "waiting_qr"
StateConnected ConnectionState = "connected"
StateFailed ConnectionState = "failed"
)
type QRFrame struct {
QR string
State ConnectionState
Error string
}
type Contact struct {
Phone string
Name string
Message string // raw text of the first/incoming message
FromMe bool
Time time.Time
}
type ContactHandler interface {
OnContact(ctx context.Context, clientID int64, contact Contact) error
}
type Connector interface {
Connect(ctx context.Context, clientID int64) (<-chan QRFrame, error)
Disconnect(ctx context.Context, clientID int64) error
IsConnected(ctx context.Context, clientID int64) (bool, error)
SetClientDB(db interface{})
}
+96
View File
@@ -0,0 +1,96 @@
package whatsapp
import (
"context"
"sync"
)
type FakeConnector struct {
mu sync.RWMutex
connected map[int64]bool
qrChan map[int64]chan QRFrame
qrQueue map[int64][]QRFrame
connectErr error
}
func NewFakeConnector() *FakeConnector {
return &FakeConnector{
connected: make(map[int64]bool),
qrChan: make(map[int64]chan QRFrame),
qrQueue: make(map[int64][]QRFrame),
}
}
func (f *FakeConnector) SetConnectError(err error) {
f.connectErr = err
}
func (f *FakeConnector) QueueQR(clientID int64, frames ...QRFrame) {
f.mu.Lock()
defer f.mu.Unlock()
f.qrQueue[clientID] = append(f.qrQueue[clientID], frames...)
}
func (f *FakeConnector) Connect(ctx context.Context, clientID int64) (<-chan QRFrame, error) {
f.mu.Lock()
defer f.mu.Unlock()
if f.connectErr != nil {
return nil, f.connectErr
}
// Already connected — return immediately.
if f.connected[clientID] {
ch := make(chan QRFrame, 1)
ch <- QRFrame{State: StateConnected}
close(ch)
return ch, nil
}
// QR session already in progress — reuse same channel (mirrors real adapter behaviour).
if ch, ok := f.qrChan[clientID]; ok {
return ch, nil
}
// New session — create channel and seed with QR frame(s).
ch := make(chan QRFrame, 20)
f.qrChan[clientID] = ch
queue := f.qrQueue[clientID]
if len(queue) == 0 {
ch <- QRFrame{QR: "fake-qr-code-for-testing", State: StateWaitingQR}
} else {
for _, frame := range queue {
ch <- frame
}
}
return ch, nil
}
func (f *FakeConnector) Disconnect(ctx context.Context, clientID int64) error {
f.mu.Lock()
defer f.mu.Unlock()
if ch, ok := f.qrChan[clientID]; ok {
close(ch)
delete(f.qrChan, clientID)
}
delete(f.connected, clientID)
delete(f.qrQueue, clientID)
return nil
}
func (f *FakeConnector) IsConnected(ctx context.Context, clientID int64) (bool, error) {
f.mu.RLock()
defer f.mu.RUnlock()
return f.connected[clientID], nil
}
func (f *FakeConnector) MarkConnected(clientID int64) {
f.mu.Lock()
defer f.mu.Unlock()
f.connected[clientID] = true
}
func (f *FakeConnector) SetClientDB(db interface{}) {}
@@ -0,0 +1,36 @@
package whatsapp
import (
"context"
"bytes"
"log"
"os"
"strings"
"testing"
)
func TestPostContactLogsErrorOnFailure(t *testing.T) {
// Capture log output.
var buf bytes.Buffer
log.SetOutput(&buf)
defer log.SetOutput(os.Stderr)
// Create adapter with invalid endpoint (connection refused).
adapter := &WhatsmeowAdapter{
goEndpoint: "http://localhost:1",
internalSecret: "test-secret",
}
contact := Contact{
Phone: "5511999999999",
Name: "Test",
Message: "test message",
}
adapter.postContact(context.Background(), 1, contact, "test-msg-id-123")
output := buf.String()
if !strings.Contains(output, "postContact") {
t.Errorf("expected log to contain 'postContact', got: %s", output)
}
}
@@ -0,0 +1,138 @@
package whatsapp_test
import (
"context"
"fmt"
"testing"
"time"
"go-crm/internal/whatsapp"
)
// TestFakeConnector_FirstConnectReturnsQR verifies that a fresh Connect()
// emits a QR frame before the connected state.
func TestFakeConnector_FirstConnectReturnsQR(t *testing.T) {
fc := whatsapp.NewFakeConnector()
ch, err := fc.Connect(context.Background(), 1)
if err != nil {
t.Fatalf("Connect failed: %v", err)
}
select {
case frame := <-ch:
if frame.QR == "" {
t.Errorf("expected QR code in first frame, got empty QR with state=%s", frame.State)
}
if frame.State != whatsapp.StateWaitingQR {
t.Errorf("expected StateWaitingQR, got %s", frame.State)
}
case <-time.After(500 * time.Millisecond):
t.Fatal("timeout waiting for QR frame")
}
}
// TestFakeConnector_IsConnectedFalseBeforeScan verifies IsConnected returns false
// until MarkConnected is explicitly called — mirrors the IsLoggedIn() semantics.
func TestFakeConnector_IsConnectedFalseBeforeScan(t *testing.T) {
fc := whatsapp.NewFakeConnector()
connected, err := fc.IsConnected(context.Background(), 1)
if err != nil {
t.Fatalf("IsConnected error: %v", err)
}
if connected {
t.Errorf("expected not connected before any scan, got connected=true")
}
// Connect and drain QR frame — still not authenticated.
ch, _ := fc.Connect(context.Background(), 1)
<-ch // consume QR frame
connected, err = fc.IsConnected(context.Background(), 1)
if err != nil {
t.Fatalf("IsConnected error after Connect: %v", err)
}
if connected {
t.Errorf("expected not connected after QR issued but before scan, got connected=true")
}
}
// TestFakeConnector_IsConnectedTrueAfterMarkConnected verifies MarkConnected flips IsConnected.
func TestFakeConnector_IsConnectedTrueAfterMarkConnected(t *testing.T) {
fc := whatsapp.NewFakeConnector()
fc.MarkConnected(1)
connected, err := fc.IsConnected(context.Background(), 1)
if err != nil {
t.Fatalf("IsConnected error: %v", err)
}
if !connected {
t.Errorf("expected connected=true after MarkConnected, got false")
}
}
// TestFakeConnector_ConnectErrorPropagates verifies SetConnectError is returned from Connect.
func TestFakeConnector_ConnectErrorPropagates(t *testing.T) {
fc := whatsapp.NewFakeConnector()
fc.SetConnectError(fmt.Errorf("simulated failure"))
_, err := fc.Connect(context.Background(), 1)
if err == nil {
t.Fatal("expected error from Connect, got nil")
}
}
// TestFakeConnector_QueuedFramesDeliveredInOrder verifies custom QR frames via QueueQR.
func TestFakeConnector_QueuedFramesDeliveredInOrder(t *testing.T) {
fc := whatsapp.NewFakeConnector()
fc.QueueQR(1,
whatsapp.QRFrame{QR: "qr-frame-1", State: whatsapp.StateWaitingQR},
whatsapp.QRFrame{QR: "qr-frame-2", State: whatsapp.StateWaitingQR},
)
ch, err := fc.Connect(context.Background(), 1)
if err != nil {
t.Fatalf("Connect failed: %v", err)
}
first := <-ch
if first.QR != "qr-frame-1" {
t.Errorf("expected qr-frame-1, got %q", first.QR)
}
second := <-ch
if second.QR != "qr-frame-2" {
t.Errorf("expected qr-frame-2, got %q", second.QR)
}
}
// TestFakeConnector_DisconnectClearsState verifies Disconnect removes connected state.
func TestFakeConnector_DisconnectClearsState(t *testing.T) {
fc := whatsapp.NewFakeConnector()
fc.MarkConnected(1)
if err := fc.Disconnect(context.Background(), 1); err != nil {
t.Fatalf("Disconnect error: %v", err)
}
connected, _ := fc.IsConnected(context.Background(), 1)
if connected {
t.Errorf("expected connected=false after Disconnect")
}
}
// TestFakeConnector_MultipleClientsIsolated verifies separate clients don't share state.
func TestFakeConnector_MultipleClientsIsolated(t *testing.T) {
fc := whatsapp.NewFakeConnector()
fc.MarkConnected(1)
connected1, _ := fc.IsConnected(context.Background(), 1)
connected2, _ := fc.IsConnected(context.Background(), 2)
if !connected1 {
t.Errorf("client 1 should be connected")
}
if connected2 {
t.Errorf("client 2 should not be connected")
}
}
+489
View File
@@ -0,0 +1,489 @@
package whatsapp
import (
"bytes"
"context"
"database/sql"
"encoding/json"
"fmt"
"log"
"net/http"
"strconv"
"strings"
"sync"
"time"
_ "github.com/glebarez/go-sqlite"
"go.mau.fi/whatsmeow"
"go.mau.fi/whatsmeow/store/sqlstore"
"go.mau.fi/whatsmeow/types"
"go.mau.fi/whatsmeow/types/events"
waLog "go.mau.fi/whatsmeow/util/log"
)
type WhatsmeowAdapter struct {
mu sync.RWMutex
clients map[int64]*whatsmeow.Client
qrChans map[int64]chan QRFrame // persistent QR channel per client, reused across polls
container *sqlstore.Container
db *sql.DB
goEndpoint string
internalSecret string
appCtx context.Context
}
func NewWhatsmeowAdapter(storePath, goEndpoint, internalSecret string) (*WhatsmeowAdapter, error) {
db, err := sql.Open("sqlite", storePath)
if err != nil {
return nil, fmt.Errorf("failed to open database: %w", err)
}
_, err = db.Exec("PRAGMA foreign_keys = ON")
if err != nil {
return nil, fmt.Errorf("failed to enable foreign keys: %w", err)
}
container := sqlstore.NewWithDB(db, "sqlite", waLog.Stdout("SQL", "DEBUG", true))
if err = container.Upgrade(context.Background()); err != nil {
return nil, fmt.Errorf("failed to upgrade database: %w", err)
}
return &WhatsmeowAdapter{
clients: make(map[int64]*whatsmeow.Client),
qrChans: make(map[int64]chan QRFrame),
container: container,
db: db,
goEndpoint: goEndpoint,
internalSecret: internalSecret,
appCtx: context.Background(),
}, nil
}
func (a *WhatsmeowAdapter) Connect(ctx context.Context, clientID int64) (<-chan QRFrame, error) {
a.mu.Lock()
// Already authenticated — return immediately.
if client, ok := a.clients[clientID]; ok && client.IsLoggedIn() {
a.mu.Unlock()
ch := make(chan QRFrame, 1)
ch <- QRFrame{State: StateConnected}
close(ch)
return ch, nil
}
// QR session already in progress — return the same persistent channel.
// The goroutine keeps writing QR codes to it; each poll reads the latest one.
if ch, ok := a.qrChans[clientID]; ok {
a.mu.Unlock()
log.Printf("WA-Connect: Reusing existing QR session for client %d", clientID)
return ch, nil
}
// Read stored JID before releasing lock.
jid, _ := a.getJIDFromDBLocked(clientID)
a.mu.Unlock()
// Try to resume a previously paired session (no QR needed).
if jid != "" {
if ch, err := a.resumeSession(clientID, jid); err == nil {
return ch, nil
}
log.Printf("WA-Connect: Resume failed for client %d, starting QR flow", clientID)
// Clear stale JID so we don't retry resume on every poll.
a.clearJIDFromDB(clientID)
}
// Start a fresh QR session — all network I/O, no lock held.
return a.startQRSession(clientID)
}
// resumeSession attempts to reconnect a previously paired device using its stored JID.
func (a *WhatsmeowAdapter) resumeSession(clientID int64, jid string) (<-chan QRFrame, error) {
parsedJID, err := types.ParseJID(jid)
if err != nil {
return nil, err
}
device, err := a.container.GetDevice(a.appCtx, parsedJID)
if err != nil || device == nil {
return nil, fmt.Errorf("device not found")
}
client := whatsmeow.NewClient(device, waLog.Stdout("Client-"+strconv.FormatInt(clientID, 10), "DEBUG", true))
a.mu.Lock()
a.clients[clientID] = client
a.mu.Unlock()
if err := client.Connect(); err != nil {
a.mu.Lock()
delete(a.clients, clientID)
a.mu.Unlock()
return nil, err
}
a.addMessageHandler(client, clientID)
ch := make(chan QRFrame, 1)
ch <- QRFrame{State: StateConnected}
close(ch)
return ch, nil
}
// startQRSession creates a fresh device, initiates the WhatsApp WebSocket connection,
// and returns a persistent channel that emits QR frames. All network I/O without holding mutex.
// The channel is stored in a.qrChans so subsequent polls reuse it without restarting the session.
func (a *WhatsmeowAdapter) startQRSession(clientID int64) (<-chan QRFrame, error) {
device := a.container.NewDevice()
log.Printf("WA-Connect: Created device for client %d", clientID)
client := whatsmeow.NewClient(device, waLog.Stdout("Client-"+strconv.FormatInt(clientID, 10), "DEBUG", true))
// GetQRChannel must be called before Connect().
log.Printf("WA-Connect: Getting QR channel for client %d", clientID)
qrChan, err := client.GetQRChannel(a.appCtx)
if err != nil {
log.Printf("WA-Connect: GetQRChannel error for client %d: %v", clientID, err)
return nil, fmt.Errorf("failed to get QR channel: %w", err)
}
// ch is buffered so QR codes accumulate; polls read the latest available frame.
// Size 20 = enough to hold multiple rotated QR codes without blocking the goroutine.
ch := make(chan QRFrame, 20)
a.mu.Lock()
a.clients[clientID] = client
a.qrChans[clientID] = ch
a.mu.Unlock()
connectErr := make(chan error, 1)
log.Printf("WA-Connect: Starting Connect() goroutine for client %d", clientID)
go func() {
if err := client.Connect(); err != nil {
log.Printf("WA-Connect: Connect() error for client %d: %v", clientID, err)
connectErr <- err
return
}
log.Printf("WA-Connect: Connect() succeeded for client %d", clientID)
connectErr <- nil
}()
// Wait for WS handshake — lock NOT held, no deadlock risk.
select {
case err := <-connectErr:
if err != nil {
a.mu.Lock()
delete(a.clients, clientID)
delete(a.qrChans, clientID)
a.mu.Unlock()
return nil, fmt.Errorf("failed to connect: %w", err)
}
case <-time.After(15 * time.Second):
log.Printf("WA-Connect: Connect() timeout for client %d", clientID)
a.mu.Lock()
delete(a.clients, clientID)
delete(a.qrChans, clientID)
a.mu.Unlock()
return nil, fmt.Errorf("connection timeout")
}
// Fan-out goroutine: translates whatsmeow events into QRFrames on the persistent ch.
// Outlives any HTTP request. Cleans up qrChans entry on terminal events.
go func() {
defer func() {
a.mu.Lock()
delete(a.qrChans, clientID)
a.mu.Unlock()
close(ch)
}()
for {
select {
case evt, ok := <-qrChan:
if !ok {
return
}
switch evt.Event {
case whatsmeow.QRChannelEventCode:
// Drain stale QR frames so the buffer holds only the latest code.
for len(ch) > 0 {
<-ch
}
ch <- QRFrame{QR: evt.Code, State: StateWaitingQR}
log.Printf("WA-Connect: QR code updated for client %d", clientID)
case whatsmeow.QRChannelSuccess.Event:
go a.syncContacts(client, clientID)
go a.saveJIDOnConnect(client, clientID)
ch <- QRFrame{State: StateConnected}
return
case whatsmeow.QRChannelEventError:
errMsg := "pairing error"
if evt.Error != nil {
errMsg = evt.Error.Error()
}
ch <- QRFrame{State: StateFailed, Error: errMsg}
return
case whatsmeow.QRChannelTimeout.Event:
ch <- QRFrame{State: StateFailed, Error: "QR code timed out"}
return
case whatsmeow.QRChannelClientOutdated.Event:
ch <- QRFrame{State: StateFailed, Error: "client outdated"}
return
default:
ch <- QRFrame{State: StateFailed, Error: "unexpected event: " + evt.Event}
return
}
case <-a.appCtx.Done():
return
}
}
}()
a.addMessageHandler(client, clientID)
return ch, nil
}
func (a *WhatsmeowAdapter) addMessageHandler(client *whatsmeow.Client, clientID int64) {
log.Printf("[Client-%d] Registering message handler", clientID)
client.AddEventHandler(func(evt interface{}) {
log.Printf("[Client-%d] Event received: %T", clientID, evt)
msg, ok := evt.(*events.Message)
if !ok {
return
}
log.Printf("[Client-%d] Message event: IsFromMe=%v, Sender=%v, Chat=%v", clientID, msg.Info.IsFromMe, msg.Info.Sender, msg.Info.Chat)
// Skip messages from our own device.
// Compare sender JID with device JID (LID messages may have IsFromMe=true incorrectly).
if client.Store.ID != nil && msg.Info.Sender.User == client.Store.ID.User {
log.Printf("[Client-%d] Skipping message from own device", clientID)
return
}
// Prefer phone JID (SenderAlt) when sender is LID.
sender := msg.Info.Sender
if sender.Server == types.HiddenUserServer && !msg.Info.SenderAlt.IsEmpty() && msg.Info.SenderAlt.Server == types.DefaultUserServer {
sender = msg.Info.SenderAlt
}
phone := sender.String()
pushName := msg.Info.PushName
// Extract text body from the message.
var text string
if msg.Message != nil {
if c := msg.Message.GetConversation(); c != "" {
text = c
} else if ext := msg.Message.GetExtendedTextMessage(); ext != nil {
text = ext.GetText()
}
}
log.Printf("[Client-%d] Incoming msg from %s (pushName=%s): text=%q", clientID, phone, pushName, text)
if phone != "" {
contact := Contact{
Phone: phone,
Name: pushName,
Message: text,
FromMe: false,
Time: time.Now(),
}
a.postContact(a.appCtx, clientID, contact, msg.Info.ID)
}
})
}
func (a *WhatsmeowAdapter) syncContacts(client *whatsmeow.Client, clientID int64) {
// Note: GetChats API changed in newer versions
// Simplified for build - real implementation would use new API
}
func (a *WhatsmeowAdapter) postContact(ctx context.Context, clientID int64, contact Contact, messageID string) {
payload := map[string]interface{}{
"client_id": clientID,
"name": contact.Name,
"phone": contact.Phone,
"message": contact.Message,
"message_id": messageID,
}
body, _ := json.Marshal(payload)
httpBody := bytes.NewReader(body)
req, _ := http.NewRequestWithContext(ctx, "POST", a.goEndpoint+"/leads/ingest", httpBody)
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.Header.Set("X-Internal-Secret", a.internalSecret)
log.Printf("[Client-%d] postContact payload: %s", clientID, string(body))
httpClient := &http.Client{Timeout: 10 * time.Second}
resp, err := httpClient.Do(req)
if err != nil {
log.Printf("postContact failed to ingest lead for client %d: %v", clientID, err)
return
}
defer resp.Body.Close()
if resp.StatusCode >= 400 {
log.Printf("postContact ingest failed for client %d: status %d", clientID, resp.StatusCode)
} else {
log.Printf("[Client-%d] postContact success: status %d", clientID, resp.StatusCode)
}
}
func (a *WhatsmeowAdapter) getJIDFromDB(clientID int64) (string, error) {
a.mu.RLock()
db := a.db
a.mu.RUnlock()
return a.queryJID(db, clientID)
}
// getJIDFromDBLocked reads JID from DB; caller must hold a.mu (read or write).
func (a *WhatsmeowAdapter) getJIDFromDBLocked(clientID int64) (string, error) {
return a.queryJID(a.db, clientID)
}
func (a *WhatsmeowAdapter) queryJID(db *sql.DB, clientID int64) (string, error) {
if db == nil {
return "", nil
}
var jid string
err := db.QueryRow("SELECT whatsapp_jid FROM clients WHERE client_id = ?", clientID).Scan(&jid)
if err == sql.ErrNoRows {
return "", nil
}
if err != nil {
return "", err
}
return jid, nil
}
func (a *WhatsmeowAdapter) getDeviceFromStore(jid string) interface{} {
return nil
}
func (a *WhatsmeowAdapter) saveJIDOnConnect(client *whatsmeow.Client, clientID int64) {
if client.Store.ID == nil {
return
}
jid := client.Store.ID.User
if jid == "" {
return
}
phone := strings.Split(jid, "@")[0]
_ = a.SaveJID(clientID, jid)
_ = a.saveWhatsAppNumber(clientID, phone)
_ = a.markConnected(clientID)
}
func (a *WhatsmeowAdapter) saveWhatsAppNumber(clientID int64, phone string) error {
a.mu.RLock()
db := a.db
a.mu.RUnlock()
if db == nil {
return nil
}
_, err := db.Exec("UPDATE clients SET whatsapp_number = ? WHERE client_id = ?", phone, clientID)
return err
}
func (a *WhatsmeowAdapter) markConnected(clientID int64) error {
a.mu.RLock()
db := a.db
a.mu.RUnlock()
if db == nil {
return nil
}
_, err := db.Exec("UPDATE clients SET whatsapp_connected = 1 WHERE client_id = ?", clientID)
return err
}
func (a *WhatsmeowAdapter) Disconnect(ctx context.Context, clientID int64) error {
a.mu.Lock()
defer a.mu.Unlock()
client, ok := a.clients[clientID]
if ok {
client.Disconnect()
delete(a.clients, clientID)
}
delete(a.qrChans, clientID)
return nil
}
func (a *WhatsmeowAdapter) clearJIDFromDB(clientID int64) {
a.mu.RLock()
db := a.db
a.mu.RUnlock()
if db != nil {
db.Exec("UPDATE clients SET whatsapp_jid = '' WHERE client_id = ?", clientID)
}
}
func (a *WhatsmeowAdapter) SetClientDB(db interface{}) {
a.mu.Lock()
defer a.mu.Unlock()
a.db = db.(*sql.DB)
}
func (a *WhatsmeowAdapter) SaveJID(clientID int64, jid string) error {
a.mu.RLock()
db := a.db
a.mu.RUnlock()
if db == nil {
return nil
}
_, err := db.Exec("UPDATE clients SET whatsapp_jid = ? WHERE client_id = ?", jid, clientID)
return err
}
func (a *WhatsmeowAdapter) GetJID(clientID int64) (string, error) {
a.mu.RLock()
db := a.db
a.mu.RUnlock()
if db == nil {
return "", nil
}
var jid string
err := db.QueryRow("SELECT whatsapp_jid FROM clients WHERE client_id = ?", clientID).Scan(&jid)
if err == sql.ErrNoRows {
return "", nil
}
return jid, err
}
func (a *WhatsmeowAdapter) IsConnected(ctx context.Context, clientID int64) (bool, error) {
if a == nil {
return false, fmt.Errorf("adapter not initialized")
}
a.mu.RLock()
client, ok := a.clients[clientID]
a.mu.RUnlock()
if ok && client != nil && client.IsLoggedIn() {
return true, nil
}
// No client in memory — try to resume from stored JID.
jid, err := a.getJIDFromDB(clientID)
if err != nil || jid == "" {
return false, nil
}
// Attempt to reconnect silently.
if ch, err := a.Connect(ctx, clientID); err == nil {
for frame := range ch {
if frame.State == StateConnected {
return true, nil
}
if frame.State == StateFailed {
break
}
}
}
return false, nil
}
+134 -55
View File
@@ -4,109 +4,188 @@ import (
"fmt" "fmt"
"log" "log"
"net/http" "net/http"
"strconv"
"go-crm/config"
"go-crm/internal/db" "go-crm/internal/db"
"go-crm/internal/handlers" "go-crm/internal/handlers"
"go-crm/internal/templates" "go-crm/internal/templates"
wa "go-crm/internal/whatsapp"
"go-crm/pkg/repo"
"go-crm/pkg/usecase"
"github.com/go-chi/chi/v5" "github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware" "github.com/go-chi/chi/v5/middleware"
"github.com/go-chi/cors"
) )
func main() { func main() {
database, err := db.Init("/workspace/data/go-crm.db") fmt.Println("main: starting db init")
database, err := db.Init(config.DatabasePath())
fmt.Println("main: db init returned")
if err != nil { if err != nil {
log.Fatalf("Failed to initialize database: %v", err) log.Fatalf("Failed to initialize database: %v", err)
} }
defer database.Close() defer database.Close()
handlers.SetupHandlers(database) fmt.Println("main: initializing WhatsApp adapter")
waConnector, err := wa.NewWhatsmeowAdapter(config.WhatsAppStorePath(), config.HTTPServerEndpoint(), config.InternalSecret())
fmt.Println("main: WhatsApp adapter init returned")
if err != nil {
log.Printf("Warning: failed to initialize WhatsApp connector: %v", err)
waConnector = nil
} else {
waConnector.SetClientDB(database)
}
// App is the single dependency-injection container.
// All handler methods receive DB and WAConnector through it,
// eliminating package-level global state.
// Build our clean-arch layers for leads
leadRepo := repo.NewSQLiteLeadRepository(database)
leadSvc := usecase.NewLeadService(leadRepo)
app := handlers.NewApp(database, leadSvc, waConnector)
// Also populate legacy globals so existing tests continue to work.
handlers.SetupHandlers(database, waConnector)
r := chi.NewRouter() r := chi.NewRouter()
r.Use(middleware.Logger) r.Use(middleware.Logger)
r.Use(middleware.Recoverer) r.Use(middleware.Recoverer)
r.Use(middleware.RequestID) r.Use(middleware.RequestID)
r.Use(cors.Handler(cors.Options{
AllowedOrigins: []string{"*"},
AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"},
AllowedHeaders: []string{"Accept", "Content-Type", "X-Internal-Secret", "Origin"},
ExposedHeaders: []string{"Content-Length", "Content-Type"},
AllowCredentials: false,
MaxAge: 86400,
}))
templates.Init() templates.Init()
r.Get("/", func(w http.ResponseWriter, r *http.Request) { r.Get("/", app.Dashboard)
_, err := handlers.GetAccountID(r)
if err != nil {
http.Redirect(w, r, "/auth/login", http.StatusFound)
return
}
w.Header().Set("Content-Type", "text/html")
w.Write([]byte(`<!DOCTYPE html><html><head><title>Dashboard</title></head><body><h1>Welcome to CRM</h1><nav><a href="/clients">Clients</a> | <a href="/customers">Customers</a> | <a href="/services">Services</a> | <a href="/scheduling">Scheduling</a> | <a href="/payments">Payments</a> | <a href="/questions">Questions</a> | <a href="/answers">Answers</a> | <a href="/auth/account">Account</a> | <form method="POST" action="/auth/logout" style="display:inline"><button type="submit">Logout</button></form></nav></body></html>`))
})
r.Route("/auth", func(r chi.Router) { r.Route("/auth", func(r chi.Router) {
r.Get("/signup", handlers.SignupPage) r.Get("/signup", app.SignupPage)
r.Post("/signup", handlers.Signup) r.Post("/signup", app.Signup)
r.Get("/login", handlers.LoginPage) r.Get("/login", app.LoginPage)
r.Post("/login", handlers.Login) r.Post("/login", app.Login)
r.Post("/logout", handlers.Logout) r.Post("/logout", app.Logout)
r.Get("/account", handlers.AccountPage) r.Get("/account", app.AccountPage)
r.Post("/account", handlers.UpdateAccount) r.Post("/account", app.UpdateAccount)
}) })
r.Route("/clients", func(r chi.Router) { r.Route("/clients", func(r chi.Router) {
r.Get("/", handlers.ListClients) r.Get("/", app.ListClients)
r.Post("/", handlers.CreateClient) r.Post("/", app.CreateClient)
r.Get("/{id}", handlers.ViewClient) r.Get("/{id}", app.ViewClient)
r.Put("/{id}", handlers.UpdateClient) r.Put("/{id}", app.UpdateClient)
r.Delete("/{id}", handlers.DeleteClient) r.Delete("/{id}", app.DeleteClient)
}) })
r.Route("/customers", func(r chi.Router) { r.Route("/customers", func(r chi.Router) {
r.Get("/", handlers.ListCustomers) r.Get("/", app.ListCustomers)
r.Post("/", handlers.CreateCustomer) r.Post("/", app.CreateCustomer)
r.Get("/{id}", handlers.ViewCustomer) r.Get("/{id}", app.ViewCustomer)
r.Put("/{id}", handlers.UpdateCustomer) r.Put("/{id}", app.UpdateCustomer)
r.Delete("/{id}", handlers.DeleteCustomer) r.Delete("/{id}", app.DeleteCustomer)
}) })
r.Get("/debug/cors-test", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(`{"status":"ok","origin":"` + r.Header.Get("Origin") + `"}`))
})
r.Get("/debug/whatsapp", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
if waConnector == nil {
w.Write([]byte(`{"status":"error","error":"WhatsApp connector not initialized"}`))
return
}
w.Write([]byte(`{"status":"ok","message":"WhatsApp connector initialized"}`))
})
r.Get("/debug/net-test", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
resp, err := http.Get("https://www.google.com")
if err != nil {
w.Write([]byte(`{"status":"error","error":` + err.Error() + `}`))
return
}
defer resp.Body.Close()
w.Write([]byte(`{"status":"ok","code":` + strconv.Itoa(resp.StatusCode) + `}`))
})
r.Route("/leads", func(r chi.Router) {
r.Get("/", app.ListLeads)
r.Get("/connect", app.LeadsConnectPage)
r.Get("/qr", app.LeadsQR)
r.Get("/verify/{client_id}", app.VerifyLead)
r.Put("/{id}", app.UpdateLead)
r.Delete("/{id}", app.DeleteLead)
// Lead pipeline
r.Post("/ingest", app.IngestLead)
r.Get("/review", app.LeadReviewQueue)
r.Put("/{id}/review", app.ConfirmLeadReview)
r.Get("/all", app.LeadAllList)
r.Delete("/{id}", app.DeleteLeadNew)
// Keyword management
r.Get("/keywords", app.LeadKeywordsPage)
r.Post("/keywords", app.AddServiceKeyword)
r.Delete("/keywords/{id}", app.DeleteServiceKeywordHandler)
// Status management
r.Post("/statuses", app.AddLeadStatusHandler)
r.Delete("/statuses/{id}", app.DeleteLeadStatusHandler)
})
r.Get("/report", app.MonthlyReport)
r.Route("/services", func(r chi.Router) { r.Route("/services", func(r chi.Router) {
r.Get("/", handlers.ListServices) r.Get("/", app.ListServices)
r.Post("/", handlers.CreateService) r.Post("/", app.CreateService)
r.Get("/{id}", handlers.ViewService) r.Get("/{id}", app.ViewService)
r.Put("/{id}", handlers.UpdateService) r.Put("/{id}", app.UpdateService)
r.Delete("/{id}", handlers.DeleteService) r.Delete("/{id}", app.DeleteService)
}) })
r.Route("/scheduling", func(r chi.Router) { r.Route("/scheduling", func(r chi.Router) {
r.Get("/", handlers.ListSchedules) r.Get("/", app.ListSchedules)
r.Post("/", handlers.CreateSchedule) r.Post("/", app.CreateSchedule)
r.Get("/{id}", handlers.ViewSchedule) r.Get("/{id}", app.ViewSchedule)
r.Put("/{id}", handlers.UpdateSchedule) r.Put("/{id}", app.UpdateSchedule)
r.Delete("/{id}", handlers.DeleteSchedule) r.Delete("/{id}", app.DeleteSchedule)
}) })
r.Route("/payments", func(r chi.Router) { r.Route("/payments", func(r chi.Router) {
r.Get("/", handlers.ListPayments) r.Get("/", app.ListPayments)
r.Post("/", handlers.CreatePayment) r.Post("/", app.CreatePayment)
r.Get("/{id}", handlers.ViewPayment) r.Get("/{id}", app.ViewPayment)
r.Put("/{id}", handlers.UpdatePayment) r.Put("/{id}", app.UpdatePayment)
r.Delete("/{id}", handlers.DeletePayment) r.Delete("/{id}", app.DeletePayment)
}) })
r.Route("/questions", func(r chi.Router) { r.Route("/questions", func(r chi.Router) {
r.Get("/", handlers.ListQuestions) r.Get("/", app.ListQuestions)
r.Post("/", handlers.CreateQuestion) r.Post("/", app.CreateQuestion)
r.Get("/{id}", handlers.ViewQuestion) r.Get("/{id}", app.ViewQuestion)
r.Put("/{id}", handlers.UpdateQuestion) r.Put("/{id}", app.UpdateQuestion)
r.Delete("/{id}", handlers.DeleteQuestion) r.Delete("/{id}", app.DeleteQuestion)
}) })
r.Route("/answers", func(r chi.Router) { r.Route("/answers", func(r chi.Router) {
r.Get("/", handlers.ListAnswers) r.Get("/", app.ListAnswers)
r.Post("/", handlers.CreateAnswer) r.Post("/", app.CreateAnswer)
r.Get("/{id}", handlers.ViewAnswer) r.Get("/{id}", app.ViewAnswer)
r.Put("/{id}", handlers.UpdateAnswer) r.Put("/{id}", app.UpdateAnswer)
r.Delete("/{id}", handlers.DeleteAnswer) r.Delete("/{id}", app.DeleteAnswer)
}) })
fmt.Println("main: ready to serve")
fmt.Println("CRM server running on http://localhost:8080") fmt.Println("CRM server running on http://localhost:8080")
log.Fatal(http.ListenAndServe(":8080", r)) log.Fatal(http.ListenAndServe(":8080", r))
} }
+31
View File
@@ -0,0 +1,31 @@
// Package domain defines core business entities and interfaces.
package domain
import "context"
// Lead represents a customer lead with service interest, status, and payment info.
type Lead struct {
LeadID int64 `json:"lead_id"`
ClientID int64 `json:"client_id"`
Name string `json:"name"`
PhoneRaw string `json:"phone_raw"`
PhoneNormalized string `json:"phone_normalized"`
ServiceInterest string `json:"service_interest"`
Status string `json:"status"`
NeedsReview bool `json:"needs_review"`
AppointmentDate string `json:"appointment_date,omitempty"`
AppointmentTime string `json:"appointment_time,omitempty"`
PaymentStatus string `json:"payment_status"`
PaymentAmount float64 `json:"payment_amount,omitempty"`
PaymentDate string `json:"payment_date,omitempty"`
CreatedAt int64 `json:"created_at"`
LastContactAt int64 `json:"last_contact_at"`
}
// LeadRepository defines persistence operations for leads.
type LeadRepository interface {
// ListAll retrieves all leads for a client, with pagination.
ListAll(ctx context.Context, clientID int64, limit, offset int) ([]Lead, error)
// Update saves changes to an existing lead.
Update(ctx context.Context, lead Lead) error
}
+78
View File
@@ -0,0 +1,78 @@
// Package repo provides SQLite implementations of repository interfaces.
package repo
import (
"context"
"database/sql"
"fmt"
"go-crm/pkg/domain"
)
// SQLiteLeadRepository implements domain.LeadRepository using SQLite.
type SQLiteLeadRepository struct {
DB *sql.DB
}
// NewSQLiteLeadRepository returns a new SQLiteLeadRepository.
func NewSQLiteLeadRepository(db *sql.DB) *SQLiteLeadRepository {
return &SQLiteLeadRepository{DB: db}
}
// ListAll retrieves leads for a client with pagination.
func (r *SQLiteLeadRepository) ListAll(ctx context.Context, clientID int64, limit, offset int) ([]domain.Lead, error) {
query := `SELECT lead_id, client_id, name, phone_raw, phone_normalized,
service_interest, status, needs_review,
COALESCE(appointment_date,''), COALESCE(appointment_time,''), payment_status,
COALESCE(payment_amount,0), COALESCE(payment_date,''), created_at, last_contact_at
FROM leads WHERE client_id = ?
ORDER BY created_at DESC LIMIT ? OFFSET ?`
rows, err := r.DB.QueryContext(ctx, query, clientID, limit, offset)
if err != nil {
return nil, fmt.Errorf("ListAll query error: %w", err)
}
defer rows.Close()
var leads []domain.Lead
for rows.Next() {
var l domain.Lead
var needsReview int
if err := rows.Scan(
&l.LeadID, &l.ClientID, &l.Name, &l.PhoneRaw, &l.PhoneNormalized,
&l.ServiceInterest, &l.Status, &needsReview,
&l.AppointmentDate, &l.AppointmentTime, &l.PaymentStatus,
&l.PaymentAmount, &l.PaymentDate, &l.CreatedAt, &l.LastContactAt,
); err != nil {
return nil, fmt.Errorf("ListAll scan error: %w", err)
}
l.NeedsReview = needsReview == 1
leads = append(leads, l)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("ListAll rows error: %w", err)
}
return leads, nil
}
// Update saves changes to an existing lead.
func (r *SQLiteLeadRepository) Update(ctx context.Context, lead domain.Lead) error {
_, err := r.DB.ExecContext(ctx,
`UPDATE leads SET name=?, service_interest=?, status=?, needs_review=?,
appointment_date=?, appointment_time=?, payment_status=?, payment_amount=?, payment_date=?
WHERE lead_id=? AND client_id=?`,
lead.Name, lead.ServiceInterest, lead.Status, boolToInt(lead.NeedsReview),
lead.AppointmentDate, lead.AppointmentTime, lead.PaymentStatus, lead.PaymentAmount, lead.PaymentDate,
lead.LeadID, lead.ClientID,
)
if err != nil {
return fmt.Errorf("Update lead error: %w", err)
}
return nil
}
func boolToInt(b bool) int {
if b {
return 1
}
return 0
}
+28
View File
@@ -0,0 +1,28 @@
// Package usecase implements application business logic.
package usecase
import (
"context"
"go-crm/pkg/domain"
)
// LeadService coordinates lead-related business rules.
type LeadService struct {
Repo domain.LeadRepository
}
// NewLeadService constructs a LeadService with the given repository.
func NewLeadService(repo domain.LeadRepository) *LeadService {
return &LeadService{Repo: repo}
}
// ListAllLeads returns paginated leads for a client.
func (s *LeadService) ListAllLeads(ctx context.Context, clientID int64, limit, offset int) ([]domain.Lead, error) {
return s.Repo.ListAll(ctx, clientID, limit, offset)
}
// UpdateLead applies updates to a lead.
func (s *LeadService) UpdateLead(ctx context.Context, lead domain.Lead) error {
return s.Repo.Update(ctx, lead)
}
+8
View File
@@ -0,0 +1,8 @@
#!/bin/bash
# Run all go-crm tests
# Usage: ./run-tests.sh
# Or: make test
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$SCRIPT_DIR"
go test ./... -v "$@"
+21
View File
@@ -0,0 +1,21 @@
#!/usr/bin/env bash
set -euo pipefail
# Simple local development runner for go-crm
# For junior-friendly setup: no Docker, no file watchers, just plain Go.
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
APP_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
DEV_DATA_DIR="${DEV_DATA_DIR:-$APP_ROOT/.dev-data}"
mkdir -p "$DEV_DATA_DIR"
export CRM_DATABASE_PATH="${CRM_DATABASE_PATH:-$DEV_DATA_DIR/go-crm.db}"
export CRM_WHATSAPP_STORE_PATH="${CRM_WHATSAPP_STORE_PATH:-$DEV_DATA_DIR/whatsapp.db}"
export CRM_HTTP_ENDPOINT="${CRM_HTTP_ENDPOINT:-http://localhost:8080}"
export CRM_INTERNAL_SECRET="${CRM_INTERNAL_SECRET:-internal-secret}"
cd "$APP_ROOT"
echo "Starting go-crm..."
go run main.go
+1228 -485
View File
File diff suppressed because it is too large. Load diff
+2 -2
View File
@@ -13,10 +13,10 @@
}, },
"dependencies": { "dependencies": {
"better-sqlite3": "^12.8.0", "better-sqlite3": "^12.8.0",
"node-cron": "3.0.3", "node-cron": "^4.2.1",
"qrcode-terminal": "0.12.0", "qrcode-terminal": "0.12.0",
"sql.js": "1.10.2", "sql.js": "1.10.2",
"whatsapp-web.js": "1.23.0" "whatsapp-web.js": "^1.34.7"
}, },
"devDependencies": { "devDependencies": {
"@babel/preset-env": "^7.29.2", "@babel/preset-env": "^7.29.2",
+9
View File
@@ -0,0 +1,9 @@
#!/usr/bin/env node
// whatsapp-sync entrypoint stub
// This file exists so `npm run start` and `npm run dev` do not fail.
// To run the one-off JSONL sync: `npm run sync`
// To start the WhatsApp->CRM integration: `node src/whatsapp-leads.js`
console.log('whatsapp-sync service stub. No long-running logic implemented.');
console.log('Use `npm run sync` to fetch messages, or `node src/whatsapp-leads.js` to start WhatsApp->CRM sync.');
+176
View File
@@ -0,0 +1,176 @@
const { Client, LocalAuth } = require('whatsapp-web.js');
const fs = require('fs');
const path = require('path');
const http = require('http');
function normalizePhone(phone) {
if (!phone) return '';
phone = phone.replace(/[^\d+]/g, '');
if (!phone.startsWith('+')) {
if (phone.length === 10) {
return '+1' + phone;
} else if (phone.length === 11) {
return '+' + phone;
}
}
return phone;
}
function isGroupChat(msg) {
return msg.key?.remoteJid?.includes('@g');
}
module.exports = { normalizePhone, isGroupChat };
var clientID, goEndpoint, internalSecret;
function logEvent(event, data) {
console.log(JSON.stringify({
timestamp: Date.now(),
event,
client_id: clientID,
...data,
}));
}
function postCustomer(data) {
const postData = JSON.stringify(data);
const url = new URL('/customers', goEndpoint);
const options = {
hostname: url.hostname,
port: url.port || 8080,
path: url.pathname,
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Content-Length': Buffer.byteLength(postData),
'X-Internal-Secret': internalSecret,
},
};
const req = http.request(options, (res) => {
let body = '';
res.on('data', chunk => body += chunk);
res.on('end', () => {
logEvent('customer_synced', { phone: data.phone, success: res.statusCode === 200 });
});
});
req.on('error', (err) => {
logEvent('error', { message: err.message });
});
req.write(postData);
req.end();
}
async function syncChat(client, chat) {
const messages = await chat.fetchMessages({ limit: 100 });
for (const msg of messages) {
if (!msg.fromMe && msg.type === 'chat') {
const phone = normalizePhone(msg.from);
if (phone) {
postCustomer({
client_id: parseInt(clientID),
name: phone,
phone: phone,
});
}
}
}
}
async function main() {
const args = process.argv.slice(2);
clientID = args.find(a => a.startsWith('--client-id='))?.split('=')[1] || args[0];
goEndpoint = args.find(a => a.startsWith('--go-endpoint='))?.split('=')[1] || 'http://localhost:8080';
internalSecret = args.find(a => a.startsWith('--secret='))?.split('=')[1] || 'internal-secret';
const authDir = process.env.WA_AUTH_DIR || path.join('.wwebjs_auth', clientID);
if (!fs.existsSync(authDir)) {
fs.mkdirSync(authDir, { recursive: true });
}
logEvent('starting', { auth_dir: authDir });
const client = new Client({
authStrategy: new LocalAuth({
dataPath: authDir,
}),
puppeteer: {
executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || '/usr/bin/chromium',
headless: true,
args: ['--no-sandbox', '--disable-setuid-sandbox'],
},
});
client.on('qr', (qr) => {
logEvent('qr', { qr });
});
client.on('ready', async () => {
logEvent('ready', { timestamp: Date.now() });
const chats = await client.getChats();
for (const chat of chats) {
const isGroup = chat.id.server === 'g';
if (!isGroup) {
await syncChat(client, chat);
}
}
});
client.on('message', async (msg) => {
if (msg.fromMe) return;
const isGroup = msg.key.remoteJid?.includes('@g');
if (isGroup) {
logEvent('group_skipped', { from: msg.from });
return;
}
const phone = normalizePhone(msg.from);
if (phone) {
postCustomer({
client_id: parseInt(clientID),
name: phone,
phone: phone,
});
}
});
client.on('disconnected', (reason) => {
logEvent('disconnected', { reason: String(reason) });
process.exit(1);
});
client.on('auth_failure', (err) => {
logEvent('auth_failure', { error: String(err), stack: err?.stack });
process.exit(1);
});
client.on('authenticated', () => {
logEvent('authenticated', { timestamp: Date.now() });
});
client.on('authed', () => {
logEvent('authed', { timestamp: Date.now() });
});
client.on('error', (err) => {
logEvent('client_error', { error: String(err), stack: err?.stack });
});
try {
await client.initialize();
} catch (err) {
logEvent('error', { message: err.message });
process.exit(1);
}
}
if (require.main === module) {
main();
}
@@ -0,0 +1,50 @@
const path = require('path');
const fs = require('fs');
describe('whatsapp-leads.js module', () => {
const scriptPath = path.join(__dirname, '../src/whatsapp-leads.js');
test('script file exists', () => {
expect(fs.existsSync(scriptPath)).toBe(true);
});
test('exports normalizePhone function', () => {
const script = require(scriptPath);
expect(typeof script.normalizePhone).toBe('function');
});
test('exports isGroupChat function', () => {
const script = require(scriptPath);
expect(typeof script.isGroupChat).toBe('function');
});
});
describe('WhatsApp message filtering', () => {
const scriptPath = path.join(__dirname, '../src/whatsapp-leads.js');
test('filters out group messages (only 1:1 chats)', () => {
const groupMessage = {
key: { remoteJid: '1234567890@g group' },
message: { conversation: 'Group message' },
};
const personalMessage = {
key: { remoteJid: '[email protected]' },
message: { conversation: 'Personal message' },
};
expect(isGroupChat(groupMessage)).toBe(true);
expect(isGroupChat(personalMessage)).toBe(false);
});
test('normalizes phone numbers', () => {
const script = require(scriptPath);
expect(script.normalizePhone('+5521987654321')).toBe('+5521987654321');
expect(script.normalizePhone('21987654321')).toBe('+21987654321');
expect(script.normalizePhone('')).toBe('');
});
});
function isGroupChat(message) {
return message.key.remoteJid?.includes('@g');
}
+530
View File
@@ -0,0 +1,530 @@
package main
import (
"context"
"database/sql"
"embed"
"encoding/json"
"fmt"
"html/template"
"log/slog"
"net/http"
"os"
"os/signal"
"path/filepath"
"strings"
"sync"
"syscall"
"time"
"github.com/go-chi/chi/v5"
_ "github.com/glebarez/sqlite"
"go.mau.fi/whatsmeow"
"go.mau.fi/whatsmeow/store/sqlstore"
"go.mau.fi/whatsmeow/types"
"go.mau.fi/whatsmeow/types/events"
waLog "go.mau.fi/whatsmeow/util/log"
)
//go:embed templates/*
var templateFS embed.FS
type ConnectionState string
const (
StateDisconnected ConnectionState = "disconnected"
StateConnecting ConnectionState = "connecting"
StateWaitingQR ConnectionState = "waiting_qr"
StateConnected ConnectionState = "connected"
StateFailed ConnectionState = "failed"
)
type Message struct {
ID int64
Phone string
Name string
Message string
MessageID string
Timestamp int64
}
type Event struct {
Type string `json:"type"`
State string `json:"state,omitempty"`
QR string `json:"qr,omitempty"`
Error string `json:"error,omitempty"`
Message *Message `json:"message,omitempty"`
Log string `json:"log,omitempty"`
}
type App struct {
db *sql.DB
client *whatsmeow.Client
container *sqlstore.Container
mu sync.RWMutex
state ConnectionState
currentQR string
eventChan chan Event
logger *slog.Logger
ctx context.Context
cancel context.CancelFunc
dataDir string
}
func main() {
port := os.Getenv("WHATSME_PORT")
if port == "" {
port = "8080"
}
dataDir := os.Getenv("WHATSME_DATA_DIR")
if dataDir == "" {
dataDir = "./whatsme"
}
if err := os.MkdirAll(dataDir, 0755); err != nil {
slog.Error("failed to create data dir", "error", err)
os.Exit(1)
}
logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
ctx, cancel := context.WithCancel(context.Background())
app := &App{
eventChan: make(chan Event, 100),
logger: logger,
ctx: ctx,
cancel: cancel,
dataDir: dataDir,
state: StateDisconnected,
}
if err := app.initDB(); err != nil {
logger.Error("failed to init DB", "error", err)
os.Exit(1)
}
defer app.db.Close()
if err := app.initWhatsApp(); err != nil {
logger.Error("failed to init WhatsApp", "error", err)
os.Exit(1)
}
go app.autoResume()
r := chi.NewRouter()
r.Get("/", app.handleIndex)
r.Get("/events", app.handleEvents)
r.Get("/health", app.handleHealth)
srv := &http.Server{
Addr: ":" + port,
Handler: r,
}
go func() {
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
<-sig
logger.Info("shutting down...")
cancel()
if app.client != nil {
app.client.Disconnect()
}
shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 5*time.Second)
defer shutdownCancel()
srv.Shutdown(shutdownCtx)
}()
logger.Info("starting", "port", port, "data_dir", dataDir)
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
logger.Error("server error", "error", err)
os.Exit(1)
}
}
func (a *App) initDB() error {
dbPath := filepath.Join(a.dataDir, "messages.db")
db, err := sql.Open("sqlite", dbPath)
if err != nil {
return fmt.Errorf("open db: %w", err)
}
if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
return fmt.Errorf("enable foreign keys: %w", err)
}
schema := `
CREATE TABLE IF NOT EXISTS messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
phone TEXT NOT NULL,
name TEXT NOT NULL DEFAULT '',
message TEXT NOT NULL DEFAULT '',
message_id TEXT NOT NULL,
timestamp INTEGER NOT NULL
);
CREATE UNIQUE INDEX IF NOT EXISTS idx_message_id ON messages(message_id);
`
if _, err := db.Exec(schema); err != nil {
return fmt.Errorf("exec schema: %w", err)
}
a.db = db
return nil
}
func (a *App) initWhatsApp() error {
sessionPath := filepath.Join(a.dataDir, "session.db")
db, err := sql.Open("sqlite", sessionPath)
if err != nil {
return fmt.Errorf("open session db: %w", err)
}
if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
return fmt.Errorf("enable foreign keys: %w", err)
}
a.container = sqlstore.NewWithDB(db, "sqlite", waLog.Stdout("SQL", "DEBUG", true))
if err := a.container.Upgrade(a.ctx); err != nil {
return fmt.Errorf("upgrade session db: %w", err)
}
return nil
}
func (a *App) autoResume() {
a.mu.Lock()
stores, err := a.container.GetAllDevices(a.ctx)
a.mu.Unlock()
if err != nil {
a.logger.Error("failed to get stores", "error", err)
return
}
if len(stores) == 0 {
a.logger.Info("no stored session, starting QR flow")
a.startQRFlow()
return
}
a.logger.Info("found stored session, resuming")
a.startQRFlow()
}
func (a *App) startQRFlow() {
device := a.container.NewDevice()
client := whatsmeow.NewClient(device, waLog.Stdout("Client", "DEBUG", true))
a.mu.Lock()
a.client = client
a.state = StateWaitingQR
a.mu.Unlock()
qrChan, err := client.GetQRChannel(a.ctx)
if err != nil {
a.logger.Error("failed to get QR channel", "error", err)
a.setState(StateFailed, "failed to get QR channel")
return
}
if err := client.Connect(); err != nil {
a.logger.Error("failed to connect", "error", err)
a.setState(StateFailed, "connection failed")
return
}
a.addMessageHandler(client)
go func() {
for evt := range qrChan {
switch evt.Event {
case whatsmeow.QRChannelSuccess.Event:
a.logger.Info("WhatsApp connected successfully")
a.setState(StateConnected, "")
return
case whatsmeow.QRChannelEventError:
a.logger.Error("QR error", "error", evt.Error)
a.setState(StateFailed, evt.Error.Error())
return
case whatsmeow.QRChannelTimeout.Event:
a.logger.Info("QR timeout, restarting")
a.setState(StateDisconnected, "QR timed out")
go a.startQRFlow()
return
default:
if evt.Code != "" {
a.mu.Lock()
a.currentQR = evt.Code
a.state = StateWaitingQR
a.mu.Unlock()
a.broadcastQR(evt.Code)
}
}
}
}()
}
func (a *App) setState(state ConnectionState, errMsg string) {
a.mu.Lock()
a.state = state
if errMsg != "" {
a.logger.Info("state changed", "state", state, "error", errMsg)
}
a.mu.Unlock()
a.eventChan <- Event{
Type: "state",
State: string(state),
Error: errMsg,
}
a.eventChan <- Event{
Type: "log",
Log: fmt.Sprintf("[%s] %s", time.Now().Format("15:04:05"), state),
}
if state == StateDisconnected {
go a.startQRFlow()
}
}
func (a *App) broadcastQR(code string) {
a.eventChan <- Event{
Type: "state",
State: string(StateWaitingQR),
QR: code,
}
a.eventChan <- Event{
Type: "log",
Log: fmt.Sprintf("[%s] QR code generated", time.Now().Format("15:04:05")),
}
}
func (a *App) addMessageHandler(client *whatsmeow.Client) {
client.AddEventHandler(func(raw interface{}) {
evt, ok := raw.(*events.Message)
if !ok {
return
}
a.logger.Debug("raw event",
"type", fmt.Sprintf("%T", raw),
"is_from_me", evt.Info.IsFromMe,
"sender", evt.Info.Sender.String(),
"chat", evt.Info.Chat.String(),
"message_id", evt.Info.ID,
"timestamp", evt.Info.Timestamp,
"push_name", evt.Info.PushName,
"sender_server", evt.Info.Sender.Server,
"chat_server", evt.Info.Chat.Server,
"message_type", fmt.Sprintf("%T", evt.Message),
)
if evt.Info.IsFromMe {
a.logger.Info("skipping own message", "message_id", evt.Info.ID)
return
}
if evt.Info.Chat.Server == types.GroupServer {
a.logger.Info("skipping group message", "chat", evt.Info.Chat.String())
return
}
if evt.Info.ID == "" {
a.logger.Info("skipping message with empty ID")
return
}
sender := evt.Info.Sender
phone := sender.User
if phone == "" {
phone = sender.String()
}
if !strings.HasPrefix(phone, "+") {
phone = "+" + phone
}
if strings.HasSuffix(phone, "@s.whatsapp.net") {
phone = strings.TrimSuffix(phone, "@s.whatsapp.net")
phone = "+" + strings.TrimPrefix(phone, "+")
}
pushName := evt.Info.PushName
var text string
if evt.Message != nil {
if c := evt.Message.GetConversation(); c != "" {
text = c
} else if ext := evt.Message.GetExtendedTextMessage(); ext != nil {
text = ext.GetText()
}
}
if text == "" {
a.logger.Info("skipping non-text message", "message_id", evt.Info.ID)
return
}
ts := evt.Info.Timestamp.Unix()
if ts == 0 {
ts = time.Now().Unix()
}
msg := &Message{
Phone: phone,
Name: pushName,
Message: text,
MessageID: evt.Info.ID,
Timestamp: ts,
}
if err := a.saveMessage(msg); err != nil {
a.logger.Error("failed to save message", "error", err)
return
}
a.logger.Info("message saved",
"phone", phone,
"name", pushName,
"message", text,
"message_id", evt.Info.ID,
)
output := map[string]interface{}{
"phone": phone,
"name": pushName,
"message": text,
"message_id": evt.Info.ID,
"timestamp": ts,
}
if b, err := json.Marshal(output); err == nil {
fmt.Println(string(b))
}
a.eventChan <- Event{
Type: "message",
Message: msg,
}
a.eventChan <- Event{
Type: "log",
Log: fmt.Sprintf("[%s] MSG from %s (%s): %s", time.Now().Format("15:04:05"), phone, pushName, text),
}
})
}
func (a *App) saveMessage(msg *Message) error {
_, err := a.db.Exec(
`INSERT OR IGNORE INTO messages (phone, name, message, message_id, timestamp) VALUES (?, ?, ?, ?, ?)`,
msg.Phone, msg.Name, msg.Message, msg.MessageID, msg.Timestamp,
)
return err
}
func (a *App) getMessages() ([]Message, error) {
rows, err := a.db.Query(
`SELECT id, phone, name, message, message_id, timestamp FROM messages ORDER BY timestamp DESC LIMIT 100`,
)
if err != nil {
return nil, err
}
defer rows.Close()
var msgs []Message
for rows.Next() {
var m Message
if err := rows.Scan(&m.ID, &m.Phone, &m.Name, &m.Message, &m.MessageID, &m.Timestamp); err != nil {
return nil, err
}
msgs = append(msgs, m)
}
return msgs, nil
}
func (a *App) handleIndex(w http.ResponseWriter, r *http.Request) {
a.mu.RLock()
state := a.state
currentQR := a.currentQR
a.mu.RUnlock()
msgs, err := a.getMessages()
if err != nil {
a.logger.Error("failed to get messages", "error", err)
http.Error(w, "internal error", http.StatusInternalServerError)
return
}
tmpl, err := template.ParseFS(templateFS, "templates/index.gohtml")
if err != nil {
a.logger.Error("failed to parse template", "error", err)
http.Error(w, "template error", http.StatusInternalServerError)
return
}
data := struct {
State string
QR string
Messages []Message
}{
State: string(state),
QR: currentQR,
Messages: msgs,
}
if err := tmpl.Execute(w, data); err != nil {
a.logger.Error("failed to render template", "error", err)
}
}
func (a *App) handleEvents(w http.ResponseWriter, r *http.Request) {
flusher, ok := w.(http.Flusher)
if !ok {
http.Error(w, "streaming not supported", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("Cache-Control", "no-cache")
w.Header().Set("Connection", "keep-alive")
w.Header().Set("X-Accel-Buffering", "no")
a.mu.RLock()
state := a.state
currentQR := a.currentQR
a.mu.RUnlock()
if state == StateWaitingQR && currentQR != "" {
fmt.Fprintf(w, "event: state\ndata: {\"type\":\"state\",\"state\":\"%s\",\"qr\":\"%s\"}\n\n", state, escapeJSON(currentQR))
flusher.Flush()
} else {
fmt.Fprintf(w, "event: state\ndata: {\"type\":\"state\",\"state\":\"%s\"}\n\n", state)
flusher.Flush()
}
for evt := range a.eventChan {
switch evt.Type {
case "state":
if evt.QR != "" {
fmt.Fprintf(w, "event: state\ndata: {\"type\":\"state\",\"state\":\"%s\",\"qr\":\"%s\",\"error\":\"%s\"}\n\n", evt.State, escapeJSON(evt.QR), evt.Error)
} else {
fmt.Fprintf(w, "event: state\ndata: {\"type\":\"state\",\"state\":\"%s\",\"error\":\"%s\"}\n\n", evt.State, evt.Error)
}
case "message":
if evt.Message != nil {
msgJSON, _ := json.Marshal(evt.Message)
fmt.Fprintf(w, "event: message\ndata: {\"type\":\"message\",\"message\":%s}\n\n", msgJSON)
}
case "log":
fmt.Fprintf(w, "event: log\ndata: {\"type\":\"log\",\"log\":\"%s\"}\n\n", escapeJSON(evt.Log))
}
flusher.Flush()
}
}
func (a *App) handleHealth(w http.ResponseWriter, r *http.Request) {
a.mu.RLock()
state := a.state
a.mu.RUnlock()
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]interface{}{
"status": "ok",
"connected": state == StateConnected,
"state": state,
})
}
func escapeJSON(s string) string {
s = strings.ReplaceAll(s, "\n", "\\n")
s = strings.ReplaceAll(s, "\r", "\\r")
s = strings.ReplaceAll(s, "\t", "\\t")
s = strings.ReplaceAll(s, `"`, `\"`)
return s
}
+23
View File
@@ -0,0 +1,23 @@
//go:build ignore
package main
import (
"os"
"github.com/mdp/qrterminal/v3"
)
func main() {
if len(os.Args) < 2 {
println("usage: go run qr_render.go <code>")
os.Exit(1)
}
config := qrterminal.Config{
Level: qrterminal.M,
Writer: os.Stdout,
BlackChar: qrterminal.BLACK,
WhiteChar: qrterminal.WHITE,
QuietZone: 1,
}
qrterminal.GenerateWithConfig(os.Args[1], config)
}
+23
View File
@@ -0,0 +1,23 @@
//go:build ignore
package main
import (
"os"
"github.com/mdp/qrterminal/v3"
)
func main() {
if len(os.Args) < 2 {
println("usage: go run qr_render2.go <code>")
os.Exit(1)
}
config := qrterminal.Config{
Level: qrterminal.M,
Writer: os.Stdout,
BlackChar: "##",
WhiteChar: " ",
QuietZone: 1,
}
qrterminal.GenerateWithConfig(os.Args[1], config)
}
+244
View File
@@ -0,0 +1,244 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>whatsme</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;700&display=swap" rel="stylesheet">
<script src="https://unpkg.com/[email protected]"></script>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/build/qrcode.min.js"></script>
<style>
*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
html { font-size: 14px; }
body {
font-family: 'JetBrains Mono', monospace;
background: #0a0a0a;
color: #a0a0a0;
min-height: 100vh;
display: flex;
flex-direction: column;
}
header {
border-bottom: 1px solid #1a1a1a;
padding: 0.75rem 1.5rem;
display: flex;
align-items: center;
gap: 1rem;
}
header h1 {
font-size: 1.1rem;
font-weight: 700;
color: #e0e0e0;
letter-spacing: 0.05em;
}
.status-badge {
font-size: 0.75rem;
padding: 0.2rem 0.6rem;
border: 1px solid;
border-radius: 2px;
text-transform: uppercase;
letter-spacing: 0.1em;
}
.status-waiting_qr { color: #d4a017; border-color: #d4a017; }
.status-connected { color: #4ade80; border-color: #4ade80; }
.status-disconnected { color: #f87171; border-color: #f87171; }
.status-failed { color: #f87171; border-color: #f87171; }
.status-connecting { color: #60a5fa; border-color: #60a5fa; }
main {
flex: 1;
display: grid;
grid-template-columns: 1fr 1fr;
grid-template-rows: auto 1fr;
gap: 1px;
background: #1a1a1a;
}
.panel {
background: #0a0a0a;
padding: 1rem;
overflow: hidden;
}
.panel-header {
font-size: 0.7rem;
text-transform: uppercase;
letter-spacing: 0.15em;
color: #505050;
margin-bottom: 0.75rem;
padding-bottom: 0.5rem;
border-bottom: 1px solid #1a1a1a;
}
#qr-panel { grid-column: 1; grid-row: 1; }
#messages-panel { grid-column: 1; grid-row: 2; }
#log-panel { grid-column: 2; grid-row: 1 / span 2; }
#qr-container {
display: flex;
justify-content: center;
align-items: center;
background: #111;
padding: 1rem;
border: 1px solid #1a1a1a;
}
#qr-container canvas {
image-rendering: pixelated;
border: 4px solid #e0e0e0;
}
#messages-list {
display: flex;
flex-direction: column;
gap: 0.5rem;
max-height: calc(100vh - 280px);
overflow-y: auto;
}
.message {
padding: 0.5rem 0.75rem;
border-left: 2px solid #2a2a2a;
background: #0d0d0d;
}
.message:hover { border-left-color: #d4a017; }
.message-phone { color: #d4a017; font-size: 0.8rem; }
.message-name { color: #606060; font-size: 0.7rem; margin-left: 0.5rem; }
.message-text { color: #c0c0c0; margin-top: 0.25rem; font-size: 0.85rem; }
.message-time { color: #404040; font-size: 0.65rem; margin-top: 0.25rem; }
#log-list {
display: flex;
flex-direction: column;
gap: 0.25rem;
max-height: calc(100vh - 120px);
overflow-y: auto;
font-size: 0.75rem;
}
.log-entry { color: #505050; }
.log-entry:last-child { color: #a0a0a0; }
.prompt { color: #4ade80; }
.prompt::before { content: "$ "; }
.empty-state {
color: #303030;
text-align: center;
padding: 2rem;
font-size: 0.8rem;
}
</style>
</head>
<body>
<header>
<h1>whatsme</h1>
<span class="status-badge status-{{.State}}">{{.State}}</span>
</header>
<main>
<div class="panel" id="qr-panel">
<div class="panel-header">QR Code</div>
{{if eq .State "waiting_qr"}}
{{if .QR}}
<div id="qr-container"></div>
<input type="hidden" id="qr-code" value="{{.QR}}">
{{else}}
<div class="empty-state">generating qr code...</div>
{{end}}
{{else if eq .State "connected"}}
<div class="empty-state"><span class="prompt">device connected</span></div>
{{else if eq .State "disconnected"}}
<div class="empty-state"><span class="prompt">reconnecting...</span></div>
{{else if eq .State "failed"}}
<div class="empty-state"><span class="prompt">connection failed</span></div>
{{else}}
<div class="empty-state"><span class="prompt">waiting for connection...</span></div>
{{end}}
</div>
<div class="panel" id="messages-panel">
<div class="panel-header">Messages</div>
<div id="messages-list">
{{if .Messages}}
{{range .Messages}}
<div class="message">
<span class="message-phone">{{.Phone}}</span>
<span class="message-name">{{.Name}}</span>
<div class="message-text">{{.Message}}</div>
<div class="message-time">{{.Timestamp}}</div>
</div>
{{end}}
{{else}}
<div class="empty-state">no messages yet</div>
{{end}}
</div>
</div>
<div class="panel" id="log-panel">
<div class="panel-header">Activity Log</div>
<div id="log-list">
<div class="log-entry"><span class="prompt">whatsme started</span></div>
</div>
</div>
</main>
<script>
const qrContainer = document.getElementById('qr-container');
const qrCodeInput = document.getElementById('qr-code');
function renderQR(code) {
if (!qrContainer) return;
qrContainer.innerHTML = '';
QRCode.toCanvas(qrContainer, code, {
width: 256,
margin: 2,
color: { dark: '#e0e0e0', light: '#0a0a0a' }
}, function (err) {
if (err) console.error(err);
});
}
if (qrCodeInput && qrCodeInput.value) {
renderQR(qrCodeInput.value);
}
const evtSource = new EventSource('/events');
const messagesList = document.getElementById('messages-list');
const logList = document.getElementById('log-list');
const statusBadge = document.querySelector('.status-badge');
evtSource.addEventListener('state', (e) => {
const data = JSON.parse(e.data);
if (data.qr) {
renderQR(data.qr);
}
if (statusBadge) {
statusBadge.textContent = data.state;
statusBadge.className = 'status-badge status-' + data.state;
}
});
evtSource.addEventListener('message', (e) => {
const data = JSON.parse(e.data);
const msg = data.message;
const emptyState = messagesList.querySelector('.empty-state');
if (emptyState) emptyState.remove();
const div = document.createElement('div');
div.className = 'message';
div.innerHTML = `
<span class="message-phone">${msg.Phone}</span>
<span class="message-name">${msg.Name}</span>
<div class="message-text">${msg.Message}</div>
<div class="message-time">${new Date(msg.Timestamp * 1000).toLocaleTimeString()}</div>
`;
messagesList.insertBefore(div, messagesList.firstChild);
});
evtSource.addEventListener('log', (e) => {
const data = JSON.parse(e.data);
const div = document.createElement('div');
div.className = 'log-entry';
div.innerHTML = `<span class="prompt">${data.log}</span>`;
logList.appendChild(div);
logList.scrollTop = logList.scrollHeight;
});
evtSource.onerror = () => {
setTimeout(() => {
const div = document.createElement('div');
div.className = 'log-entry';
div.innerHTML = `<span class="prompt">[sse reconnecting...]</span>`;
logList.appendChild(div);
}, 100);
};
</script>
</body>
</html>
+122
View File
@@ -0,0 +1,122 @@
# PRD: WhatsApp Lead Management for go-crm
---
## Problem Statement
Clients using the go-crm platform need to connect their personal WhatsApp number to capture leads. Currently, there is no way for clients to:
1. Authenticate their WhatsApp account via QR code
2. Automatically capture incoming WhatsApp messages (1:1 chats, not groups) as leads in the CRM
3. Manage these leads (CRUD operations) through the platform
---
## Solution
Add a "Leads" feature to go-crm that allows clients to:
1. Connect their WhatsApp via QR code scanning from the client list
2. Automatically sync incoming WhatsApp messages (not group chats) as leads in the CRM
3. View, edit, and manage these leads through existing CRUD operations
---
## User Stories
1. As a client, I want to see a "QR Connect" button next to my client name in the client list, so that I can initiate WhatsApp connection
2. As a client, I want to scan a QR code with my WhatsApp app to authenticate, so that my WhatsApp gets connected to my CRM account
3. As a client, I want to see my connected WhatsApp phone number displayed in the client list, so that I know I'm connected
4. As a client, I want my incoming WhatsApp messages (not groups) to automatically appear as leads in the CRM, so that I can manage them
5. As a client, I want my existing WhatsApp contacts to sync as leads when I first connect, so that I have my historical data in the CRM
6. As a client, I want to view all my leads in a dedicated "/leads" page, so that I can see my potential customers
7. As a client, I want to search and filter my leads by name or phone number, so that I can find specific contacts quickly
8. As a client, I want to edit lead details (name, phone, birth date, Instagram) from the Leads page, so that I can keep information up to date
9. As a client, I want to delete a lead, so that I can remove spam or unwanted contacts
10. As a client, I want my lead's phone number to be normalized (with country code), so that data is consistent
11. As a client, I want the system to skip group messages from WhatsApp, so that I only get 1:1 chat leads
12. As a client, if I reconnect my WhatsApp, I want the session to be reused, so that I don't need to scan QR every time
13. As a client, if the WhatsApp background process crashes, I want it to automatically restart, so that I don't lose messages
14. As a client, if I receive a message from an existing lead phone number, I want the system to update the existing record (not create duplicates), so that my data stays accurate
15. As a client, I want my leads to display the phone number I connected with as my own, so that I know which WhatsApp is linked
---
## Implementation Decisions
### Architecture
- Go wraps Node.js whatsapp-web.js as a subprocess (spawn-and-keep after connection)
- IPC via stdout JSON lines + HTMX polling for frontend
- Per-client WhatsApp session folder (`.wwebjs_auth/{client_id}/`)
### Database Schema (clients table)
- `whatsapp_number TEXT` — normalized phone number (e.g., `+5521...`)
- `whatsapp_connected INTEGER DEFAULT 0` — connection status (0=false, 1=true)
### Route Structure
- `GET /leads` — list all leads for the logged-in client's account
- `GET /leads/connect?client_id={id}` — QR code display page for connection
- `GET /leads/qr?client_id={id}` — polling endpoint for QR/status (returns current QR string or status)
### Node.js Script (whatsapp-leads.js)
- Spawned per-client with per-client session folder
- Filters group chats (only processes 1:1 messages)
- Upserts on duplicate phone number
- Syncs historical chats + new incoming messages
- Calls Go's existing `POST /customers` endpoint with internal secret header
### Process Lifecycle
- Ephemeral spawn for QR connection flow (spawns, waits for READY, then keeps running)
- Auto-restart if Node.js process exits unexpectedly
### UI Flow
- Client list (`/clients`) shows "Connect" button if `whatsapp_number IS NULL`, otherwise displays connected phone number
- Leads page (`/leads`) shows table of leads with edit/delete actions
### Authentication
- Node.js → Go uses shared internal secret header (`X-Internal-Secret`) to bypass session auth
---
## Testing Decisions
### Test Philosophy
- Tests should verify behavior through public interfaces, not implementation details
- Good tests read like specifications: "client can connect WhatsApp" tells you exactly what capability exists
- Tests should survive internal refactors — if renaming an internal function breaks tests, those tests were testing implementation
### Modules to Test
- Database: Client WhatsApp columns (insert/query)
- Handler: Leads page rendering, connection status display
- Node.js script: JSON output to stdout, group message filtering
### Prior Art
- No existing tests in go-crm to follow; will create new `handlers_test.go` alongside implementation
---
## Out of Scope
- Sending messages back to WhatsApp from the CRM (only receiving/syncing)
- WhatsApp profile pictures/avatars
- Multiple WhatsApp numbers per client (one per client)
- Group management features
- Message notifications/push to mobile
- WhatsApp Web client session restoration across Go server restarts (requires systemd/supervisor)
---
## Further Notes
- Phone numbers are stored normalized (with country code) as received from WhatsApp
- Historical chat sync happens on first connection (all existing 1:1 chats become leads)
- New messages sync in real-time while the Node.js process runs
- If WhatsApp session expires/disconnects, client must reconnect via QR
+44
View File
@@ -0,0 +1,44 @@
module whatsme
go 1.26.2
require (
github.com/glebarez/sqlite v1.11.0
github.com/go-chi/chi/v5 v5.2.5
github.com/mdp/qrterminal/v3 v3.2.1
go.mau.fi/whatsmeow v0.0.0-20260506122147-6a7198d94d26
)
require (
filippo.io/edwards25519 v1.1.0 // indirect
github.com/beeper/argo-go v1.1.2 // indirect
github.com/coder/websocket v1.8.14 // indirect
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/elliotchance/orderedmap/v3 v3.1.0 // indirect
github.com/glebarez/go-sqlite v1.21.2 // indirect
github.com/google/uuid v1.6.0 // indirect
github.com/jinzhu/inflection v1.0.0 // indirect
github.com/jinzhu/now v1.1.5 // indirect
github.com/mattn/go-colorable v0.1.14 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/petermattis/goid v0.0.0-20260330135022-df67b199bc81 // indirect
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
github.com/rs/zerolog v1.35.0 // indirect
github.com/vektah/gqlparser/v2 v2.5.27 // indirect
go.mau.fi/libsignal v0.2.1 // indirect
go.mau.fi/util v0.9.8 // indirect
golang.org/x/crypto v0.50.0 // indirect
golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f // indirect
golang.org/x/net v0.53.0 // indirect
golang.org/x/sync v0.20.0 // indirect
golang.org/x/sys v0.43.0 // indirect
golang.org/x/term v0.42.0 // indirect
golang.org/x/text v0.36.0 // indirect
google.golang.org/protobuf v1.36.11 // indirect
gorm.io/gorm v1.25.7 // indirect
modernc.org/libc v1.22.5 // indirect
modernc.org/mathutil v1.5.0 // indirect
modernc.org/memory v1.5.0 // indirect
modernc.org/sqlite v1.23.1 // indirect
rsc.io/qr v0.2.0 // indirect
)
+94
View File
@@ -0,0 +1,94 @@
filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM=
github.com/agnivade/levenshtein v1.2.1/go.mod h1:QVVI16kDrtSuwcpd0p1+xMC6Z/VfhtCyDIjcwga4/DU=
github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ=
github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8=
github.com/beeper/argo-go v1.1.2 h1:UQI2G8F+NLfGTOmTUI0254pGKx/HUU/etbUGTJv91Fs=
github.com/beeper/argo-go v1.1.2/go.mod h1:M+LJAnyowKVQ6Rdj6XYGEn+qcVFkb3R/MUpqkGR0hM4=
github.com/coder/websocket v1.8.14 h1:9L0p0iKiNOibykf283eHkKUHHrpG7f65OE3BhhO7v9g=
github.com/coder/websocket v1.8.14/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/elliotchance/orderedmap/v3 v3.1.0 h1:j4DJ5ObEmMBt/lcwIecKcoRxIQUEnw0L804lXYDt/pg=
github.com/elliotchance/orderedmap/v3 v3.1.0/go.mod h1:G+Hc2RwaZvJMcS4JpGCOyViCnGeKf0bTYCGTO4uhjSo=
github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9gAXWo=
github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k=
github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw=
github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ=
github.com/go-chi/chi/v5 v5.2.5 h1:Eg4myHZBjyvJmAFjFvWgrqDTXFyOzjj7YIm3L3mu6Ug=
github.com/go-chi/chi/v5 v5.2.5/go.mod h1:X7Gx4mteadT3eDOMTsXzmI4/rwUpOwBHLpAfupzFJP0=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-sqlite3 v1.14.42 h1:MigqEP4ZmHw3aIdIT7T+9TLa90Z6smwcthx+Azv4Cgo=
github.com/mattn/go-sqlite3 v1.14.42/go.mod h1:pjEuOr8IwzLJP2MfGeTb0A35jauH+C2kbHKBr7yXKVQ=
github.com/mdp/qrterminal/v3 v3.2.1 h1:6+yQjiiOsSuXT5n9/m60E54vdgFsw0zhADHhHLrFet4=
github.com/mdp/qrterminal/v3 v3.2.1/go.mod h1:jOTmXvnBsMy5xqLniO0R++Jmjs2sTm9dFSuQ5kpz/SU=
github.com/petermattis/goid v0.0.0-20260330135022-df67b199bc81 h1:WDsQxOJDy0N1VRAjXLpi8sCEZRSGarLWQevDxpTBRrM=
github.com/petermattis/goid v0.0.0-20260330135022-df67b199bc81/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
github.com/rs/zerolog v1.35.0 h1:VD0ykx7HMiMJytqINBsKcbLS+BJ4WYjz+05us+LRTdI=
github.com/rs/zerolog v1.35.0/go.mod h1:EjML9kdfa/RMA7h/6z6pYmq1ykOuA8/mjWaEvGI+jcw=
github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/vektah/gqlparser/v2 v2.5.27 h1:RHPD3JOplpk5mP5JGX8RKZkt2/Vwj/PZv0HxTdwFp0s=
github.com/vektah/gqlparser/v2 v2.5.27/go.mod h1:D1/VCZtV3LPnQrcPBeR/q5jkSQIPti0uYCP/RI0gIeo=
go.mau.fi/libsignal v0.2.1 h1:vRZG4EzTn70XY6Oh/pVKrQGuMHBkAWlGRC22/85m9L0=
go.mau.fi/libsignal v0.2.1/go.mod h1:iVvjrHyfQqWajOUaMEsIfo3IqgVMrhWcPiiEzk7NgoU=
go.mau.fi/util v0.9.8 h1:+/jf8eM2dAT2wx9UidmaneH28r/CSCKCniCyby1qWz8=
go.mau.fi/util v0.9.8/go.mod h1:up/5mbzH2M1pSBNXqRxODn8dg/hEKbLJu92W4/SNAX0=
go.mau.fi/whatsmeow v0.0.0-20260506122147-6a7198d94d26 h1:DyFksXWn7z/NN+TNJ0DomV1/drWjkyiVuJ6RIiy/bo4=
go.mau.fi/whatsmeow v0.0.0-20260506122147-6a7198d94d26/go.mod h1:ijfkzOXauA/Vz/htXEMfOAJSUgglribW5oQeYC9tSSg=
golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI=
golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q=
golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f h1:W3F4c+6OLc6H2lb//N1q4WpJkhzJCK5J6kUi1NTVXfM=
golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f/go.mod h1:J1xhfL/vlindoeF/aINzNzt2Bket5bjo9sdOYzOsU80=
golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
golang.org/x/term v0.42.0 h1:UiKe+zDFmJobeJ5ggPwOshJIVt6/Ft0rcfrXZDLWAWY=
golang.org/x/term v0.42.0/go.mod h1:Dq/D+snpsbazcBG5+F9Q1n2rXV8Ma+71xEjTRufARgY=
golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gorm.io/gorm v1.25.7 h1:VsD6acwRjz2zFxGO50gPO6AkNs7KKnvfzUjHQhZDz/A=
gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE=
modernc.org/libc v1.22.5/go.mod h1:jj+Z7dTNX8fBScMVNRAYZ/jF91K8fdT2hYMThc3YjBY=
modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ=
modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
modernc.org/memory v1.5.0 h1:N+/8c5rE6EqugZwHii4IFsaJ7MUhoWX07J5tC/iI5Ds=
modernc.org/memory v1.5.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU=
modernc.org/sqlite v1.23.1 h1:nrSBg4aRQQwq59JpvGEQ15tNxoO5pX/kUjcRNwSAGQM=
modernc.org/sqlite v1.23.1/go.mod h1:OrDj17Mggn6MhE+iPbBNf7RGKODDE9NFT0f3EwDzJqk=
rsc.io/qr v0.2.0 h1:6vBLea5/NRMVTz8V66gipeLycZMl/+UlFmk8DvqQ6WY=
rsc.io/qr v0.2.0/go.mod h1:IF+uZjkb9fqyeF/4tlBoynqmQxUoPfWEKh921coOuXs=
Binary file not shown.

After

Width:  |  Height:  |  Size: 30 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 31 KiB

+36
View File
@@ -0,0 +1,36 @@
---
name: backend-driven-ui
description: Create distinctive, production-grade frontend interfaces using Golang and Hypermedia (HTMX/Templ). Use this skill to build reactive web components and pages that prioritize performance and maintainability without the complexity of modern JavaScript frameworks.
---
This skill guides the creation of high-end, "vibe-coded" interfaces using a **Golang-centric stack**. It avoids the maintenance burden of React/JS frameworks by leveraging **HTMX** and **Templ**, focusing on server-side logic that delivers rich, interactive client experiences.
## Design Thinking & "Vibe Coding"
Before coding, commit to a BOLD aesthetic direction that feels "hand-crafted" rather than "framework-default":
- **Hypermedia First**: Architecture relies on HTML fragments. Every interaction is a server-side transition, making the app feel incredibly fast and robust.
- **Tone**: Since we are avoiding the "React look," lean into distinctive styles: **High-Tech Industrial**, **Neo-Brutalist**, **Swiss International**, or **Terminal-Core**.
- **The "Vibe"**: Aim for the "vibe coding" energy—fast feedback loops, visible data flowing through the terminal, and interfaces that feel like specialized tools rather than generic SaaS dashboards.
## Frontend Aesthetics Guidelines
Focus on:
- **Typography**: Use characterful fonts that reflect the precision of Go. Lean towards high-quality Monospace (e.g., JetBrains Mono, Berkeley Graphics) for a "tooling" feel, or sophisticated Serifs paired with tight Grotesks for an editorial look.
- **Color & Theme**: Use high-contrast themes. Since this is built with **Tailwind CSS**, use specific color scales (e.g., Zinc, Slate, or custom olive/amber palettes) to avoid the "Tailwind default" blue.
- **Motion (CSS-Only)**: Prioritize CSS transitions and HTMX swapping animations (`htmx-settling`, `htmx-requesting`). Use staggered reveals and smooth opacity fades to mask the server-side round trip, making it feel "instant."
- **Interaction**: Use **HTMX attributes** (`hx-get`, `hx-post`, `hx-target`) to create "Active Search," "Infinite Scroll," and "Inline Editing" patterns that surprise users who expect a heavy JS bundle.
## Technical Implementation (The Go Stack)
- **Templ over HTML**: All components must be written in `.templ` files. This ensures type safety and allows you to pass Go structs directly into your UI components.
- **HTMX over JavaScript**: Replace `useState` and `useEffect` with `hx-trigger` and `hx-swap`. Maintain application state in the Go backend or the URL, not in a complex client-side store.
- **Tailwind for Styling**: Use utility classes to keep styles local to the HTML. Avoid external CSS files to maintain the "Locality of Behavior" principle.
- **Zero-JS Interactivity**: If client-side logic is strictly necessary (modals, toggles), use **Alpine.js** for its minimal footprint, keeping the code readable within the HTML.
## What to Avoid
- **No Heavy Frameworks**: Strictly avoid React, Vue, or Angular.
- **No JS "Glue Code"**: Avoid writing custom vanilla JavaScript for things HTMX can handle natively.
- **No "AI Slop" Aesthetics**: Avoid the "Inter font + purple gradient + rounded card" combo.
- **No JSON APIs for the UI**: Do not build internal JSON endpoints for your own frontend; return HTML fragments instead.
**IMPORTANT**: The beauty of this approach lies in its **mechanical elegance**. The code should be as clean and performant as the Go binary itself. Show that a "Vibe" can be achieved through clever hypermedia patterns and rock-solid backend engineering.