Compare commits

...
Author SHA1 Message Date
gabspereira 9c3bfd131d feat(go-crm): industrial terminal-core UI redesign
Complete visual overhaul of the go-crm web interface:

- New shared layout system (internal/templates/ui.go) with dark zinc
  industrial theme, JetBrains Mono typography, grid/noise textures
- Redesigned all pages: Dashboard, Login/Signup, Clients, Customers,
  Services, Scheduling, Payments, Questions, Answers, Leads,
  Review Queue, Report, Keyword Mapping
- Tailwind CSS via CDN with custom color palette (amber/emerald/rose/sky)
- HTMX-powered interactions with CSS swap animations
- Status pills, KPI cards, data tables, empty states, inline forms
- Mobile-responsive sidebar with collapsible navigation
- All existing tests updated and passing
- Zero new build dependencies — works with existing go run/air workflow
2026-05-23 18:00:32 -03:00
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
gabspereira 8833e38b80 remove not necessary files to publish 2026-05-02 14:37:59 -03:00
gabspereira 31247a63f6 go-crm improvements 2026-05-01 15:43:13 -03:00
gabspereira ee6673265f enabling skills to opencode 2026-04-25 15:08:18 -03:00
gabspereira fcaec5ea46 new skills according to mattpocock 2026-04-25 14:52:24 -03:00
gabspereira f8135d0e1b go-crm initial 2026-04-21 17:34:58 -03:00
gabspereira 5b8107c169 Add GOTH stack CRM platform skeleton
- Go module with chi router, bcrypt
- SQLite schema for 9 tables
- Auth, Clients, Customers, Services, Scheduling, Payments, Q&A handlers
- HTMX template layouts
2026-04-21 15:56:40 +00:00
104 changed files with 13453 additions and 634 deletions

No files matched your search

+32
View File
@@ -50,3 +50,35 @@ Thumbs.db
.opencode-sandbox/.env
# Go CRM data
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
+7
View File
@@ -10,10 +10,17 @@ RUN pacman -Syu --noconfirm && \
openssh \
opencode \
curl \
go \
sqlite \
&& pacman -Scc --noconfirm
RUN npx -y skills add JuliusBrussee/caveman -g -a opencode -s caveman -y
# 2. Install air using Go
RUN go install github.com/air-verse/air@latest
# Add Go binaries to your PATH so you can actually run 'air'
ENV PATH="/root/go/bin:${PATH}"
# Git safe directory system-wide config
RUN git config --system --add safe.directory /workspace
+12 -1
View File
@@ -15,11 +15,22 @@ services:
- /home/ga/.ssh:/root/.ssh
# Persist opencode auth
- opencode-auth:/root/.local/share/opencode
# Go CRM database
- ./data:/workspace/data
environment:
- OPENCODE_API_KEY=${OPENCODE_API_KEY}
stdin_open: true
tty: true
ports:
- "8080:8080"
working_dir: /workspace
networks:
- crm-network
networks:
crm-network:
name: crm-network
external: true
volumes:
opencode-auth:
opencode-auth:
@@ -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.
@@ -0,0 +1,47 @@
# ADR Format
ADRs live in `docs/adr/` and use sequential numbering: `0001-slug.md`, `0002-slug.md`, etc.
Create the `docs/adr/` directory lazily — only when the first ADR is needed.
## Template
```md
# {Short title of the decision}
{1-3 sentences: what's the context, what did we decide, and why.}
```
That's it. An ADR can be a single paragraph. The value is in recording *that* a decision was made and *why* — not in filling out sections.
## Optional sections
Only include these when they add genuine value. Most ADRs won't need them.
- **Status** frontmatter (`proposed | accepted | deprecated | superseded by ADR-NNNN`) — useful when decisions are revisited
- **Considered Options** — only when the rejected alternatives are worth remembering
- **Consequences** — only when non-obvious downstream effects need to be called out
## Numbering
Scan `docs/adr/` for the highest existing number and increment by one.
## When to offer an ADR
All three of these must be true:
1. **Hard to reverse** — the cost of changing your mind later is meaningful
2. **Surprising without context** — a future reader will look at the code and wonder "why on earth did they do it this way?"
3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
If a decision is easy to reverse, skip it — you'll just reverse it. If it's not surprising, nobody will wonder why. If there was no real alternative, there's nothing to record beyond "we did the obvious thing."
### What qualifies
- **Architectural shape.** "We're using a monorepo." "The write model is event-sourced, the read model is projected into Postgres."
- **Integration patterns between contexts.** "Ordering and Billing communicate via domain events, not synchronous HTTP."
- **Technology choices that carry lock-in.** Database, message bus, auth provider, deployment target. Not every library — just the ones that would take a quarter to swap out.
- **Boundary and scope decisions.** "Customer data is owned by the Customer context; other contexts reference it by ID only." The explicit no-s are as valuable as the yes-s.
- **Deliberate deviations from the obvious path.** "We're using manual SQL instead of an ORM because X." Anything where a reasonable reader would assume the opposite. These stop the next engineer from "fixing" something that was deliberate.
- **Constraints not visible in the code.** "We can't use AWS because of compliance requirements." "Response times must be under 200ms because of the partner API contract."
- **Rejected alternatives when the rejection is non-obvious.** If you considered GraphQL and picked REST for subtle reasons, record it — otherwise someone will suggest GraphQL again in six months.
@@ -0,0 +1,77 @@
# CONTEXT.md Format
## Structure
```md
# {Context Name}
{One or two sentence description of what this context is and why it exists.}
## Language
**Order**:
A customer's request to purchase one or more items.
_Avoid_: Purchase, transaction
**Invoice**:
A request for payment sent to a customer after delivery.
_Avoid_: Bill, payment request
**Customer**:
A person or organization that places orders.
_Avoid_: Client, buyer, account
## Relationships
- An **Order** produces one or more **Invoices**
- An **Invoice** belongs to exactly one **Customer**
## Example dialogue
> **Dev:** "When a **Customer** places an **Order**, do we create the **Invoice** immediately?"
> **Domain expert:** "No — an **Invoice** is only generated once a **Fulfillment** is confirmed."
## Flagged ambiguities
- "account" was used to mean both **Customer** and **User** — resolved: these are distinct concepts.
```
## Rules
- **Be opinionated.** When multiple words exist for the same concept, pick the best one and list the others as aliases to avoid.
- **Flag conflicts explicitly.** If a term is used ambiguously, call it out in "Flagged ambiguities" with a clear resolution.
- **Keep definitions tight.** One sentence max. Define what it IS, not what it does.
- **Show relationships.** Use bold term names and express cardinality where obvious.
- **Only include terms specific to this project's context.** General programming concepts (timeouts, error types, utility patterns) don't belong even if the project uses them extensively. Before adding a term, ask: is this a concept unique to this context, or a general programming concept? Only the former belongs.
- **Group terms under subheadings** when natural clusters emerge. If all terms belong to a single cohesive area, a flat list is fine.
- **Write an example dialogue.** A conversation between a dev and a domain expert that demonstrates how the terms interact naturally and clarifies boundaries between related concepts.
## Single vs multi-context repos
**Single context (most repos):** One `CONTEXT.md` at the repo root.
**Multiple contexts:** A `CONTEXT-MAP.md` at the repo root lists the contexts, where they live, and how they relate to each other:
```md
# Context Map
## Contexts
- [Ordering](./src/ordering/CONTEXT.md) — receives and tracks customer orders
- [Billing](./src/billing/CONTEXT.md) — generates invoices and processes payments
- [Fulfillment](./src/fulfillment/CONTEXT.md) — manages warehouse picking and shipping
## Relationships
- **Ordering → Fulfillment**: Ordering emits `OrderPlaced` events; Fulfillment consumes them to start picking
- **Fulfillment → Billing**: Fulfillment emits `ShipmentDispatched` events; Billing consumes them to generate invoices
- **Ordering ↔ Billing**: Shared types for `CustomerId` and `Money`
```
The skill infers which structure applies:
- If `CONTEXT-MAP.md` exists, read it to find contexts
- If only a root `CONTEXT.md` exists, single context
- If neither exists, create a root `CONTEXT.md` lazily when the first term is resolved
When multiple contexts exist, infer which one the current topic relates to. If unclear, ask.
+81
View File
@@ -0,0 +1,81 @@
---
name: domain-model
description: Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.
disable-model-invocation: true
---
Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
Ask the questions one at a time, waiting for feedback on each question before continuing.
If a question can be answered by exploring the codebase, explore the codebase instead.
## Domain awareness
During codebase exploration, also look for existing documentation:
### File structure
Most repos have a single context:
```
/
├── CONTEXT.md
├── docs/
│ └── adr/
│ ├── 0001-event-sourced-orders.md
│ └── 0002-postgres-for-write-model.md
└── src/
```
If a `CONTEXT-MAP.md` exists at the root, the repo has multiple contexts. The map points to where each one lives:
```
/
├── CONTEXT-MAP.md
├── docs/
│ └── adr/ ← system-wide decisions
├── src/
│ ├── ordering/
│ │ ├── CONTEXT.md
│ │ └── docs/adr/ ← context-specific decisions
│ └── billing/
│ ├── CONTEXT.md
│ └── docs/adr/
```
Create files lazily — only when you have something to write. If no `CONTEXT.md` exists, create one when the first term is resolved. If no `docs/adr/` exists, create it when the first ADR is needed.
## During the session
### Challenge against the glossary
When the user uses a term that conflicts with the existing language in `CONTEXT.md`, call it out immediately. "Your glossary defines 'cancellation' as X, but you seem to mean Y — which is it?"
### Sharpen fuzzy language
When the user uses vague or overloaded terms, propose a precise canonical term. "You're saying 'account' — do you mean the Customer or the User? Those are different things."
### Discuss concrete scenarios
When domain relationships are being discussed, stress-test them with specific scenarios. Invent scenarios that probe edge cases and force the user to be precise about the boundaries between concepts.
### Cross-reference with code
When the user states how something works, check whether the code agrees. If you find a contradiction, surface it: "Your code cancels entire Orders, but you just said partial cancellation is possible — which is right?"
### Update CONTEXT.md inline
When a term is resolved, update `CONTEXT.md` right there. Don't batch these up — capture them as they happen. Use the format in [CONTEXT-FORMAT.md](./CONTEXT-FORMAT.md).
Don't couple `CONTEXT.md` to implementation details. Only include terms that are meaningful to domain experts.
### Offer ADRs sparingly
Only offer to create an ADR when all three are true:
1. **Hard to reverse** — the cost of changing your mind later is meaningful
2. **Surprising without context** — a future reader will wonder "why did they do it this way?"
3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
If any of the three is missing, skip the ADR. Use the format in [ADR-FORMAT.md](./ADR-FORMAT.md).
+10
View File
@@ -0,0 +1,10 @@
---
name: grill-me
description: Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
---
Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
Ask the questions one at a time.
If a question can be answered by exploring the codebase, explore the codebase instead.
@@ -0,0 +1,37 @@
# Deepening
How to deepen a cluster of shallow modules safely, given its dependencies. Assumes the vocabulary in [LANGUAGE.md](LANGUAGE.md) — **module**, **interface**, **seam**, **adapter**.
## Dependency categories
When assessing a candidate for deepening, classify its dependencies. The category determines how the deepened module is tested across its seam.
### 1. In-process
Pure computation, in-memory state, no I/O. Always deepenable — merge the modules and test through the new interface directly. No adapter needed.
### 2. Local-substitutable
Dependencies that have local test stand-ins (PGLite for Postgres, in-memory filesystem). Deepenable if the stand-in exists. The deepened module is tested with the stand-in running in the test suite. The seam is internal; no port at the module's external interface.
### 3. Remote but owned (Ports & Adapters)
Your own services across a network boundary (microservices, internal APIs). Define a **port** (interface) at the seam. The deep module owns the logic; the transport is injected as an **adapter**. Tests use an in-memory adapter. Production uses an HTTP/gRPC/queue adapter.
Recommendation shape: *"Define a port at the seam, implement an HTTP adapter for production and an in-memory adapter for testing, so the logic sits in one deep module even though it's deployed across a network."*
### 4. True external (Mock)
Third-party services (Stripe, Twilio, etc.) you don't control. The deepened module takes the external dependency as an injected port; tests provide a mock adapter.
## Seam discipline
- **One adapter means a hypothetical seam. Two adapters means a real one.** Don't introduce a port unless at least two adapters are justified (typically production + test). A single-adapter seam is just indirection.
- **Internal seams vs external seams.** A deep module can have internal seams (private to its implementation, used by its own tests) as well as the external seam at its interface. Don't expose internal seams through the interface just because tests use them.
## Testing strategy: replace, don't layer
- Old unit tests on shallow modules become waste once tests at the deepened module's interface exist — delete them.
- Write new tests at the deepened module's interface. The **interface is the test surface**.
- Tests assert on observable outcomes through the interface, not internal state.
- Tests should survive internal refactors — they describe behaviour, not implementation. If a test has to change when the implementation changes, it's testing past the interface.
@@ -0,0 +1,44 @@
# Interface Design
When the user wants to explore alternative interfaces for a chosen deepening candidate, use this parallel sub-agent pattern. Based on "Design It Twice" (Ousterhout) — your first idea is unlikely to be the best.
Uses the vocabulary in [LANGUAGE.md](LANGUAGE.md) — **module**, **interface**, **seam**, **adapter**, **leverage**.
## Process
### 1. Frame the problem space
Before spawning sub-agents, write a user-facing explanation of the problem space for the chosen candidate:
- The constraints any new interface would need to satisfy
- The dependencies it would rely on, and which category they fall into (see [DEEPENING.md](DEEPENING.md))
- A rough illustrative code sketch to ground the constraints — not a proposal, just a way to make the constraints concrete
Show this to the user, then immediately proceed to Step 2. The user reads and thinks while the sub-agents work in parallel.
### 2. Spawn sub-agents
Spawn 3+ sub-agents in parallel using the Agent tool. Each must produce a **radically different** interface for the deepened module.
Prompt each sub-agent with a separate technical brief (file paths, coupling details, dependency category from [DEEPENING.md](DEEPENING.md), what sits behind the seam). The brief is independent of the user-facing problem-space explanation in Step 1. Give each agent a different design constraint:
- Agent 1: "Minimize the interface — aim for 1–3 entry points max. Maximise leverage per entry point."
- Agent 2: "Maximise flexibility — support many use cases and extension."
- Agent 3: "Optimise for the most common caller — make the default case trivial."
- Agent 4 (if applicable): "Design around ports & adapters for cross-seam dependencies."
Include both [LANGUAGE.md](LANGUAGE.md) vocabulary and CONTEXT.md vocabulary in the brief so each sub-agent names things consistently with the architecture language and the project's domain language.
Each sub-agent outputs:
1. Interface (types, methods, params — plus invariants, ordering, error modes)
2. Usage example showing how callers use it
3. What the implementation hides behind the seam
4. Dependency strategy and adapters (see [DEEPENING.md](DEEPENING.md))
5. Trade-offs — where leverage is high, where it's thin
### 3. Present and compare
Present designs sequentially so the user can absorb each one, then compare them in prose. Contrast by **depth** (leverage at the interface), **locality** (where change concentrates), and **seam placement**.
After comparing, give your own recommendation: which design you think is strongest and why. If elements from different designs would combine well, propose a hybrid. Be opinionated — the user wants a strong read, not a menu.
@@ -0,0 +1,53 @@
# Language
Shared vocabulary for every suggestion this skill makes. Use these terms exactly — don't substitute "component," "service," "API," or "boundary." Consistent language is the whole point.
## Terms
**Module**
Anything with an interface and an implementation. Deliberately scale-agnostic — applies equally to a function, class, package, or tier-spanning slice.
_Avoid_: unit, component, service.
**Interface**
Everything a caller must know to use the module correctly. Includes the type signature, but also invariants, ordering constraints, error modes, required configuration, and performance characteristics.
_Avoid_: API, signature (too narrow — those refer only to the type-level surface).
**Implementation**
What's inside a module — its body of code. Distinct from **Adapter**: a thing can be a small adapter with a large implementation (a Postgres repo) or a large adapter with a small implementation (an in-memory fake). Reach for "adapter" when the seam is the topic; "implementation" otherwise.
**Depth**
Leverage at the interface — the amount of behaviour a caller (or test) can exercise per unit of interface they have to learn. A module is **deep** when a large amount of behaviour sits behind a small interface. A module is **shallow** when the interface is nearly as complex as the implementation.
**Seam** _(from Michael Feathers)_
A place where you can alter behaviour without editing in that place. The *location* at which a module's interface lives. Choosing where to put the seam is its own design decision, distinct from what goes behind it.
_Avoid_: boundary (overloaded with DDD's bounded context).
**Adapter**
A concrete thing that satisfies an interface at a seam. Describes *role* (what slot it fills), not substance (what's inside).
**Leverage**
What callers get from depth. More capability per unit of interface they have to learn. One implementation pays back across N call sites and M tests.
**Locality**
What maintainers get from depth. Change, bugs, knowledge, and verification concentrate at one place rather than spreading across callers. Fix once, fixed everywhere.
## Principles
- **Depth is a property of the interface, not the implementation.** A deep module can be internally composed of small, mockable, swappable parts — they just aren't part of the interface. A module can have **internal seams** (private to its implementation, used by its own tests) as well as the **external seam** at its interface.
- **The deletion test.** Imagine deleting the module. If complexity vanishes, the module wasn't hiding anything (it was a pass-through). If complexity reappears across N callers, the module was earning its keep.
- **The interface is the test surface.** Callers and tests cross the same seam. If you want to test *past* the interface, the module is probably the wrong shape.
- **One adapter means a hypothetical seam. Two adapters means a real one.** Don't introduce a seam unless something actually varies across it.
## Relationships
- A **Module** has exactly one **Interface** (the surface it presents to callers and tests).
- **Depth** is a property of a **Module**, measured against its **Interface**.
- A **Seam** is where a **Module**'s **Interface** lives.
- An **Adapter** sits at a **Seam** and satisfies the **Interface**.
- **Depth** produces **Leverage** for callers and **Locality** for maintainers.
## Rejected framings
- **Depth as ratio of implementation-lines to interface-lines** (Ousterhout): rewards padding the implementation. We use depth-as-leverage instead.
- **"Interface" as the TypeScript `interface` keyword or a class's public methods**: too narrow — interface here includes every fact a caller must know.
- **"Boundary"**: overloaded with DDD's bounded context. Say **seam** or **interface**.
@@ -0,0 +1,76 @@
---
name: improve-codebase-architecture
description: Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.
---
# Improve Codebase Architecture
Surface architectural friction and propose **deepening opportunities** — refactors that turn shallow modules into deep ones. The aim is testability and AI-navigability.
## Glossary
Use these terms exactly in every suggestion. Consistent language is the point — don't drift into "component," "service," "API," or "boundary." Full definitions in [LANGUAGE.md](LANGUAGE.md).
- **Module** — anything with an interface and an implementation (function, class, package, slice).
- **Interface** — everything a caller must know to use the module: types, invariants, error modes, ordering, config. Not just the type signature.
- **Implementation** — the code inside.
- **Depth** — leverage at the interface: a lot of behaviour behind a small interface. **Deep** = high leverage. **Shallow** = interface nearly as complex as the implementation.
- **Seam** — where an interface lives; a place behaviour can be altered without editing in place. (Use this, not "boundary.")
- **Adapter** — a concrete thing satisfying an interface at a seam.
- **Leverage** — what callers get from depth.
- **Locality** — what maintainers get from depth: change, bugs, knowledge concentrated in one place.
Key principles (see [LANGUAGE.md](LANGUAGE.md) for the full list):
- **Deletion test**: imagine deleting the module. If complexity vanishes, it was a pass-through. If complexity reappears across N callers, it was earning its keep.
- **The interface is the test surface.**
- **One adapter = hypothetical seam. Two adapters = real seam.**
This skill is _informed_ by the project's domain model — `CONTEXT.md` and any `docs/adr/`. The domain language gives names to good seams; ADRs record decisions the skill should not re-litigate. See [CONTEXT-FORMAT.md](../domain-model/CONTEXT-FORMAT.md) and [ADR-FORMAT.md](../domain-model/ADR-FORMAT.md).
## Process
### 1. Explore
Read existing documentation first:
- `CONTEXT.md` (or `CONTEXT-MAP.md` + each `CONTEXT.md` in a multi-context repo)
- Relevant ADRs in `docs/adr/` (and any context-scoped `docs/adr/` directories)
If any of these files don't exist, proceed silently — don't flag their absence or suggest creating them upfront.
Then use the Agent tool with `subagent_type=Explore` to walk the codebase. Don't follow rigid heuristics — explore organically and note where you experience friction:
- Where does understanding one concept require bouncing between many small modules?
- Where are modules **shallow** — interface nearly as complex as the implementation?
- Where have pure functions been extracted just for testability, but the real bugs hide in how they're called (no **locality**)?
- Where do tightly-coupled modules leak across their seams?
- Which parts of the codebase are untested, or hard to test through their current interface?
Apply the **deletion test** to anything you suspect is shallow: would deleting it concentrate complexity, or just move it? A "yes, concentrates" is the signal you want.
### 2. Present candidates
Present a numbered list of deepening opportunities. For each candidate:
- **Files** — which files/modules are involved
- **Problem** — why the current architecture is causing friction
- **Solution** — plain English description of what would change
- **Benefits** — explained in terms of locality and leverage, and also in how tests would improve
**Use CONTEXT.md vocabulary for the domain, and [LANGUAGE.md](LANGUAGE.md) vocabulary for the architecture.** If `CONTEXT.md` defines "Order," talk about "the Order intake module" — not "the FooBarHandler," and not "the Order service."
**ADR conflicts**: if a candidate contradicts an existing ADR, only surface it when the friction is real enough to warrant revisiting the ADR. Mark it clearly (e.g. _"contradicts ADR-0007 — but worth reopening because…"_). Don't list every theoretical refactor an ADR forbids.
Do NOT propose interfaces yet. Ask the user: "Which of these would you like to explore?"
### 3. Grilling loop
Once the user picks a candidate, drop into a grilling conversation. Walk the design tree with them — constraints, dependencies, the shape of the deepened module, what sits behind the seam, what tests survive.
Side effects happen inline as decisions crystallize:
- **Naming a deepened module after a concept not in `CONTEXT.md`?** Add the term to `CONTEXT.md` — same discipline as `/domain-model` (see [CONTEXT-FORMAT.md](../domain-model/CONTEXT-FORMAT.md)). Create the file lazily if it doesn't exist.
- **Sharpening a fuzzy term during the conversation?** Update `CONTEXT.md` right there.
- **User rejects the candidate with a load-bearing reason?** Offer an ADR, framed as: _"Want me to record this as an ADR so future architecture reviews don't re-suggest it?"_ Only offer when the reason would actually be needed by a future explorer to avoid re-suggesting the same thing — skip ephemeral reasons ("not worth it right now") and self-evident ones. See [ADR-FORMAT.md](../domain-model/ADR-FORMAT.md).
- **Want to explore alternative interfaces for the deepened module?** See [INTERFACE-DESIGN.md](INTERFACE-DESIGN.md).
+73
View File
@@ -0,0 +1,73 @@
---
name: to-prd
description: Turn the current conversation context into a PRD and submit it as a GitHub issue. Use when user wants to create a PRD from the current context.
---
This skill takes the current conversation context and codebase understanding and produces a PRD. Do NOT interview the user — just synthesize what you already know.
## Process
1. Explore the repo to understand the current state of the codebase, if you haven't already.
2. Sketch out the major modules you will need to build or modify to complete the implementation. Actively look for opportunities to extract deep modules that can be tested in isolation.
A deep module (as opposed to a shallow module) is one which encapsulates a lot of functionality in a simple, testable interface which rarely changes.
Check with the user that these modules match their expectations. Check with the user which modules they want tests written for.
3. Write the PRD using the template below and submit it as a GitHub issue.
<prd-template>
## Problem Statement
The problem that the user is facing, from the user's perspective.
## Solution
The solution to the problem, from the user's perspective.
## User Stories
A LONG, numbered list of user stories. Each user story should be in the format of:
1. As an <actor>, I want a <feature>, so that <benefit>
<user-story-example>
1. As a mobile bank customer, I want to see balance on my accounts, so that I can make better informed decisions about my spending
</user-story-example>
This list of user stories should be extremely extensive and cover all aspects of the feature.
## Implementation Decisions
A list of implementation decisions that were made. This can include:
- The modules that will be built/modified
- The interfaces of those modules that will be modified
- Technical clarifications from the developer
- Architectural decisions
- Schema changes
- API contracts
- Specific interactions
Do NOT include specific file paths or code snippets. They may end up being outdated very quickly.
## Testing Decisions
A list of testing decisions that were made. Include:
- A description of what makes a good test (only test external behavior, not implementation details)
- Which modules will be tested
- Prior art for the tests (i.e. similar types of tests in the codebase)
## Out of Scope
A description of the things that are out of scope for this PRD.
## Further Notes
Any further notes about the feature.
</prd-template>
+107
View File
@@ -0,0 +1,107 @@
---
name: tdd
description: Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development.
---
# Test-Driven Development
## Philosophy
**Core principle**: Tests should verify behavior through public interfaces, not implementation details. Code can change entirely; tests shouldn't.
**Good tests** are integration-style: they exercise real code paths through public APIs. They describe _what_ the system does, not _how_ it does it. A good test reads like a specification - "user can checkout with valid cart" tells you exactly what capability exists. These tests survive refactors because they don't care about internal structure.
**Bad tests** are coupled to implementation. They mock internal collaborators, test private methods, or verify through external means (like querying a database directly instead of using the interface). The warning sign: your test breaks when you refactor, but behavior hasn't changed. If you rename an internal function and tests fail, those tests were testing implementation, not behavior.
See [tests.md](tests.md) for examples and [mocking.md](mocking.md) for mocking guidelines.
## Anti-Pattern: Horizontal Slices
**DO NOT write all tests first, then all implementation.** This is "horizontal slicing" - treating RED as "write all tests" and GREEN as "write all code."
This produces **crap tests**:
- Tests written in bulk test _imagined_ behavior, not _actual_ behavior
- You end up testing the _shape_ of things (data structures, function signatures) rather than user-facing behavior
- Tests become insensitive to real changes - they pass when behavior breaks, fail when behavior is fine
- You outrun your headlights, committing to test structure before understanding the implementation
**Correct approach**: Vertical slices via tracer bullets. One test → one implementation → repeat. Each test responds to what you learned from the previous cycle. Because you just wrote the code, you know exactly what behavior matters and how to verify it.
```
WRONG (horizontal):
RED: test1, test2, test3, test4, test5
GREEN: impl1, impl2, impl3, impl4, impl5
RIGHT (vertical):
RED→GREEN: test1→impl1
RED→GREEN: test2→impl2
RED→GREEN: test3→impl3
...
```
## Workflow
### 1. Planning
Before writing any code:
- [ ] Confirm with user what interface changes are needed
- [ ] Confirm with user which behaviors to test (prioritize)
- [ ] Identify opportunities for [deep modules](deep-modules.md) (small interface, deep implementation)
- [ ] Design interfaces for [testability](interface-design.md)
- [ ] List the behaviors to test (not implementation steps)
- [ ] Get user approval on the plan
Ask: "What should the public interface look like? Which behaviors are most important to test?"
**You can't test everything.** Confirm with the user exactly which behaviors matter most. Focus testing effort on critical paths and complex logic, not every possible edge case.
### 2. Tracer Bullet
Write ONE test that confirms ONE thing about the system:
```
RED: Write test for first behavior → test fails
GREEN: Write minimal code to pass → test passes
```
This is your tracer bullet - proves the path works end-to-end.
### 3. Incremental Loop
For each remaining behavior:
```
RED: Write next test → fails
GREEN: Minimal code to pass → passes
```
Rules:
- One test at a time
- Only enough code to pass current test
- Don't anticipate future tests
- Keep tests focused on observable behavior
### 4. Refactor
After all tests pass, look for [refactor candidates](refactoring.md):
- [ ] Extract duplication
- [ ] Deepen modules (move complexity behind simple interfaces)
- [ ] Apply SOLID principles where natural
- [ ] Consider what new code reveals about existing code
- [ ] Run tests after each refactor step
**Never refactor while RED.** Get to GREEN first.
## Checklist Per Cycle
```
[ ] Test describes behavior, not implementation
[ ] Test uses public interface only
[ ] Test would survive internal refactor
[ ] Code is minimal for this test
[ ] No speculative features added
```
+33
View File
@@ -0,0 +1,33 @@
# Deep Modules
From "A Philosophy of Software Design":
**Deep module** = small interface + lots of implementation
```
┌─────────────────────┐
│ Small Interface │ ← Few methods, simple params
├─────────────────────┤
│ │
│ │
│ Deep Implementation│ ← Complex logic hidden
│ │
│ │
└─────────────────────┘
```
**Shallow module** = large interface + little implementation (avoid)
```
┌─────────────────────────────────┐
│ Large Interface │ ← Many methods, complex params
├─────────────────────────────────┤
│ Thin Implementation │ ← Just passes through
└─────────────────────────────────┘
```
When designing interfaces, ask:
- Can I reduce the number of methods?
- Can I simplify the parameters?
- Can I hide more complexity inside?
+31
View File
@@ -0,0 +1,31 @@
# Interface Design for Testability
Good interfaces make testing natural:
1. **Accept dependencies, don't create them**
```typescript
// Testable
function processOrder(order, paymentGateway) {}
// Hard to test
function processOrder(order) {
const gateway = new StripeGateway();
}
```
2. **Return results, don't produce side effects**
```typescript
// Testable
function calculateDiscount(cart): Discount {}
// Hard to test
function applyDiscount(cart): void {
cart.total -= discount;
}
```
3. **Small surface area**
- Fewer methods = fewer tests needed
- Fewer params = simpler test setup
+59
View File
@@ -0,0 +1,59 @@
# When to Mock
Mock at **system boundaries** only:
- External APIs (payment, email, etc.)
- Databases (sometimes - prefer test DB)
- Time/randomness
- File system (sometimes)
Don't mock:
- Your own classes/modules
- Internal collaborators
- Anything you control
## Designing for Mockability
At system boundaries, design interfaces that are easy to mock:
**1. Use dependency injection**
Pass external dependencies in rather than creating them internally:
```typescript
// Easy to mock
function processPayment(order, paymentClient) {
return paymentClient.charge(order.total);
}
// Hard to mock
function processPayment(order) {
const client = new StripeClient(process.env.STRIPE_KEY);
return client.charge(order.total);
}
```
**2. Prefer SDK-style interfaces over generic fetchers**
Create specific functions for each external operation instead of one generic function with conditional logic:
```typescript
// GOOD: Each function is independently mockable
const api = {
getUser: (id) => fetch(`/users/${id}`),
getOrders: (userId) => fetch(`/users/${userId}/orders`),
createOrder: (data) => fetch('/orders', { method: 'POST', body: data }),
};
// BAD: Mocking requires conditional logic inside the mock
const api = {
fetch: (endpoint, options) => fetch(endpoint, options),
};
```
The SDK approach means:
- Each mock returns one specific shape
- No conditional logic in test setup
- Easier to see which endpoints a test exercises
- Type safety per endpoint
+10
View File
@@ -0,0 +1,10 @@
# Refactor Candidates
After TDD cycle, look for:
- **Duplication** → Extract function/class
- **Long methods** → Break into private helpers (keep tests on public interface)
- **Shallow modules** → Combine or deepen
- **Feature envy** → Move logic to where data lives
- **Primitive obsession** → Introduce value objects
- **Existing code** the new code reveals as problematic
+61
View File
@@ -0,0 +1,61 @@
# Good and Bad Tests
## Good Tests
**Integration-style**: Test through real interfaces, not mocks of internal parts.
```typescript
// GOOD: Tests observable behavior
test("user can checkout with valid cart", async () => {
const cart = createCart();
cart.add(product);
const result = await checkout(cart, paymentMethod);
expect(result.status).toBe("confirmed");
});
```
Characteristics:
- Tests behavior users/callers care about
- Uses public API only
- Survives internal refactors
- Describes WHAT, not HOW
- One logical assertion per test
## Bad Tests
**Implementation-detail tests**: Coupled to internal structure.
```typescript
// BAD: Tests implementation details
test("checkout calls paymentService.process", async () => {
const mockPayment = jest.mock(paymentService);
await checkout(cart, payment);
expect(mockPayment.process).toHaveBeenCalledWith(cart.total);
});
```
Red flags:
- Mocking internal collaborators
- Testing private methods
- Asserting on call counts/order
- Test breaks when refactoring without behavior change
- Test name describes HOW not WHAT
- Verifying through external means instead of interface
```typescript
// BAD: Bypasses interface to verify
test("createUser saves to database", async () => {
await createUser({ name: "Alice" });
const row = await db.query("SELECT * FROM users WHERE name = ?", ["Alice"]);
expect(row).toBeDefined();
});
// GOOD: Verifies through interface
test("createUser makes user retrievable", async () => {
const user = await createUser({ name: "Alice" });
const retrieved = await getUser(user.id);
expect(retrieved.name).toBe("Alice");
});
```
+72
View File
@@ -0,0 +1,72 @@
---
name: to-prd
description: Turn the current conversation context into a PRD and submit it as a GitHub issue. Use when user wants to create a PRD from the current context.
---
This skill takes the current conversation context and codebase understanding and produces a PRD. Do NOT interview the user — just synthesize what you already know.
## Process
1. Explore the repo to understand the current state of the codebase, if you haven't already.
2. Sketch out the major modules you will need to build or modify to complete the implementation. Actively look for opportunities to extract deep modules that can be tested in isolation.
A deep module (as opposed to a shallow module) is one which encapsulates a lot of functionality in a simple, testable interface which rarely changes.
Check with the user that these modules match their expectations. Check with the user which modules they want tests written for.
3. Write the PRD using the template below and submit it as a GitHub issue.
<prd-template>
## Problem Statement
The problem that the user is facing, from the user's perspective.
## Solution
The solution to the problem, from the user's perspective.
## User Stories
A LONG, numbered list of user stories. Each user story should be in the format of:
1. As an <actor>, I want a <feature>, so that <benefit>
<user-story-example>
1. As a mobile bank customer, I want to see balance on my accounts, so that I can make better informed decisions about my spending
</user-story-example>
This list of user stories should be extremely extensive and cover all aspects of the feature.
## Implementation Decisions
A list of implementation decisions that were made. This can include:
- The modules that will be built/modified
- The interfaces of those modules that will be modified
- Technical clarifications from the developer
- Architectural decisions
- Schema changes
- API contracts
- Specific interactions
Do NOT include specific file paths or code snippets. They may end up being outdated very quickly.
## Testing Decisions
A list of testing decisions that were made. Include:
- A description of what makes a good test (only test external behavior, not implementation details)
- Which modules will be tested
- Prior art for the tests (i.e. similar types of tests in the codebase)
## Out of Scope
A description of the things that are out of scope for this PRD.
## Further Notes
Any further notes about the feature.
</prd-template>
@@ -0,0 +1,93 @@
---
name: ubiquitous-language
description: Extract a DDD-style ubiquitous language glossary from the current conversation, flagging ambiguities and proposing canonical terms. Saves to UBIQUITOUS_LANGUAGE.md. Use when user wants to define domain terms, build a glossary, harden terminology, create a ubiquitous language, or mentions "domain model" or "DDD".
disable-model-invocation: true
---
# Ubiquitous Language
Extract and formalize domain terminology from the current conversation into a consistent glossary, saved to a local file.
## Process
1. **Scan the conversation** for domain-relevant nouns, verbs, and concepts
2. **Identify problems**:
- Same word used for different concepts (ambiguity)
- Different words used for the same concept (synonyms)
- Vague or overloaded terms
3. **Propose a canonical glossary** with opinionated term choices
4. **Write to `UBIQUITOUS_LANGUAGE.md`** in the working directory using the format below
5. **Output a summary** inline in the conversation
## Output Format
Write a `UBIQUITOUS_LANGUAGE.md` file with this structure:
```md
# Ubiquitous Language
## Order lifecycle
| Term | Definition | Aliases to avoid |
| ----------- | ------------------------------------------------------- | --------------------- |
| **Order** | A customer's request to purchase one or more items | Purchase, transaction |
| **Invoice** | A request for payment sent to a customer after delivery | Bill, payment request |
## People
| Term | Definition | Aliases to avoid |
| ------------ | ------------------------------------------- | ---------------------- |
| **Customer** | A person or organization that places orders | Client, buyer, account |
| **User** | An authentication identity in the system | Login, account |
## Relationships
- An **Invoice** belongs to exactly one **Customer**
- An **Order** produces one or more **Invoices**
## Example dialogue
> **Dev:** "When a **Customer** places an **Order**, do we create the **Invoice** immediately?"
> **Domain expert:** "No — an **Invoice** is only generated once a **Fulfillment** is confirmed. A single **Order** can produce multiple **Invoices** if items ship in separate **Shipments**."
> **Dev:** "So if a **Shipment** is cancelled before dispatch, no **Invoice** exists for it?"
> **Domain expert:** "Exactly. The **Invoice** lifecycle is tied to the **Fulfillment**, not the **Order**."
## Flagged ambiguities
- "account" was used to mean both **Customer** and **User** — these are distinct concepts: a **Customer** places orders, while a **User** is an authentication identity that may or may not represent a **Customer**.
```
## Rules
- **Be opinionated.** When multiple words exist for the same concept, pick the best one and list the others as aliases to avoid.
- **Flag conflicts explicitly.** If a term is used ambiguously in the conversation, call it out in the "Flagged ambiguities" section with a clear recommendation.
- **Only include terms relevant for domain experts.** Skip the names of modules or classes unless they have meaning in the domain language.
- **Keep definitions tight.** One sentence max. Define what it IS, not what it does.
- **Show relationships.** Use bold term names and express cardinality where obvious.
- **Only include domain terms.** Skip generic programming concepts (array, function, endpoint) unless they have domain-specific meaning.
- **Group terms into multiple tables** when natural clusters emerge (e.g. by subdomain, lifecycle, or actor). Each group gets its own heading and table. If all terms belong to a single cohesive domain, one table is fine — don't force groupings.
- **Write an example dialogue.** A short conversation (3-5 exchanges) between a dev and a domain expert that demonstrates how the terms interact naturally. The dialogue should clarify boundaries between related concepts and show terms being used precisely.
<example>
## Example dialogue
> **Dev:** "How do I test the **sync service** without Docker?"
> **Domain expert:** "Provide the **filesystem layer** instead of the **Docker layer**. It implements the same **Sandbox service** interface but uses a local directory as the **sandbox**."
> **Dev:** "So **sync-in** still creates a **bundle** and unpacks it?"
> **Domain expert:** "Exactly. The **sync service** doesn't know which layer it's talking to. It calls `exec` and `copyIn` — the **filesystem layer** just runs those as local shell commands."
</example>
## Re-running
When invoked again in the same conversation:
1. Read the existing `UBIQUITOUS_LANGUAGE.md`
2. Incorporate any new terms from subsequent discussion
3. Update definitions if understanding has evolved
4. Re-flag any new ambiguities
5. Rewrite the example dialogue to incorporate new terms
+72 -146
View File
@@ -1,185 +1,111 @@
# AGENTS.md - Agent Coding Guidelines
This workspace is a monorepo containing data engineering projects and WhatsApp CRM applications.
---
# AGENTS.md
## Project Structure
```
workspace/
├── apps/
│ ├── whatsapp-crm/ # Next.js CRM with Kanban board (primary app)
│ ├── whatsapp-sync/ # WhatsApp message sync service
│ ├── whatsapp-reader/ # WhatsApp message reader
│ └── timesfm-forecast/ # Time series forecasting app
├── data-engineering/ # Udacity DE portfolio projects
│ ├── go-crm/ # Go server (Chi), HTML templates, hot-reload via air
│ ├── whatsapp-crm/ # Next.js 14 App Router, sql.js (browser SQLite), Kanban
│ ├── whatsapp-sync/ # Node.js WhatsApp sync service
│ ├── whatsapp-reader/ # Standalone message reader
│ └── 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
```
---
## 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
cd apps/whatsapp-crm
# Development
npm run dev # Start Next.js dev server on 0.0.0.0:3000
npm run build # Production build
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
npm run dev # Next.js dev server 0.0.0.0:3000
npm run build # production build
npm run lint # ESLint
npm run test # Jest (uses tests/setup.ts)
```
### whatsapp-sync
```bash
cd apps/whatsapp-sync
npm run start # node src/index.js
npm run dev # node --watch src/index.js
npm run sync # node src/sync.js
npm run test # Jest
npm run test:watch # Jest watch mode
npm run test:coverage # Jest with coverage
npm run start # node src/index.js
npm run dev # node --watch src/index.js
npm run sync # node src/sync.js
npm run test # Jest (mocks qrcode-terminal + whatsapp-web.js)
```
### whatsapp-reader
```bash
cd apps/whatsapp-reader
# No test script defined
node index.js # main script
node sync.js # sync script
# no test script
```
### timesfm-forecast
```bash
cd apps/timesfm-forecast
uv venv && source .venv/bin/activate
uv pip install -e .
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
- `strict: true` enabled in tsconfig.json
- Always use explicit types for function parameters and return values
- Use `interface` for objects, `type` for unions/aliases
### WhatsApp auth sessions
- `.wwebjs_auth/` directories store session state — do not commit these
- `whatsapp-sync` uses `better-sqlite3` for persistence
- `whatsapp-crm` browser-side uses `sql.js` (WebAssembly, no native deps)
```typescript
// Good
interface Contact {
id: number
name: string
stage: Stage
}
### go-crm auth
- `X-Internal-Secret` header required on requests (value: `internal-secret`)
- WhatsApp connector init URL: `http://localhost:8080`
function getContactById(id: number): Contact | null
// Avoid
const contact = { id: 1, name: 'Test' } // implicit any
### Docker
```bash
docker compose up whatsapp-crm # CRM only
docker compose --profile sync up # CRM + sync
docker compose --profile test up # test runner
```
### Imports
- Use path alias `@/*` for internal imports (configured in tsconfig.json)
- Order: external → internal → relative
- Group by: React imports → other imports → types → components
### go-crm hot-reload
- Uses `air` (not `go run`) — configured in `.air.toml`
- Build excludes `_test.go` and `vendor/`, `tmp/`, `assets/`
```typescript
import { useState, useMemo } from 'react'
import { Stage, STAGES, Contact } from '@/lib/types'
import { ContactCard } from '@/components/ContactCard'
```
### TypeScript config (whatsapp-crm, whatsapp-sync)
- `strict: true` in tsconfig.json
- Path alias `@/*` maps to `src/*`
### Naming Conventions
- **Components**: PascalCase (e.g., `KanbanBoard`, `ContactCard`)
- **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
### Testing mocks
- `whatsapp-sync` has manual mocks for `qrcode-terminal` and `whatsapp-web.js` in `tests/__mocks__/`
---
## Important Notes
## What to Avoid
- whatsapp-crm uses Next.js 14 App Router
- Database is sql.js (WebAssembly SQLite) - runs in browser
- Authentication uses WhatsApp Web.js QR code scanning
- STAGES constant defines the Kanban pipeline (defined in `src/lib/types.ts`)
- Do not use `go run main.go` for development — use `air`
- Do not commit `.wwebjs_auth/` or `.wwebjs_cache/` directories
- Do not change hardcoded DB paths in `main.go`
- The `data-engineering/` projects are standalone — no shared build or test commands
+35
View File
@@ -0,0 +1,35 @@
root_dir = "."
tmp_dir = "tmp"
[build]
bin = "./tmp/main"
cmd = "go build -buildvcs=false -o ./tmp/main ."
delay = 2000
exclude_dir = ["assets", "tmp", "vendor", "data", "node_modules", ".git"]
exclude_file = []
exclude_regex = ["_test.go", "\\.db$", "\\.db-journal$", "\\.db-shm$", "\\.db-wal$"]
exclude_unchanged = true
follow_symlink = false
full_screen = false
include_dir = ["internal"]
include_ext = ["go", "templ"]
kill_delay = "2s"
log = "build-errors.toml"
send_exit = false
send_user = false
stop_on_error = true
[log]
main_only = false
time = false
[misc]
clean_on_exit = false
dao = "0x60"
force_kill = true
kill = true
restart = true
[screen]
clear_on_rebuild = false
extra_resize = 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/
+32
View File
@@ -0,0 +1,32 @@
FROM archlinux:latest
RUN pacman -Syu --noconfirm && \
pacman -S --noconfirm \
go \
git \
sqlite \
curl \
nodejs \
npm \
chromium \
&& pacman -Scc --noconfirm
ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true
ENV PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium
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 && \
chmod +x air && \
mv air /usr/local/bin/air
WORKDIR /workspace/apps/go-crm
COPY go.mod go.sum ./
RUN go mod download
COPY . .
EXPOSE 8080
CMD ["air"]
+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
}
+22
View File
@@ -0,0 +1,22 @@
services:
go-crm:
build: .
container_name: go-crm
ports:
- "8888:8080"
volumes:
- /home/ga/workspace:/workspace
- ./data:/workspace/data
networks:
- crm-network
working_dir: /workspace/apps/go-crm
command: air
restart: unless-stopped
deploy:
resources:
limits:
memory: 2G
networks:
crm-network:
external: false
+44
View File
@@ -0,0 +1,44 @@
module go-crm
go 1.25.0
require (
github.com/glebarez/go-sqlite v1.21.2
github.com/glebarez/sqlite v1.11.0
github.com/go-chi/chi/v5 v5.1.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 (
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/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/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
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
)
replace go.mau.eu/whatsmeow => go.mau.fi/whatsmeow v0.0.0-20260427122815-7514259253a7
+90
View File
@@ -0,0 +1,90 @@
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.1.0 h1:acVI1TYaD+hhedDJ3r54HyA6sExp3HfXq7QWEEY/xMw=
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/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/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-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/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=
+804
View File
@@ -0,0 +1,804 @@
package db
import (
"database/sql"
"time"
)
type Client struct {
ClientID int64 `json:"client_id"`
AccountID int64 `json:"account_id"`
Name string `json:"name"`
Phone string `json:"phone,omitempty"`
Email string `json:"email,omitempty"`
Address string `json:"address,omitempty"`
Notes string `json:"notes,omitempty"`
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 {
CustomerID int64 `json:"customer_id"`
ClientID int64 `json:"client_id"`
Name string `json:"name"`
Phone string `json:"phone,omitempty"`
BirthDate string `json:"birth_date,omitempty"`
Instagram string `json:"instagram,omitempty"`
CreatedAt int64 `json:"created_at"`
WhatsAppConnected int `json:"whatsapp_connected"`
WhatsAppNumber string `json:"whatsapp_number,omitempty"`
}
type Service struct {
ServiceID int64 `json:"service_id"`
ClientID int64 `json:"client_id"`
Name string `json:"name"`
Price float64 `json:"price,omitempty"`
Description string `json:"description,omitempty"`
Duration string `json:"duration,omitempty"`
CreatedAt int64 `json:"created_at"`
}
type Schedule struct {
ScheduleID int64 `json:"schedule_id"`
ClientID int64 `json:"client_id"`
CustomerID int64 `json:"customer_id"`
ServiceID int64 `json:"service_id"`
PlanDate string `json:"plan_date,omitempty"`
Time string `json:"time,omitempty"`
Status string `json:"status"`
CreatedAt int64 `json:"created_at"`
}
type Payment struct {
PaymentID int64 `json:"payment_id"`
ClientID int64 `json:"client_id"`
CustomerID int64 `json:"customer_id"`
ScheduleID int64 `json:"schedule_id,omitempty"`
HasPaid bool `json:"has_paid"`
Amount float64 `json:"amount,omitempty"`
PaymentDate string `json:"payment_date,omitempty"`
PaymentMethod string `json:"payment_method,omitempty"`
CreatedAt int64 `json:"created_at"`
}
func (c *Client) Create(db *sql.DB) error {
result, err := db.Exec(
"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.WhatsAppNumber, c.WhatsAppConnected, c.CreatedAt,
)
if err != nil {
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
c.ClientID = id
return nil
}
func (c *Client) Read(db *sql.DB, id int64) error {
return db.QueryRow(
"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,
).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 {
_, err := db.Exec(
"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.WhatsAppNumber, c.WhatsAppConnected, c.WhatsAppJID, c.ClientID, c.AccountID,
)
return err
}
func (c *Client) Delete(db *sql.DB) error {
_, err := db.Exec("DELETE FROM clients WHERE client_id = ? AND account_id = ?", c.ClientID, c.AccountID)
return err
}
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,''), COALESCE(whatsapp_number,''), COALESCE(whatsapp_connected,0), COALESCE(whatsapp_jid,''), created_at FROM clients"
args := []interface{}{}
if accountID > 0 {
query += " WHERE account_id = ?"
args = append(args, accountID)
}
query += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
rows, err := db.Query(query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var clients []Client
for rows.Next() {
var c Client
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
}
clients = append(clients, c)
}
return clients, rows.Err()
}
func GetClientByID(db *sql.DB, accountID, id int64) (*Client, error) {
var c Client
err := db.QueryRow(
"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,
).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 {
return nil, err
}
return &c, nil
}
func (cu *Customer) Create(db *sql.DB) error {
result, err := db.Exec(
"INSERT INTO customers (client_id, name, phone, birth_date, instagram, created_at) VALUES (?, ?, ?, ?, ?, ?)",
cu.ClientID, cu.Name, cu.Phone, cu.BirthDate, cu.Instagram, cu.CreatedAt,
)
if err != nil {
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
cu.CustomerID = id
return nil
}
func ListCustomers(db *sql.DB, accountID, clientID int64, limit, offset int) ([]Customer, error) {
args := []interface{}{}
query := "SELECT customer_id, client_id, name, phone, birth_date, instagram, created_at FROM customers"
cond := ""
if clientID > 0 {
cond = "client_id = ?"
args = append(args, clientID)
}
if accountID > 0 {
if cond != "" {
cond += " AND "
}
cond += "client_id IN (SELECT client_id FROM clients WHERE account_id = ?)"
args = append(args, accountID)
}
if cond != "" {
query += " WHERE " + cond
}
query += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
rows, err := db.Query(query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var customers []Customer
for rows.Next() {
var cu Customer
if err := rows.Scan(&cu.CustomerID, &cu.ClientID, &cu.Name, &cu.Phone, &cu.BirthDate, &cu.Instagram, &cu.CreatedAt); err != nil {
return nil, err
}
customers = append(customers, cu)
}
return customers, rows.Err()
}
func (s *Service) Create(db *sql.DB) error {
result, err := db.Exec(
"INSERT INTO services (client_id, name, price, description, duration, created_at) VALUES (?, ?, ?, ?, ?, ?)",
s.ClientID, s.Name, s.Price, s.Description, s.Duration, s.CreatedAt,
)
if err != nil {
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
s.ServiceID = id
return nil
}
func ListServices(db *sql.DB, accountID, clientID int64, limit, offset int) ([]Service, error) {
args := []interface{}{}
query := "SELECT service_id, client_id, name, price, description, duration, created_at FROM services"
cond := ""
if clientID > 0 {
cond = "client_id = ?"
args = append(args, clientID)
}
if accountID > 0 {
if cond != "" {
cond += " AND "
}
cond += "client_id IN (SELECT client_id FROM clients WHERE account_id = ?)"
args = append(args, accountID)
}
if cond != "" {
query += " WHERE " + cond
}
query += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
rows, err := db.Query(query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var services []Service
for rows.Next() {
var s Service
if err := rows.Scan(&s.ServiceID, &s.ClientID, &s.Name, &s.Price, &s.Description, &s.Duration, &s.CreatedAt); err != nil {
return nil, err
}
services = append(services, s)
}
return services, rows.Err()
}
func (sch *Schedule) Create(db *sql.DB) error {
result, err := db.Exec(
"INSERT INTO scheduling (client_id, customer_id, service_id, plan_date, time, status, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
sch.ClientID, sch.CustomerID, sch.ServiceID, sch.PlanDate, sch.Time, sch.Status, sch.CreatedAt,
)
if err != nil {
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
sch.ScheduleID = id
return nil
}
func ListSchedules(db *sql.DB, clientID, customerID int64, limit, offset int) ([]Schedule, error) {
query := "SELECT schedule_id, client_id, customer_id, service_id, plan_date, time, status, created_at FROM scheduling WHERE 1=1"
var args []interface{}
if clientID > 0 {
query += " AND client_id = ?"
args = append(args, clientID)
}
if customerID > 0 {
query += " AND customer_id = ?"
args = append(args, customerID)
}
query += " ORDER BY plan_date DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
rows, err := db.Query(query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var schedules []Schedule
for rows.Next() {
var sch Schedule
if err := rows.Scan(&sch.ScheduleID, &sch.ClientID, &sch.CustomerID, &sch.ServiceID, &sch.PlanDate, &sch.Time, &sch.Status, &sch.CreatedAt); err != nil {
return nil, err
}
schedules = append(schedules, sch)
}
return schedules, rows.Err()
}
func (p *Payment) Create(db *sql.DB) error {
result, err := db.Exec(
"INSERT INTO payments (client_id, customer_id, schedule_id, has_paid, amount, payment_date, payment_method, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
p.ClientID, p.CustomerID, p.ScheduleID, boolToInt(p.HasPaid), p.Amount, p.PaymentDate, p.PaymentMethod, p.CreatedAt,
)
if err != nil {
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
p.PaymentID = id
return nil
}
func ListPayments(db *sql.DB, clientID int64, limit, offset int) ([]Payment, error) {
query := "SELECT payment_id, client_id, customer_id, schedule_id, has_paid, amount, payment_date, payment_method, created_at FROM payments"
var args []interface{}
if clientID > 0 {
query += " WHERE client_id = ?"
args = append(args, clientID)
}
query += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
rows, err := db.Query(query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var payments []Payment
for rows.Next() {
var p Payment
var hasPaid int
if err := rows.Scan(&p.PaymentID, &p.ClientID, &p.CustomerID, &p.ScheduleID, &hasPaid, &p.Amount, &p.PaymentDate, &p.PaymentMethod, &p.CreatedAt); err != nil {
return nil, err
}
p.HasPaid = hasPaid == 1
payments = append(payments, p)
}
return payments, rows.Err()
}
func boolToInt(b bool) int {
if b {
return 1
}
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 {
QuestionID int64 `json:"question_id"`
ClientID int64 `json:"client_id"`
CustomerID int64 `json:"customer_id"`
Question string `json:"question"`
Timestamp int64 `json:"timestamp"`
Status string `json:"status"`
CreatedAt int64 `json:"created_at"`
}
func (q *Question) Create(db *sql.DB) error {
result, err := db.Exec(
"INSERT INTO questions (client_id, customer_id, question, timestamp, status, created_at) VALUES (?, ?, ?, ?, ?, ?)",
q.ClientID, q.CustomerID, q.Question, q.Timestamp, q.Status, q.CreatedAt,
)
if err != nil {
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
q.QuestionID = id
return nil
}
func ListQuestions(db *sql.DB, clientID int64, limit, offset int) ([]Question, error) {
query := "SELECT question_id, client_id, customer_id, question, timestamp, status, created_at FROM questions WHERE 1=1"
var args []interface{}
if clientID > 0 {
query += " AND client_id = ?"
args = append(args, clientID)
}
query += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
rows, err := db.Query(query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var questions []Question
for rows.Next() {
var q Question
if err := rows.Scan(&q.QuestionID, &q.ClientID, &q.CustomerID, &q.Question, &q.Timestamp, &q.Status, &q.CreatedAt); err != nil {
return nil, err
}
questions = append(questions, q)
}
return questions, rows.Err()
}
type Answer struct {
AnswerID int64 `json:"answer_id"`
ClientID int64 `json:"client_id"`
QuestionID int64 `json:"question_id"`
Answer string `json:"answer"`
Timestamp int64 `json:"timestamp"`
Status string `json:"status"`
CreatedAt int64 `json:"created_at"`
}
func (a *Answer) Create(db *sql.DB) error {
result, err := db.Exec(
"INSERT INTO answers (client_id, question_id, answer, timestamp, status, created_at) VALUES (?, ?, ?, ?, ?, ?)",
a.ClientID, a.QuestionID, a.Answer, a.Timestamp, a.Status, a.CreatedAt,
)
if err != nil {
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
a.AnswerID = id
return nil
}
func ListAnswers(db *sql.DB, questionID int64, limit, offset int) ([]Answer, error) {
query := "SELECT answer_id, client_id, question_id, answer, timestamp, status, created_at FROM answers WHERE 1=1"
var args []interface{}
if questionID > 0 {
query += " AND question_id = ?"
args = append(args, questionID)
}
query += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
rows, err := db.Query(query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var answers []Answer
for rows.Next() {
var a Answer
if err := rows.Scan(&a.AnswerID, &a.ClientID, &a.QuestionID, &a.Answer, &a.Timestamp, &a.Status, &a.CreatedAt); err != nil {
return nil, err
}
answers = append(answers, a)
}
return answers, rows.Err()
}
type AnswerWithDetails struct {
AnswerID int64 `json:"answer_id"`
ClientID int64 `json:"client_id"`
QuestionID int64 `json:"question_id"`
Answer string `json:"answer"`
Timestamp int64 `json:"timestamp"`
Status string `json:"status"`
CreatedAt int64 `json:"created_at"`
ClientName string `json:"client_name"`
CustomerName string `json:"customer_name"`
QuestionText string `json:"question_text"`
}
func ListAnswersWithDetails(db *sql.DB, accountID, questionID int64, limit, offset int) ([]AnswerWithDetails, error) {
args := []interface{}{accountID}
query := `
SELECT
a.answer_id, a.client_id, a.question_id, a.answer, a.timestamp, a.status, a.created_at,
c.name as client_name,
cu.name as customer_name,
q.question as question_text
FROM answers a
JOIN questions q ON a.question_id = q.question_id
JOIN customers cu ON q.customer_id = cu.customer_id
JOIN clients c ON q.client_id = c.client_id
WHERE c.account_id = ?`
if questionID > 0 {
query += " AND a.question_id = ?"
args = append(args, questionID)
}
query += " ORDER BY a.created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
rows, err := db.Query(query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var answers []AnswerWithDetails
for rows.Next() {
var a AnswerWithDetails
if err := rows.Scan(&a.AnswerID, &a.ClientID, &a.QuestionID, &a.Answer, &a.Timestamp, &a.Status, &a.CreatedAt, &a.ClientName, &a.CustomerName, &a.QuestionText); err != nil {
return nil, err
}
answers = append(answers, a)
}
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)
}
}
+395
View File
@@ -0,0 +1,395 @@
package db
import (
"database/sql"
"fmt"
"golang.org/x/text/encoding/charmap"
"os"
"path/filepath"
"strings"
"unicode/utf8"
_ "github.com/glebarez/sqlite"
)
const schema = `
CREATE TABLE IF NOT EXISTS accounts (
account_id INTEGER PRIMARY KEY AUTOINCREMENT,
email TEXT UNIQUE NOT NULL,
name TEXT NOT NULL,
password TEXT NOT NULL,
created_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS sessions (
session_id TEXT PRIMARY KEY,
account_id INTEGER NOT NULL,
expires INTEGER NOT NULL,
FOREIGN KEY (account_id) REFERENCES accounts(account_id)
);
CREATE TABLE IF NOT EXISTS clients (
client_id INTEGER PRIMARY KEY AUTOINCREMENT,
account_id INTEGER NOT NULL,
name TEXT NOT NULL,
phone TEXT,
email TEXT,
address TEXT,
notes TEXT,
whatsapp_number TEXT,
whatsapp_connected INTEGER DEFAULT 0,
created_at INTEGER NOT NULL,
whatsapp_jid TEXT,
FOREIGN KEY (account_id) REFERENCES accounts(account_id)
);
CREATE TABLE IF NOT EXISTS customers (
customer_id INTEGER PRIMARY KEY AUTOINCREMENT,
client_id INTEGER NOT NULL,
name TEXT NOT NULL,
phone TEXT,
birth_date TEXT,
instagram TEXT,
created_at INTEGER NOT NULL,
FOREIGN KEY (client_id) REFERENCES clients(client_id)
);
CREATE TABLE IF NOT EXISTS services (
service_id INTEGER PRIMARY KEY AUTOINCREMENT,
client_id INTEGER NOT NULL,
name TEXT NOT NULL,
price REAL,
description TEXT,
duration TEXT,
created_at INTEGER NOT NULL,
FOREIGN KEY (client_id) REFERENCES clients(client_id)
);
CREATE TABLE IF NOT EXISTS scheduling (
schedule_id INTEGER PRIMARY KEY AUTOINCREMENT,
client_id INTEGER NOT NULL,
customer_id INTEGER NOT NULL,
service_id INTEGER NOT NULL,
plan_date TEXT,
time TEXT,
status TEXT DEFAULT 'pending',
created_at INTEGER NOT NULL,
FOREIGN KEY (client_id) REFERENCES clients(client_id),
FOREIGN KEY (customer_id) REFERENCES customers(customer_id),
FOREIGN KEY (service_id) REFERENCES services(service_id)
);
CREATE TABLE IF NOT EXISTS payments (
payment_id INTEGER PRIMARY KEY AUTOINCREMENT,
client_id INTEGER NOT NULL,
customer_id INTEGER NOT NULL,
schedule_id INTEGER,
has_paid INTEGER DEFAULT 0,
amount REAL,
payment_date TEXT,
payment_method TEXT,
created_at INTEGER NOT NULL,
FOREIGN KEY (client_id) REFERENCES clients(client_id),
FOREIGN KEY (customer_id) REFERENCES customers(customer_id),
FOREIGN KEY (schedule_id) REFERENCES scheduling(schedule_id)
);
CREATE TABLE IF NOT EXISTS questions (
question_id INTEGER PRIMARY KEY AUTOINCREMENT,
client_id INTEGER NOT NULL,
customer_id INTEGER NOT NULL,
question TEXT NOT NULL,
timestamp INTEGER NOT NULL,
status TEXT DEFAULT 'pending',
created_at INTEGER NOT NULL,
FOREIGN KEY (client_id) REFERENCES clients(client_id),
FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);
CREATE TABLE IF NOT EXISTS answers (
answer_id INTEGER PRIMARY KEY AUTOINCREMENT,
client_id INTEGER NOT NULL,
question_id INTEGER NOT NULL,
answer TEXT NOT NULL,
timestamp INTEGER NOT NULL,
status TEXT DEFAULT 'active',
created_at INTEGER NOT NULL,
FOREIGN KEY (client_id) REFERENCES clients(client_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)
);
`
var dbPath = "data/go-crm.db"
func Init(path string) (*sql.DB, error) {
if path != "" {
dbPath = path
}
dir := filepath.Dir(dbPath)
fmt.Println("db.Init: data dir", dir)
if err := os.MkdirAll(dir, 0755); err != nil {
return nil, fmt.Errorf("failed to create data directory: %w", err)
}
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 {
return nil, fmt.Errorf("failed to open database: %w", err)
}
fmt.Println("db.Init: ping database")
if err := database.Ping(); err != nil {
return nil, fmt.Errorf("failed to ping database: %w", err)
}
fmt.Println("db.Init: executing schema")
if _, err := database.Exec(schema); err != nil {
return nil, fmt.Errorf("failed to create schema: %w", err)
}
fmt.Println("db.Init: running migrate")
if err := migrate(database); err != nil {
return nil, fmt.Errorf("failed to migrate: %w", err)
}
fmt.Println("db.Init: migration complete")
return database, nil
}
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")
if err != nil {
if !strings.Contains(err.Error(), "duplicate column name") {
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
}
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
}
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
}
}
+395
View File
@@ -0,0 +1,395 @@
package handlers
import (
"database/sql"
"fmt"
"net/http"
"time"
"go-crm/internal/templates"
"github.com/go-chi/chi/v5"
"golang.org/x/crypto/bcrypt"
)
// package-level globals kept for existing tests; App methods use a.DB directly.
var DB *sql.DB
func (a *App) SignupPage(w http.ResponseWriter, r *http.Request) {
content := fmt.Sprintf(`
<div class="min-h-[60vh] flex items-center justify-center">
<div class="w-full max-w-sm">
<div class="text-center mb-8">
<div class="inline-flex items-center justify-center w-12 h-12 rounded-xl bg-amber-400/10 border border-amber-400/20 mb-4">
<svg class="w-6 h-6 text-amber-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 10V3L4 14h7v7l9-11h-7z"/></svg>
</div>
<h1 class="text-2xl font-bold text-zinc-100 tracking-tight">go-crm</h1>
<p class="text-sm text-zinc-500 mt-1">Create your account</p>
</div>
<div class="card-industrial p-6">
<form method="POST" action="/auth/signup" class="space-y-4">
<div>
<label class="block text-[10px] font-mono uppercase tracking-wider text-zinc-500 mb-1.5">Email</label>
<input type="email" name="email" required class="input-industrial" placeholder="[email protected]">
</div>
<div>
<label class="block text-[10px] font-mono uppercase tracking-wider text-zinc-500 mb-1.5">Name</label>
<input type="text" name="name" required class="input-industrial" placeholder="Your name">
</div>
<div>
<label class="block text-[10px] font-mono uppercase tracking-wider text-zinc-500 mb-1.5">Password</label>
<input type="password" name="password" required class="input-industrial" placeholder="Min 8 characters">
</div>
<button type="submit" class="btn-primary w-full justify-center mt-2">Create Account</button>
</form>
</div>
<p class="text-center text-xs text-zinc-500 mt-6">Already have an account? <a href="/auth/login" class="text-amber-400 hover:text-amber-300 transition-colors">Sign in</a></p>
</div>
</div>`)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WriteHTMLPage(w, "Sign Up", "", content)
}
func (a *App) Signup(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
email := r.FormValue("email")
name := r.FormValue("name")
password := r.FormValue("password")
if email == "" || name == "" || password == "" {
http.Error(w, "All fields required", http.StatusBadRequest)
return
}
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err != nil {
http.Error(w, "Failed to hash password", http.StatusInternalServerError)
return
}
tx, err := a.DB.Begin()
if err != nil {
http.Error(w, "Failed to start transaction", http.StatusInternalServerError)
return
}
defer tx.Rollback()
_, err = tx.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
email, name, string(hashedPassword), time.Now().Unix(),
)
if err != nil {
http.Error(w, "Email already exists", http.StatusBadRequest)
return
}
var accountID int64
if err = tx.QueryRow("SELECT account_id FROM accounts WHERE email = ?", email).Scan(&accountID); err != nil {
http.Error(w, "Failed to create account", http.StatusInternalServerError)
return
}
if _, err = tx.Exec(
"INSERT INTO clients (account_id, name, created_at) VALUES (?, ?, ?)",
accountID, name, time.Now().Unix(),
); err != nil {
http.Error(w, "Failed to create client", http.StatusInternalServerError)
return
}
sessionID := generateSessionID()
expires := time.Now().Add(24 * time.Hour).Unix()
if _, err = tx.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
); err != nil {
http.Error(w, "Failed to create session", http.StatusInternalServerError)
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.Redirect(w, r, "/", http.StatusFound)
}
func (a *App) LoginPage(w http.ResponseWriter, r *http.Request) {
content := fmt.Sprintf(`
<div class="min-h-[60vh] flex items-center justify-center">
<div class="w-full max-w-sm">
<div class="text-center mb-8">
<div class="inline-flex items-center justify-center w-12 h-12 rounded-xl bg-amber-400/10 border border-amber-400/20 mb-4">
<svg class="w-6 h-6 text-amber-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 10V3L4 14h7v7l9-11h-7z"/></svg>
</div>
<h1 class="text-2xl font-bold text-zinc-100 tracking-tight">go-crm</h1>
<p class="text-sm text-zinc-500 mt-1">Sign in to your workspace</p>
</div>
<div class="card-industrial p-6">
<form method="POST" action="/auth/login" class="space-y-4">
<div>
<label class="block text-[10px] font-mono uppercase tracking-wider text-zinc-500 mb-1.5">Email</label>
<input type="email" name="email" required class="input-industrial" placeholder="[email protected]">
</div>
<div>
<label class="block text-[10px] font-mono uppercase tracking-wider text-zinc-500 mb-1.5">Password</label>
<input type="password" name="password" required class="input-industrial" placeholder="Enter your password">
</div>
<button type="submit" class="btn-primary w-full justify-center mt-2">Sign In</button>
</form>
</div>
<p class="text-center text-xs text-zinc-500 mt-6">Don't have an account? <a href="/auth/signup" class="text-amber-400 hover:text-amber-300 transition-colors">Create one</a></p>
</div>
</div>`)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WriteHTMLPage(w, "Sign In", "", content)
}
func (a *App) Login(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
email := r.FormValue("email")
password := r.FormValue("password")
var accountID int64
var hashedPassword string
err := a.DB.QueryRow("SELECT account_id, password FROM accounts WHERE email = ?", email).Scan(&accountID, &hashedPassword)
if err != nil {
http.Error(w, "Invalid credentials", http.StatusUnauthorized)
return
}
if err := bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(password)); err != nil {
http.Error(w, "Invalid credentials", http.StatusUnauthorized)
return
}
sessionID := generateSessionID()
expires := time.Now().Add(24 * time.Hour).Unix()
_, err = a.DB.Exec("INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)", sessionID, accountID, expires)
if err != nil {
http.Error(w, "Failed to create session", http.StatusInternalServerError)
return
}
http.SetCookie(w, &http.Cookie{Name: "session", Value: sessionID, Path: "/"})
http.Redirect(w, r, "/", http.StatusFound)
}
func (a *App) Logout(w http.ResponseWriter, r *http.Request) {
cookie, err := r.Cookie("session")
if err == nil {
a.DB.Exec("DELETE FROM sessions WHERE session_id = ?", cookie.Value)
}
http.SetCookie(w, &http.Cookie{Name: "session", Value: "", Path: "/", MaxAge: -1})
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
}
content := fmt.Sprintf(`
%s
<div class="max-w-lg animate-slide-up">
<div class="card-industrial p-6">
<form method="POST" action="/auth/account" class="space-y-4">
<div>
<label class="block text-[10px] font-mono uppercase tracking-wider text-zinc-500 mb-1.5">Name</label>
<input type="text" name="name" value="%s" class="input-industrial">
</div>
<div>
<label class="block text-[10px] font-mono uppercase tracking-wider text-zinc-500 mb-1.5">Email</label>
<input type="email" value="%s" disabled class="input-industrial opacity-50 cursor-not-allowed">
</div>
<div>
<label class="block text-[10px] font-mono uppercase tracking-wider text-zinc-500 mb-1.5">New Password</label>
<input type="password" name="password" class="input-industrial" placeholder="Leave blank to keep current">
</div>
<div class="pt-2">
<button type="submit" class="btn-primary">Update Account</button>
</div>
</form>
</div>
</div>`, templates.PageHeader("Account Settings", "Manage your profile and security"), htmlEscape(name), htmlEscape(email))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WriteHTMLPage(w, "Account", "", content)
}
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 {
return time.Now().Format("20060102150405") + "-" + randomString(32)
}
func randomString(n int) string {
const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
b := make([]byte, n)
for i := range b {
b[i] = letters[time.Now().UnixNano()%int64(len(letters))]
}
return string(b)
}
// SignupPage, Signup, LoginPage, Login, Logout, AccountPage, UpdateAccount
// are also kept as package-level functions for backward compat with test
// setups that call handlers.Signup directly. They delegate to the globals.
func SignupPage(w http.ResponseWriter, r *http.Request) {
a := &App{DB: DB, WAConnector: WAConnector}
a.SignupPage(w, r)
}
func Signup(w http.ResponseWriter, r *http.Request) {
a := &App{DB: DB, WAConnector: WAConnector}
a.Signup(w, r)
}
func LoginPage(w http.ResponseWriter, r *http.Request) {
a := &App{DB: DB, WAConnector: WAConnector}
a.LoginPage(w, r)
}
func Login(w http.ResponseWriter, r *http.Request) {
a := &App{DB: DB, WAConnector: WAConnector}
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) {
a := &App{DB: DB, WAConnector: WAConnector}
a.AccountPage(w, r)
}
func UpdateAccount(w http.ResponseWriter, r *http.Request) {
a := &App{DB: DB, WAConnector: WAConnector}
a.UpdateAccount(w, r)
}
+292
View File
@@ -0,0 +1,292 @@
package handlers
import (
"fmt"
"net/http"
"strconv"
"time"
"go-crm/internal/db"
"go-crm/internal/templates"
"github.com/go-chi/chi/v5"
)
func (a *App) ListClients(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
if limit == 0 {
limit = 20
}
clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
buf := templates.BufRender()
actions := `<button type="button" onclick="document.getElementById('clientForm').classList.toggle('hidden')" class="btn-primary"><svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/></svg> Add Client</button>`
fmt.Fprint(buf, templates.PageHeader("Clients", "Manage your business clients", actions))
// Add form
fmt.Fprintf(buf, `
<div id="clientForm" class="hidden mb-6 animate-slide-up">
<div class="card-industrial p-5">
<h3 class="text-sm font-semibold text-zinc-200 mb-4">New Client</h3>
<form hx-post="/clients" hx-target="#clientList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
<input type="text" name="name" placeholder="Name" required class="input-industrial">
<input type="tel" name="phone" placeholder="Phone" class="input-industrial">
<input type="email" name="email" placeholder="Email" class="input-industrial">
<input type="text" name="address" placeholder="Address" class="input-industrial">
<textarea name="notes" placeholder="Notes" class="input-industrial sm:col-span-2 lg:col-span-2" rows="2"></textarea>
<div class="flex items-end">
<button type="submit" class="btn-primary">Save Client</button>
</div>
</form>
</div>
</div>`)
if len(clients) == 0 {
fmt.Fprint(buf, templates.EmptyState(`<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M19 21V5a2 2 0 00-2-2H7a2 2 0 00-2 2v16m14 0h2m-2 0h-5m-9 0H3m2 0h5M9 7h1m-1 4h1m4-4h1m-1 4h1m-5 10v-5a1 1 0 011-1h2a1 1 0 011 1v5"/>`, "No clients found. Add your first client to get started."))
} else {
fmt.Fprintf(buf, `<div class="card-industrial overflow-hidden animate-slide-up stagger-1"><div class="overflow-x-auto">`)
fmt.Fprint(buf, templates.TableStart([]string{"Name", "Phone", "WhatsApp", "Created", "Actions"}))
for _, c := range clients {
var whatsappCell string
if c.WhatsAppNumber == "" {
whatsappCell = fmt.Sprintf(`<a href="/leads/connect?client_id=%d" class="btn-ghost btn-sm">Connect</a>`, c.ClientID)
} else {
connected := false
if a.WAConnector != nil {
connected, _ = a.WAConnector.IsConnected(r.Context(), c.ClientID)
}
if connected {
whatsappCell = fmt.Sprintf(`<span class="flex items-center gap-1.5"><span class="w-1.5 h-1.5 rounded-full bg-emerald-400"></span><span class="font-mono text-xs text-zinc-300">%s</span></span>`, htmlEscape(c.WhatsAppNumber))
} else if c.WhatsAppConnected == 1 {
whatsappCell = fmt.Sprintf(`<span class="flex items-center gap-1.5"><span class="w-1.5 h-1.5 rounded-full bg-rose-400"></span><span class="font-mono text-xs text-zinc-300">%s</span><a href="/leads/connect?client_id=%d" class="text-[10px] text-amber-400 hover:underline">reconnect</a></span>`, htmlEscape(c.WhatsAppNumber), c.ClientID)
} else {
whatsappCell = fmt.Sprintf(`<a href="/leads/connect?client_id=%d" class="btn-ghost btn-sm">Connect</a>`, c.ClientID)
}
}
created := time.Unix(c.CreatedAt, 0).Format("02/01/2006")
fmt.Fprintf(buf, `<tr>
<td class="font-medium text-zinc-200">%s</td>
<td class="font-mono text-xs">%s</td>
<td>%s</td>
<td class="text-xs text-zinc-500">%s</td>
<td>
<div class="flex items-center gap-2">
<a href="/clients/%d" class="btn-ghost btn-sm">View</a>
<button type="button" onclick="document.getElementById('editForm%d').classList.toggle('hidden')" class="btn-ghost btn-sm">Edit</button>
<form hx-delete="/clients/%d" hx-target="closest tr" hx-swap="outerHTML" style="display:inline">
<button type="submit" class="btn-danger btn-sm" onclick="return confirm('Delete this client?')">Delete</button>
</form>
</div>
</td>
</tr>`, htmlEscape(c.Name), htmlEscape(c.Phone), whatsappCell, created, c.ClientID, c.ClientID, c.ClientID)
}
fmt.Fprint(buf, templates.TableEnd())
fmt.Fprintf(buf, `</div></div>`)
// Edit forms (rendered below table, toggled via JS)
for _, c := range clients {
fmt.Fprintf(buf, `
<div id="editForm%d" class="hidden mt-4 animate-slide-up">
<div class="card-industrial p-5 border-amber-400/10">
<h3 class="text-sm font-semibold text-zinc-200 mb-4">Edit %s</h3>
<form hx-put="/clients/%d" hx-target="#clientList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
<input type="text" name="name" value="%s" class="input-industrial">
<input type="tel" name="phone" value="%s" class="input-industrial">
<input type="email" name="email" value="%s" class="input-industrial">
<input type="text" name="address" value="%s" class="input-industrial">
<textarea name="notes" class="input-industrial sm:col-span-2 lg:col-span-2" rows="2">%s</textarea>
<div class="flex items-end gap-2">
<button type="submit" class="btn-primary">Save</button>
<button type="button" onclick="document.getElementById('editForm%d').classList.add('hidden')" class="btn-ghost">Cancel</button>
</div>
</form>
</div>
</div>`, c.ClientID, htmlEscape(c.Name), c.ClientID, htmlEscape(c.Name), htmlEscape(c.Phone), htmlEscape(c.Email), htmlEscape(c.Address), htmlEscape(c.Notes), c.ClientID)
}
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Clients", "clients")
}
func (a *App) CreateClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
r.ParseForm()
client := db.Client{
AccountID: accountID,
Name: r.FormValue("name"),
Phone: r.FormValue("phone"),
Email: r.FormValue("email"),
Address: r.FormValue("address"),
Notes: r.FormValue("notes"),
CreatedAt: time.Now().Unix(),
}
if err := client.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) ViewClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
client, err := db.GetClientByID(a.DB, accountID, id)
if err != nil {
http.Error(w, "Client not found", http.StatusNotFound)
return
}
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader(htmlEscape(client.Name), "Client details and WhatsApp connection"))
waSection := ""
if client.WhatsAppNumber != "" {
connected := false
if a.WAConnector != nil {
connected, _ = a.WAConnector.IsConnected(r.Context(), client.ClientID)
}
statusPill := `<span class="pill pill-rose">Disconnected</span>`
if connected {
statusPill = `<span class="pill pill-emerald">Connected</span>`
} else if client.WhatsAppConnected == 1 {
statusPill = `<span class="pill pill-amber">Stale</span>`
}
waSection = fmt.Sprintf(`
<div class="card-industrial p-5 mb-6">
<div class="flex items-center justify-between mb-4">
<h3 class="text-sm font-semibold text-zinc-200">WhatsApp</h3>
%s
</div>
<div class="font-mono text-sm text-zinc-300">%s</div>
<div class="mt-4">
<a href="/leads/connect?client_id=%d" class="btn-ghost btn-sm">%s</a>
</div>
</div>`, statusPill, htmlEscape(client.WhatsAppNumber), client.ClientID, map[bool]string{true: "Reconnect", false: "Reconnect"}[true])
} else {
waSection = fmt.Sprintf(`
<div class="card-industrial p-5 mb-6">
<h3 class="text-sm font-semibold text-zinc-200 mb-2">WhatsApp</h3>
<p class="text-sm text-zinc-500 mb-4">No WhatsApp number configured for this client.</p>
<a href="/leads/connect?client_id=%d" class="btn-primary btn-sm">Connect WhatsApp</a>
</div>`, client.ClientID)
}
fmt.Fprintf(buf, `
<div class="grid grid-cols-1 lg:grid-cols-3 gap-6 animate-slide-up">
<div class="lg:col-span-2">
<div class="card-industrial p-5">
<h3 class="text-sm font-semibold text-zinc-200 mb-4">Details</h3>
<div class="space-y-3">
<div class="flex justify-between py-2 border-b border-white/[0.04]">
<span class="text-xs text-zinc-500 font-mono uppercase">Phone</span>
<span class="text-sm text-zinc-300 font-mono">%s</span>
</div>
<div class="flex justify-between py-2 border-b border-white/[0.04]">
<span class="text-xs text-zinc-500 font-mono uppercase">Email</span>
<span class="text-sm text-zinc-300">%s</span>
</div>
<div class="flex justify-between py-2 border-b border-white/[0.04]">
<span class="text-xs text-zinc-500 font-mono uppercase">Address</span>
<span class="text-sm text-zinc-300">%s</span>
</div>
<div class="flex justify-between py-2">
<span class="text-xs text-zinc-500 font-mono uppercase">Notes</span>
<span class="text-sm text-zinc-300">%s</span>
</div>
</div>
</div>
</div>
<div>
%s
</div>
</div>
<div class="mt-4">
<a href="/clients" class="btn-ghost btn-sm">Back to Clients</a>
</div>`, htmlEscape(client.Phone), htmlEscape(client.Email), htmlEscape(client.Address), htmlEscape(client.Notes), waSection)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, client.Name, "clients")
}
func (a *App) UpdateClient(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()
client := db.Client{
ClientID: id,
AccountID: accountID,
Name: r.FormValue("name"),
Phone: r.FormValue("phone"),
Email: r.FormValue("email"),
Address: r.FormValue("address"),
Notes: r.FormValue("notes"),
}
if err := client.Update(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) DeleteClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
client := &db.Client{ClientID: id, AccountID: accountID}
if err := client.Delete(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(""))
}
// --- 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")
}
}
+272
View File
@@ -0,0 +1,272 @@
package handlers
import (
"fmt"
"net/http"
"strconv"
"time"
"go-crm/config"
"go-crm/internal/db"
"go-crm/internal/templates"
"github.com/go-chi/chi/v5"
)
func (a *App) ListCustomers(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
clientID, _ := strconv.ParseInt(r.URL.Query().Get("client_id"), 10, 64)
if limit == 0 {
limit = 20
}
customers, err := db.ListCustomers(a.DB, accountID, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
var clientOptions string
for _, c := range clients {
clientOptions += fmt.Sprintf(`<option value="%d">%s</option>`, c.ClientID, htmlEscape(c.Name))
}
buf := templates.BufRender()
actions := `<button type="button" onclick="document.getElementById('customerForm').classList.toggle('hidden')" class="btn-primary"><svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/></svg> Add Customer</button>`
fmt.Fprint(buf, templates.PageHeader("Customers", "Your customer database", actions))
fmt.Fprintf(buf, `
<div id="customerForm" class="hidden mb-6 animate-slide-up">
<div class="card-industrial p-5">
<h3 class="text-sm font-semibold text-zinc-200 mb-4">New Customer</h3>
<form hx-post="/customers" hx-target="#customerList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
<input type="text" name="name" placeholder="Name" required class="input-industrial">
<input type="tel" name="phone" placeholder="Phone" class="input-industrial">
<input type="date" name="birth_date" class="input-industrial">
<input type="text" name="instagram" placeholder="Instagram" class="input-industrial">
<select name="client_id" required class="input-industrial"><option value="">Select Client</option>%s</select>
<div class="flex items-end"><button type="submit" class="btn-primary">Save</button></div>
</form>
</div>
</div>`, clientOptions)
if len(customers) == 0 {
fmt.Fprint(buf, templates.EmptyState(`<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M12 4.354a4 4 0 110 5.292M15 21H3v-1a6 6 0 0112 0v1zm0 0h6v-1a6 6 0 00-9-5.197M13 7a4 4 0 11-8 0 4 4 0 018 0z"/>`, "No customers found. Add your first customer."))
} else {
fmt.Fprintf(buf, `<div class="card-industrial overflow-hidden animate-slide-up stagger-1"><div class="overflow-x-auto">`)
fmt.Fprint(buf, templates.TableStart([]string{"Name", "Phone", "Birth Date", "Instagram", "Actions"}))
for _, c := range customers {
fmt.Fprintf(buf, `<tr>
<td class="font-medium text-zinc-200">%s</td>
<td class="font-mono text-xs text-zinc-300">%s</td>
<td class="text-xs text-zinc-400">%s</td>
<td class="text-xs text-zinc-400">%s</td>
<td>
<div class="flex items-center gap-2">
<a href="/customers/%d" class="btn-ghost btn-sm">View</a>
<button type="button" onclick="document.getElementById('editCust%d').classList.toggle('hidden')" class="btn-ghost btn-sm">Edit</button>
<form hx-delete="/customers/%d" hx-target="closest tr" hx-swap="outerHTML" style="display:inline">
<button type="submit" class="btn-danger btn-sm" onclick="return confirm('Delete?')">Delete</button>
</form>
</div>
</td>
</tr>`, htmlEscape(c.Name), htmlEscape(c.Phone), htmlEscape(c.BirthDate), htmlEscape(c.Instagram), c.CustomerID, c.CustomerID, c.CustomerID)
}
fmt.Fprint(buf, templates.TableEnd())
fmt.Fprintf(buf, `</div></div>`)
for _, c := range customers {
fmt.Fprintf(buf, `
<div id="editCust%d" class="hidden mt-4 animate-slide-up">
<div class="card-industrial p-5 border-amber-400/10">
<h3 class="text-sm font-semibold text-zinc-200 mb-3">Edit %s</h3>
<form hx-put="/customers/%d" hx-target="#customerList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-3">
<input type="text" name="name" value="%s" class="input-industrial text-xs">
<input type="tel" name="phone" value="%s" class="input-industrial text-xs">
<input type="date" name="birth_date" value="%s" class="input-industrial text-xs">
<input type="text" name="instagram" value="%s" class="input-industrial text-xs">
<select name="client_id" class="input-industrial text-xs"><option value="%d">%s</option>%s</select>
<div class="flex items-end gap-2">
<button type="submit" class="btn-primary btn-sm">Save</button>
<button type="button" onclick="document.getElementById('editCust%d').classList.add('hidden')" class="btn-ghost btn-sm">Cancel</button>
</div>
</form>
</div>
</div>`, c.CustomerID, htmlEscape(c.Name), c.CustomerID, htmlEscape(c.Name), htmlEscape(c.Phone), htmlEscape(c.BirthDate), htmlEscape(c.Instagram), c.ClientID, htmlEscape(c.Name), clientOptions, c.CustomerID)
}
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Customers", "customers")
}
func (a *App) CreateCustomer(w http.ResponseWriter, r *http.Request) {
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 {
return
}
r.ParseForm()
if clientID == 0 {
clientID, _ = strconv.ParseInt(r.FormValue("client_id"), 10, 64)
}
if !isInternal {
var checkID int64
err := a.DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID)
if err != nil {
http.Error(w, "Invalid client", http.StatusBadRequest)
return
}
}
customer := db.Customer{
ClientID: clientID,
Name: r.FormValue("name"),
Phone: r.FormValue("phone"),
BirthDate: r.FormValue("birth_date"),
Instagram: r.FormValue("instagram"),
CreatedAt: time.Now().Unix(),
}
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)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) ViewCustomer(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
var c db.Customer
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 {
http.Error(w, "Customer not found", http.StatusNotFound)
return
}
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader(htmlEscape(c.Name), "Customer profile"))
fmt.Fprintf(buf, `
<div class="max-w-lg animate-slide-up">
<div class="card-industrial p-6">
<div class="space-y-3">
<div class="flex justify-between py-3 border-b border-white/[0.04]">
<span class="text-xs font-mono uppercase text-zinc-500">Phone</span>
<span class="text-sm font-mono text-zinc-300">%s</span>
</div>
<div class="flex justify-between py-3 border-b border-white/[0.04]">
<span class="text-xs font-mono uppercase text-zinc-500">Birth Date</span>
<span class="text-sm text-zinc-300">%s</span>
</div>
<div class="flex justify-between py-3">
<span class="text-xs font-mono uppercase text-zinc-500">Instagram</span>
<span class="text-sm text-zinc-300">%s</span>
</div>
</div>
<div class="mt-6">
<a href="/customers" class="btn-ghost btn-sm">Back</a>
</div>
</div>
</div>`, htmlEscape(c.Phone), htmlEscape(c.BirthDate), htmlEscape(c.Instagram))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, c.Name, "customers")
}
func (a *App) UpdateCustomer(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
_, 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 {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) DeleteCustomer(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
a.DB.Exec("DELETE FROM customers WHERE customer_id = ?", id)
}
// --- package-level shims ---
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)
}
}
+228
View File
@@ -0,0 +1,228 @@
package handlers
import (
"fmt"
"html/template"
"net/http"
"time"
"go-crm/internal/db"
"go-crm/internal/templates"
)
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)
// Gather metrics
var reviewCount int
var totalLeads int
var totalScheduled int
var totalRevenue float64
var totalSales int
var totalCustomers int
var totalServices int
var pendingSchedules int
if clientID > 0 {
a.DB.QueryRow("SELECT COUNT(*) FROM leads WHERE client_id = ? AND needs_review = 1", clientID).Scan(&reviewCount)
a.DB.QueryRow("SELECT COUNT(*) FROM leads WHERE client_id = ?", clientID).Scan(&totalLeads)
a.DB.QueryRow("SELECT COUNT(*) FROM leads WHERE client_id = ? AND status = 'Agendou'", clientID).Scan(&totalScheduled)
a.DB.QueryRow("SELECT COALESCE(SUM(amount),0), COUNT(*) FROM payments WHERE client_id = ? AND has_paid = 1", clientID).Scan(&totalRevenue, &totalSales)
a.DB.QueryRow("SELECT COUNT(*) FROM customers WHERE client_id IN (SELECT client_id FROM clients WHERE account_id = ?)", accountID).Scan(&totalCustomers)
a.DB.QueryRow("SELECT COUNT(*) FROM services WHERE client_id = ?", clientID).Scan(&totalServices)
a.DB.QueryRow("SELECT COUNT(*) FROM scheduling WHERE client_id = ? AND status = 'pending'", clientID).Scan(&pendingSchedules)
}
// WhatsApp status
waConnected := false
waPhone := ""
if a.WAConnector != nil && clientID > 0 {
if connected, _ := a.WAConnector.IsConnected(r.Context(), clientID); connected {
waConnected = true
} else {
var dbConnected int
a.DB.QueryRow("SELECT whatsapp_connected FROM clients WHERE client_id = ?", clientID).Scan(&dbConnected)
if dbConnected == 1 {
waConnected = true
}
}
var waNum string
a.DB.QueryRow("SELECT COALESCE(whatsapp_number,'') FROM clients WHERE client_id = ?", clientID).Scan(&waNum)
waPhone = waNum
}
// Recent leads
var recentLeads []db.Lead
if clientID > 0 {
leads, _ := db.ListAllLeads(a.DB, clientID, 5, 0)
recentLeads = leads
}
// Account name
var accountName string
a.DB.QueryRow("SELECT COALESCE(name,'User') FROM accounts WHERE account_id = ?", accountID).Scan(&accountName)
buf := templates.BufRender()
// KPI Row
fmt.Fprintf(buf, `<div class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4 mb-6">`)
fmt.Fprint(buf, templates.KPICard("Total Leads", fmt.Sprintf("%d", totalLeads), "", "amber", `<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M17 20h5v-2a3 3 0 00-5.356-1.857M17 20H7m10 0v-2c0-.656-.126-1.283-.356-1.857M7 20H2v-2a3 3 0 015.356-1.857M7 20v-2c0-.656.126-1.283.356-1.857m0 0a5.002 5.002 0 019.288 0M15 7a3 3 0 11-6 0 3 3 0 016 0z"/>`, 1))
fmt.Fprint(buf, templates.KPICard("Agendamentos", fmt.Sprintf("%d", totalScheduled), "", "emerald", `<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z"/>`, 2))
fmt.Fprint(buf, templates.KPICard("Revenue", fmt.Sprintf("R$ %.2f", totalRevenue), fmt.Sprintf("%d sales", totalSales), "sky", `<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8c-1.657 0-3 .895-3 2s1.343 2 3 2 3-.895 3-2-1.343-2-3-2zm0 0v1m0 0v1m0-1h1m-1 0H9m12 0a2 2 0 012 2v4.5a2.5 2.5 0 01-2.5 2.5h-15a2.5 2.5 0 01-2.5-2.5V10a2 2 0 012-2h15z"/>`, 3))
fmt.Fprint(buf, templates.KPICard("Pending Review", fmt.Sprintf("%d", reviewCount), "", "rose", `<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"/>`, 4))
fmt.Fprintf(buf, `</div>`)
// Secondary KPIs
fmt.Fprintf(buf, `<div class="grid grid-cols-2 sm:grid-cols-4 gap-3 mb-6">`)
secondaryKPIs := []struct{ label, value string }{
{"Customers", fmt.Sprintf("%d", totalCustomers)},
{"Services", fmt.Sprintf("%d", totalServices)},
{"Pending Schedules", fmt.Sprintf("%d", pendingSchedules)},
{"Conversion Rate", fmt.Sprintf("%.1f%%", conversionRate(totalScheduled, totalLeads))},
}
for _, kpi := range secondaryKPIs {
fmt.Fprintf(buf, `
<div class="bg-zinc-900 border border-white/[0.06] rounded-lg p-3 animate-slide-up">
<div class="text-[10px] font-mono uppercase tracking-wider text-zinc-500 mb-1">%s</div>
<div class="text-lg font-mono font-semibold text-zinc-200">%s</div>
</div>`, kpi.label, kpi.value)
}
fmt.Fprintf(buf, `</div>`)
// WhatsApp Status Card
waIcon := `<span class="w-2 h-2 rounded-full bg-rose-400 animate-pulse"></span>`
waText := "Disconnected"
waSub := "No active session"
waAction := fmt.Sprintf(`<a href="/leads/connect?client_id=%d" class="btn-primary btn-sm">Connect</a>`, clientID)
if waConnected {
waIcon = `<span class="w-2 h-2 rounded-full bg-emerald-400 animate-pulse"></span>`
waText = "Connected"
waSub = waPhone
waAction = `<span class="pill pill-emerald">Online</span>`
} else if clientID == 0 {
waAction = `<a href="/clients" class="btn-ghost btn-sm">Create Client</a>`
}
if waPhone == "" && clientID > 0 {
waSub = "Phone not configured"
}
fmt.Fprintf(buf, `
<div class="card-industrial p-4 mb-6 border animate-slide-up stagger-2">
<div class="flex items-center justify-between">
<div class="flex items-center gap-3">
<div class="w-10 h-10 rounded-lg bg-emerald-400/5 border border-emerald-400/10 flex items-center justify-center">
<svg class="w-5 h-5 text-emerald-400" fill="currentColor" viewBox="0 0 24 24"><path d="M17.472 14.382c-.297-.149-1.758-.867-2.03-.967-.273-.099-.471-.148-.67.15-.197.297-.767.966-.94 1.164-.173.199-.347.223-.644.075-.297-.15-1.255-.463-2.39-1.475-.883-.788-1.48-1.761-1.653-2.059-.173-.297-.018-.458.13-.606.134-.133.298-.347.446-.521.149-.174.198-.298.298-.497.099-.198.05-.371-.025-.52-.075-.149-.669-1.612-.916-2.207-.242-.579-.487-.5-.669-.51-.173-.008-.371-.01-.57-.01-.198 0-.52.074-.792.372-.272.297-1.04 1.016-1.04 2.479 0 1.462 1.065 2.875 1.213 3.074.149.198 2.096 3.2 5.077 4.487.709.306 1.262.489 1.694.625.712.227 1.36.195 1.871.118.571-.085 1.758-.719 2.006-1.413.248-.694.248-1.289.173-1.413-.074-.124-.272-.198-.57-.347m-5.421 7.403h-.004a9.87 9.87 0 01-5.051-1.38l-.361-.214-3.741.982.998-3.648-.235-.374a9.86 9.86 0 01-1.379-5.05c0-5.445 4.428-9.872 9.873-9.872 2.38 0 4.618.829 6.42 2.33a9.77 9.77 0 012.356 6.42c0 5.445-4.429 9.873-9.873 9.873m8.52-3.378a10.11 10.11 0 01-2.332 2.357 8.67 8.67 0 01-6.42 2.33c-5.28 0-9.58-4.298-9.58-9.578 0-5.28 4.3-9.58 9.58-9.58 2.38 0 4.618.83 6.42 2.33a10.11 10.11 0 012.332 2.357c1.152 1.522 1.756 3.347 1.756 5.28 0 1.934-.604 3.758-1.756 5.28"/></svg>
</div>
<div>
<div class="flex items-center gap-2">
%s
<span class="text-sm font-semibold text-zinc-200">%s</span>
</div>
<div class="text-xs text-zinc-500 font-mono mt-0.5">%s</div>
</div>
</div>
<div>%s</div>
</div>
</div>`, waIcon, waText, waSub, waAction)
// Recent Leads Section
var recentHTML string
if len(recentLeads) == 0 {
recentHTML = string(templates.EmptyState(`<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M17 20h5v-2a3 3 0 00-5.356-1.857M17 20H7m10 0v-2c0-.656-.126-1.283-.356-1.857M7 20H2v-2a3 3 0 015.356-1.857M7 20v-2c0-.656.126-1.283.356-1.857m0 0a5.002 5.002 0 019.288 0M15 7a3 3 0 11-6 0 3 3 0 016 0z"/>`, "No leads yet. Connect WhatsApp to start capturing."))
} else {
recentHTML = string(templates.TableStart([]string{"Phone", "Name", "Service", "Status", "Arrived"}))
for _, l := range recentLeads {
statusPill := statusPillHTML(l.Status)
reviewBadge := ""
if l.NeedsReview {
reviewBadge = `<span class="ml-2 pill pill-rose">review</span>`
}
arrived := time.Unix(l.CreatedAt, 0).Format("02/01 15:04")
recentHTML += fmt.Sprintf(`<tr>
<td class="font-mono text-xs">%s</td>
<td>%s%s</td>
<td class="text-zinc-400">%s</td>
<td>%s</td>
<td class="text-xs text-zinc-500">%s</td>
</tr>`, htmlEscape(l.PhoneNormalized), htmlEscape(l.Name), reviewBadge, htmlEscape(l.ServiceInterest), statusPill, arrived)
}
recentHTML += string(templates.TableEnd())
}
fmt.Fprint(buf, templates.SectionCard("Recent Leads", "Last 5 captured entries", template.HTML(recentHTML)))
// Quick actions
fmt.Fprintf(buf, `
<div class="mt-6 grid grid-cols-1 sm:grid-cols-3 gap-4 animate-slide-up stagger-3">
<a href="/leads/review" class="card-industrial p-4 hover:bg-white/[0.02] transition-colors group">
<div class="flex items-center gap-3">
<div class="w-8 h-8 rounded bg-rose-400/10 flex items-center justify-center group-hover:bg-rose-400/15 transition-colors">
<svg class="w-4 h-4 text-rose-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"/></svg>
</div>
<div>
<div class="text-sm font-medium text-zinc-200">Review Queue</div>
<div class="text-xs text-zinc-500">%d pending</div>
</div>
</div>
</a>
<a href="/report" class="card-industrial p-4 hover:bg-white/[0.02] transition-colors group">
<div class="flex items-center gap-3">
<div class="w-8 h-8 rounded bg-sky-400/10 flex items-center justify-center group-hover:bg-sky-400/15 transition-colors">
<svg class="w-4 h-4 text-sky-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6m10 0v-6a2 2 0 012-2h2a2 2 0 012 2v6m-6 0V7a2 2 0 012-2h2a2 2 0 012 2v12"/></svg>
</div>
<div>
<div class="text-sm font-medium text-zinc-200">Monthly Report</div>
<div class="text-xs text-zinc-500">Performance analytics</div>
</div>
</div>
</a>
<a href="/clients" class="card-industrial p-4 hover:bg-white/[0.02] transition-colors group">
<div class="flex items-center gap-3">
<div class="w-8 h-8 rounded bg-amber-400/10 flex items-center justify-center group-hover:bg-amber-400/15 transition-colors">
<svg class="w-4 h-4 text-amber-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M19 21V5a2 2 0 00-2-2H7a2 2 0 00-2 2v16m14 0h2m-2 0h-5m-9 0H3m2 0h5M9 7h1m-1 4h1m4-4h1m-1 4h1m-5 10v-5a1 1 0 011-1h2a1 1 0 011 1v5"/></svg>
</div>
<div>
<div class="text-sm font-medium text-zinc-200">Clients</div>
<div class="text-xs text-zinc-500">Manage your businesses</div>
</div>
</div>
</a>
</div>`, reviewCount)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Dashboard", "dashboard")
}
func conversionRate(scheduled, total int) float64 {
if total == 0 {
return 0
}
return float64(scheduled) / float64(total) * 100
}
func statusPillHTML(status string) string {
color := "pill-zinc"
switch status {
case "Agendou":
color = "pill-emerald"
case "Cancelou":
color = "pill-rose"
case "Converteu":
color = "pill-sky"
case "Em negociacao":
color = "pill-amber"
}
return fmt.Sprintf(`<span class="pill %s">%s</span>`, color, htmlEscape(status))
}
// Dashboard is the package-level shim.
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,203 @@
package handlers
import (
"fmt"
"html/template"
"net/http"
"strconv"
"go-crm/internal/db"
"go-crm/internal/templates"
"github.com/go-chi/chi/v5"
)
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)
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader("Keyword Mapping", "Auto-detect services from WhatsApp messages"))
if pendingCount > 0 {
fmt.Fprintf(buf, `<div class="mb-4"><a href="/leads/review" class="inline-flex items-center gap-2 px-3 py-2 bg-rose-400/5 border border-rose-400/15 rounded-lg text-xs text-rose-400 hover:bg-rose-400/10 transition-colors"><span class="w-1.5 h-1.5 rounded-full bg-rose-400 animate-pulse"></span>%d pending review</a></div>`, pendingCount)
}
// Service Keywords Section
keywordForm := fmt.Sprintf(`
<form hx-post="/leads/keywords" hx-target="#keywordTable" hx-swap="outerHTML" class="flex flex-wrap gap-3 mb-4">
<select name="service_name" class="input-industrial max-w-xs">%s</select>
<input type="text" name="keyword" placeholder="Keyword (e.g. massagem)" required class="input-industrial max-w-xs">
<button type="submit" class="btn-primary">Add Keyword</button>
</form>
%s`, buildServiceSelectOptions(services), renderKeywordTable(kws))
fmt.Fprint(buf, templates.SectionCard("Service Keywords", "Add keywords that trigger automatic service detection. Case and accent insensitive.", template.HTML(keywordForm)))
// Statuses Section
statusForm := fmt.Sprintf(`
<form hx-post="/leads/statuses" hx-target="#statusTable" hx-swap="outerHTML" class="flex flex-wrap gap-3 mb-4">
<input type="text" name="status_name" placeholder="New status name" required class="input-industrial max-w-xs">
<button type="submit" class="btn-primary">Add Status</button>
</form>
%s`, renderStatusTable(statuses))
fmt.Fprintf(buf, `<div class="mt-6">%s</div>`, templates.SectionCard("Lead Statuses", "Manage the status options available for leads.", template.HTML(statusForm)))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Keyword Mapping", "")
}
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))
}
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))
}
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))
}
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))
}
func buildServiceSelectOptions(services []string) string {
out := ""
for _, s := range services {
if s == "Não especificou" {
continue
}
out += fmt.Sprintf(`<option value="%s">%s</option>`, htmlEscape(s), htmlEscape(s))
}
return out
}
func renderKeywordTable(kws []db.ServiceKeyword) string {
out := `<div id="keywordTable"><table class="data-table"><thead><tr><th>Service</th><th>Keyword</th><th>Actions</th></tr></thead><tbody>`
if len(kws) == 0 {
out += `<tr><td colspan="3" class="text-zinc-500 text-sm py-4">No keywords defined.</td></tr>`
}
for _, kw := range kws {
out += fmt.Sprintf(`
<tr>
<td class="text-zinc-200">%s</td>
<td class="font-mono text-xs text-amber-400">%s</td>
<td>
<form hx-delete="/leads/keywords/%d" hx-target="#keywordTable" hx-swap="outerHTML" style="display:inline">
<button type="submit" class="btn-danger btn-sm">Remove</button>
</form>
</td>
</tr>`, htmlEscape(kw.ServiceName), htmlEscape(kw.Keyword), kw.KeywordID)
}
out += `</tbody></table></div>`
return out
}
func renderStatusTable(statuses []db.LeadStatus) string {
out := `<div id="statusTable"><table class="data-table"><thead><tr><th>Status</th><th>Actions</th></tr></thead><tbody>`
if len(statuses) == 0 {
out += `<tr><td colspan="2" class="text-zinc-500 text-sm py-4">No statuses defined.</td></tr>`
}
for _, s := range statuses {
out += fmt.Sprintf(`
<tr>
<td><span class="pill pill-zinc">%s</span></td>
<td>
<form hx-delete="/leads/statuses/%d" hx-target="#statusTable" hx-swap="outerHTML" style="display:inline">
<button type="submit" class="btn-danger btn-sm">Remove</button>
</form>
</td>
</tr>`, htmlEscape(s.StatusName), s.StatusID)
}
out += `</tbody></table></div>`
return out
}
// --- package-level shims ---
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,365 @@
package handlers
import (
"fmt"
"net/http"
"strconv"
"strings"
"time"
"go-crm/internal/db"
"go-crm/internal/templates"
"github.com/go-chi/chi/v5"
)
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)
buf := templates.BufRender()
badge := ""
if pendingCount > 0 {
badge = fmt.Sprintf(`<span class="ml-2 pill pill-rose">%d</span>`, pendingCount)
}
fmt.Fprint(buf, templates.PageHeader("Review Queue", "Confirm or correct leads with unidentified service interest"))
fmt.Fprintf(buf, `<div class="mb-4">%s</div>`, badge)
if len(leads) == 0 {
fmt.Fprint(buf, templates.EmptyState(`<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"/>`, "All caught up! No leads pending review."))
} else {
fmt.Fprintf(buf, `<div class="card-industrial overflow-hidden animate-slide-up"><div class="overflow-x-auto">`)
fmt.Fprint(buf, templates.TableStart([]string{"Phone", "Name", "Service Interest", "Status", "Arrived", "Actions"}))
for _, l := range leads {
arrived := time.Unix(l.CreatedAt, 0).Format("02/01 15:04")
fmt.Fprintf(buf, `<tr id="row-%d">
<td class="font-mono text-xs text-zinc-300">%s</td>
<td class="font-medium text-zinc-200">%s</td>
<td>
<form hx-put="/leads/%d/review" hx-target="#row-%d" hx-swap="outerHTML" class="flex flex-col gap-2">
<select name="service_interest" class="input-industrial text-xs">%s</select>
<select name="status" class="input-industrial text-xs">%s</select>
<input type="text" name="name" value="%s" class="input-industrial text-xs" placeholder="Name">
<button type="submit" class="btn-primary btn-sm self-start">Confirm</button>
</form>
</td>
<td><span class="pill pill-amber">%s</span></td>
<td class="text-xs text-zinc-500">%s</td>
<td>
<form hx-delete="/leads/%d" hx-target="#row-%d" hx-swap="outerHTML" style="display:inline">
<button type="submit" class="btn-danger btn-sm" 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.Fprint(buf, templates.TableEnd())
fmt.Fprintf(buf, `</div></div>`)
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Review Queue", "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" class="htmx-swapping" style="display:none"></tr>`, leadID)
}
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
}
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)
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader("All Leads", "Complete lead database with filters and inline editing"))
if pendingCount > 0 {
fmt.Fprintf(buf, `<div class="mb-4"><a href="/leads/review" class="inline-flex items-center gap-2 px-3 py-2 bg-rose-400/5 border border-rose-400/15 rounded-lg text-xs text-rose-400 hover:bg-rose-400/10 transition-colors"><span class="w-1.5 h-1.5 rounded-full bg-rose-400 animate-pulse"></span>%d pending review</a></div>`, pendingCount)
}
if len(leads) == 0 {
fmt.Fprint(buf, templates.EmptyState(`<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M17 20h5v-2a3 3 0 00-5.356-1.857M17 20H7m10 0v-2c0-.656-.126-1.283-.356-1.857M7 20H2v-2a3 3 0 015.356-1.857M7 20v-2c0-.656.126-1.283.356-1.857m0 0a5.002 5.002 0 019.288 0M15 7a3 3 0 11-6 0 3 3 0 016 0z"/>`, "No leads captured yet. Connect WhatsApp to start."))
} else {
fmt.Fprintf(buf, `<div class="card-industrial overflow-hidden animate-slide-up"><div class="overflow-x-auto">`)
fmt.Fprint(buf, templates.TableStart([]string{"Phone", "Name", "Service", "Status", "Payment", "Arrived", "Last Contact", "Actions"}))
for _, l := range leads {
arrived := time.Unix(l.CreatedAt, 0).Format("02/01 15:04")
lastContact := time.Unix(l.LastContactAt, 0).Format("02/01 15:04")
rowClass := ""
if l.NeedsReview {
rowClass = `class="bg-amber-400/[0.03]"`
}
statusPill := statusPillHTML(l.Status)
fmt.Fprintf(buf, `<tr %s id="lead-%d">
<td class="font-mono text-xs text-zinc-300">%s</td>
<td class="font-medium text-zinc-200">%s %s</td>
<td class="text-zinc-400 text-xs">%s</td>
<td>%s</td>
<td class="text-xs text-zinc-400">%s</td>
<td class="text-xs text-zinc-500">%s</td>
<td class="text-xs text-zinc-500">%s</td>
<td>
<div class="flex items-center gap-2">
<button onclick="document.getElementById('edit-%d').classList.toggle('hidden')" class="btn-ghost btn-sm">Edit</button>
<form hx-delete="/leads/%d" hx-target="#lead-%d" hx-swap="outerHTML" style="display:inline">
<button class="btn-danger btn-sm" onclick="return confirm('Delete?')">Delete</button>
</form>
</div>
</td>
</tr>`,
rowClass, l.LeadID,
htmlEscape(l.PhoneNormalized),
htmlEscape(l.Name),
map[bool]string{true: `<span class="ml-1.5 pill pill-rose text-[9px]">review</span>`, false: ""}[l.NeedsReview],
htmlEscape(l.ServiceInterest),
statusPill,
htmlEscape(l.PaymentStatus),
arrived,
lastContact,
l.LeadID,
l.LeadID, l.LeadID,
)
}
fmt.Fprint(buf, templates.TableEnd())
fmt.Fprintf(buf, `</div></div>`)
// Edit rows
for _, l := range leads {
fmt.Fprintf(buf, `
<div id="edit-%d" class="hidden mt-4 animate-slide-up">
<div class="card-industrial p-5 border-amber-400/10">
<h3 class="text-sm font-semibold text-zinc-200 mb-3">Edit Lead #%d</h3>
<form hx-put="/leads/%d/review" hx-target="#lead-%d" hx-swap="outerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-3">
<input type="text" name="name" value="%s" class="input-industrial text-xs" placeholder="Name">
<select name="service_interest" class="input-industrial text-xs">%s</select>
<select name="status" class="input-industrial text-xs">%s</select>
<div class="flex items-end gap-2">
<button type="submit" class="btn-primary btn-sm">Save</button>
<button type="button" onclick="document.getElementById('edit-%d').classList.add('hidden')" class="btn-ghost btn-sm">Cancel</button>
</div>
</form>
</div>
</div>`, l.LeadID, l.LeadID, l.LeadID, l.LeadID, htmlEscape(l.Name), buildServiceOptions(services, l.ServiceInterest), buildStatusOptions(statuses, l.Status), l.LeadID)
}
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "All Leads", "leads")
}
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.
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 {
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
}
}
return []string{
"Não especificou",
"Head Spa",
"Massagem completa",
"Drenagem linfatica",
"Hydra Boost",
"Design Henna",
"Masculino",
}
}
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)
}
+360
View File
@@ -0,0 +1,360 @@
package handlers
import (
"context"
"encoding/json"
"fmt"
"log"
"net/http"
"strconv"
"strings"
"time"
"go-crm/internal/db"
"go-crm/internal/templates"
"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 (cu.name LIKE ? OR cu.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)
}
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader("Leads", "Search and manage customer leads"))
// Search
fmt.Fprintf(buf, `
<div class="card-industrial p-4 mb-6 animate-slide-up">
<form hx-get="/leads" hx-target="#leadList" hx-swap="innerHTML" class="flex gap-3">
<input type="text" name="search" placeholder="Search by name or phone..." value="%s" class="input-industrial max-w-md">
<button type="submit" class="btn-primary">Search</button>
</form>
</div>`, htmlEscape(search))
if len(customers) == 0 {
fmt.Fprint(buf, templates.EmptyState(`<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M17 20h5v-2a3 3 0 00-5.356-1.857M17 20H7m10 0v-2c0-.656-.126-1.283-.356-1.857M7 20H2v-2a3 3 0 015.356-1.857M7 20v-2c0-.656.126-1.283.356-1.857m0 0a5.002 5.002 0 019.288 0M15 7a3 3 0 11-6 0 3 3 0 016 0z"/>`, "No leads found. Try a different search or connect WhatsApp to capture leads."))
} else {
fmt.Fprintf(buf, `<div class="card-industrial overflow-hidden animate-slide-up stagger-1"><div class="overflow-x-auto">`)
fmt.Fprint(buf, templates.TableStart([]string{"Name", "Phone", "Birth Date", "Instagram", "WhatsApp", "Actions"}))
for _, c := range customers {
waStatus := `<span class="text-zinc-600 text-xs">—</span>`
if c.WhatsAppConnected == 1 && c.WhatsAppNumber != "" {
waStatus = fmt.Sprintf(`<span class="flex items-center gap-1.5"><span class="w-1.5 h-1.5 rounded-full bg-emerald-400"></span><span class="font-mono text-xs">%s</span></span>`, htmlEscape(c.WhatsAppNumber))
}
fmt.Fprintf(buf, `<tr>
<td class="font-medium text-zinc-200">%s</td>
<td class="font-mono text-xs">%s</td>
<td class="text-xs text-zinc-400">%s</td>
<td class="text-xs text-zinc-400">%s</td>
<td>%s</td>
<td>
<div class="flex items-center gap-2">
<button type="button" onclick="document.getElementById('editLead%d').classList.toggle('hidden')" class="btn-ghost btn-sm">Edit</button>
<form hx-delete="/leads/%d" hx-target="closest tr" hx-swap="outerHTML" style="display:inline">
<button type="submit" class="btn-danger btn-sm" onclick="return confirm('Delete?')">Delete</button>
</form>
</div>
</td>
</tr>`, htmlEscape(c.Name), htmlEscape(c.Phone), htmlEscape(c.BirthDate), htmlEscape(c.Instagram), waStatus, c.CustomerID, c.CustomerID)
}
fmt.Fprint(buf, templates.TableEnd())
fmt.Fprintf(buf, `</div></div>`)
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Leads", "leads")
}
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(""))
}
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
}
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader("Connect WhatsApp", fmt.Sprintf("Scan QR code to link %s", htmlEscape(client.Name))))
fmt.Fprintf(buf, `
<div class="max-w-lg mx-auto animate-slide-up">
<div class="card-industrial p-8 text-center">
<div id="qrcode" class="flex justify-center mb-6 min-h-[256px] items-center">
<div class="spinner"></div>
</div>
<p id="status" class="text-sm text-zinc-400 font-mono">Loading QR code...</p>
</div>
</div>
<script src="https://cdnjs.cloudflare.com/ajax/libs/qrcodejs/1.0.0/qrcode.min.js"></script>
<script>
var lastQR = '';
function pollQR() {
fetch('/leads/qr?client_id=%d')
.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 = '<div class="w-16 h-16 rounded-full bg-emerald-400/10 flex items-center justify-center mx-auto"><svg class="w-8 h-8 text-emerald-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/></svg></div>';
setTimeout(() => {
fetch('/leads/verify/%d')
.then(r => r.json())
.then(v => {
var msg = 'WhatsApp: ' + (v.wa_phone || 'unknown');
if (v.match === 'yes') {
document.getElementById('status').innerHTML = msg + ' matches client phone &mdash; <span class="text-emerald-400">verified</span>';
} else if (v.match === 'no') {
document.getElementById('status').innerHTML = msg + ' does NOT match client phone &mdash; <span class="text-rose-400">mismatch</span>';
} else {
document.getElementById('status').textContent = msg + ' (client phone unknown)';
}
})
.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>`, client.ClientID, client.ClientID)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Connect WhatsApp", "leads")
}
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 := cleanPhone(client.WhatsAppNumber)
cleanClient := cleanPhone(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) + `"}`))
}
func cleanPhone(s string) string {
s = strings.TrimPrefix(s, "+")
s = strings.TrimPrefix(s, "55")
return s
}
// --- 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)
}
}
+279
View File
@@ -0,0 +1,279 @@
package handlers
import (
"fmt"
"net/http"
"strconv"
"time"
"go-crm/internal/db"
"go-crm/internal/templates"
"github.com/go-chi/chi/v5"
)
func (a *App) ListPayments(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
clientID, _ := strconv.ParseInt(r.URL.Query().Get("client_id"), 10, 64)
if limit == 0 {
limit = 20
}
payments, err := db.ListPayments(a.DB, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
customers, err := db.ListCustomers(a.DB, accountID, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
var clientOptions, customerOptions string
clientNames := make(map[int64]string)
customerNames := make(map[int64]string)
for _, c := range clients {
clientOptions += fmt.Sprintf(`<option value="%d">%s</option>`, c.ClientID, htmlEscape(c.Name))
clientNames[c.ClientID] = c.Name
}
for _, cu := range customers {
customerOptions += fmt.Sprintf(`<option value="%d">%s</option>`, cu.CustomerID, htmlEscape(cu.Name))
customerNames[cu.CustomerID] = cu.Name
}
buf := templates.BufRender()
actions := `<button type="button" onclick="document.getElementById('paymentForm').classList.toggle('hidden')" class="btn-primary"><svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/></svg> Add Payment</button>`
fmt.Fprint(buf, templates.PageHeader("Payments", "Track revenue and transactions", actions))
fmt.Fprintf(buf, `
<div id="paymentForm" class="hidden mb-6 animate-slide-up">
<div class="card-industrial p-5">
<h3 class="text-sm font-semibold text-zinc-200 mb-4">New Payment</h3>
<form hx-post="/payments" hx-target="#paymentList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
<select name="client_id" required class="input-industrial"><option value="">Select Client</option>%s</select>
<select name="customer_id" required class="input-industrial"><option value="">Select Customer</option>%s</select>
<input type="number" name="amount" placeholder="Amount" step="0.01" class="input-industrial">
<input type="date" name="payment_date" class="input-industrial">
<select name="payment_method" class="input-industrial"><option value="">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>
<label class="flex items-center gap-2 text-sm text-zinc-400 cursor-pointer select-none">
<input type="checkbox" name="has_paid" class="w-4 h-4 rounded border-zinc-600 bg-zinc-800 text-amber-400 focus:ring-amber-400/20">
<span>Paid</span>
</label>
<div class="flex items-end"><button type="submit" class="btn-primary">Save</button></div>
</form>
</div>
</div>`, clientOptions, customerOptions)
if len(payments) == 0 {
fmt.Fprint(buf, templates.EmptyState(`<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M12 8c-1.657 0-3 .895-3 2s1.343 2 3 2 3-.895 3-2-1.343-2-3-2zm0 0v1m0 0v1m0-1h1m-1 0H9m12 0a2 2 0 012 2v4.5a2.5 2.5 0 01-2.5 2.5h-15a2.5 2.5 0 01-2.5-2.5V10a2 2 0 012-2h15z"/>`, "No payments recorded yet."))
} else {
fmt.Fprintf(buf, `<div class="card-industrial overflow-hidden animate-slide-up stagger-1"><div class="overflow-x-auto">`)
fmt.Fprint(buf, templates.TableStart([]string{"Client", "Customer", "Amount", "Paid", "Date", "Method", "Actions"}))
for _, p := range payments {
paidPill := `<span class="pill pill-rose">unpaid</span>`
if p.HasPaid {
paidPill = `<span class="pill pill-emerald">paid</span>`
}
clientName := clientNames[p.ClientID]
if clientName == "" {
clientName = strconv.FormatInt(p.ClientID, 10)
}
customerName := customerNames[p.CustomerID]
if customerName == "" {
customerName = strconv.FormatInt(p.CustomerID, 10)
}
fmt.Fprintf(buf, `<tr>
<td class="text-zinc-300 text-sm">%s</td>
<td class="text-zinc-300 text-sm">%s</td>
<td class="font-mono text-sm text-emerald-400">R$ %.2f</td>
<td>%s</td>
<td class="font-mono text-xs text-zinc-400">%s</td>
<td class="text-xs text-zinc-400">%s</td>
<td>
<div class="flex items-center gap-2">
<a href="/payments/%d" class="btn-ghost btn-sm">View</a>
<button type="button" onclick="document.getElementById('editPay%d').classList.toggle('hidden')" class="btn-ghost btn-sm">Edit</button>
<form hx-delete="/payments/%d" hx-target="closest tr" hx-swap="outerHTML" style="display:inline">
<button type="submit" class="btn-danger btn-sm" onclick="return confirm('Delete?')">Delete</button>
</form>
</div>
</td>
</tr>`, htmlEscape(clientName), htmlEscape(customerName), p.Amount, paidPill, htmlEscape(p.PaymentDate), htmlEscape(p.PaymentMethod), p.PaymentID, p.PaymentID, p.PaymentID)
}
fmt.Fprint(buf, templates.TableEnd())
fmt.Fprintf(buf, `</div></div>`)
for _, p := range payments {
clientName := clientNames[p.ClientID]
customerName := customerNames[p.CustomerID]
fmt.Fprintf(buf, `
<div id="editPay%d" class="hidden mt-4 animate-slide-up">
<div class="card-industrial p-5 border-amber-400/10">
<h3 class="text-sm font-semibold text-zinc-200 mb-3">Edit Payment #%d</h3>
<form hx-put="/payments/%d" hx-target="#paymentList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-3">
<select name="client_id" class="input-industrial text-xs"><option value="%d">%s</option>%s</select>
<select name="customer_id" class="input-industrial text-xs"><option value="%d">%s</option>%s</select>
<input type="number" name="amount" value="%.2f" step="0.01" class="input-industrial text-xs">
<input type="date" name="payment_date" value="%s" class="input-industrial text-xs">
<select name="payment_method" class="input-industrial text-xs"><option value="%s">%s</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>
<label class="flex items-center gap-2 text-xs text-zinc-400 cursor-pointer select-none">
<input type="checkbox" name="has_paid" class="w-4 h-4 rounded border-zinc-600 bg-zinc-800 text-amber-400">
<span>Paid</span>
</label>
<div class="flex items-end gap-2">
<button type="submit" class="btn-primary btn-sm">Save</button>
<button type="button" onclick="document.getElementById('editPay%d').classList.add('hidden')" class="btn-ghost btn-sm">Cancel</button>
</div>
</form>
</div>
</div>`, p.PaymentID, p.PaymentID, p.PaymentID, p.ClientID, htmlEscape(clientName), clientOptions, p.CustomerID, htmlEscape(customerName), customerOptions, p.Amount, htmlEscape(p.PaymentDate), p.PaymentMethod, p.PaymentMethod, p.PaymentID)
}
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Payments", "payments")
}
func (a *App) CreatePayment(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
scheduleID, _ := strconv.ParseInt(r.FormValue("schedule_id"), 10, 64)
amount, _ := strconv.ParseFloat(r.FormValue("amount"), 64)
hasPaid := r.FormValue("has_paid") == "on"
payment := db.Payment{
ClientID: clientID,
CustomerID: customerID,
ScheduleID: scheduleID,
HasPaid: hasPaid,
Amount: amount,
PaymentDate: r.FormValue("payment_date"),
PaymentMethod: r.FormValue("payment_method"),
CreatedAt: time.Now().Unix(),
}
if err := payment.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) ViewPayment(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
var p db.Payment
var hasPaid int
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 {
http.Error(w, "Payment not found", http.StatusNotFound)
return
}
p.HasPaid = hasPaid == 1
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader("Payment", "Transaction details"))
paidPill := `<span class="pill pill-rose">unpaid</span>`
if p.HasPaid {
paidPill = `<span class="pill pill-emerald">paid</span>`
}
fmt.Fprintf(buf, `
<div class="max-w-lg animate-slide-up">
<div class="card-industrial p-6">
<div class="flex items-center gap-2 mb-6">%s</div>
<div class="space-y-3">
<div class="flex justify-between py-3 border-b border-white/[0.04]">
<span class="text-xs font-mono uppercase text-zinc-500">Amount</span>
<span class="text-lg font-mono font-semibold text-emerald-400">R$ %.2f</span>
</div>
<div class="flex justify-between py-3 border-b border-white/[0.04]">
<span class="text-xs font-mono uppercase text-zinc-500">Method</span>
<span class="text-sm text-zinc-300">%s</span>
</div>
<div class="flex justify-between py-3">
<span class="text-xs font-mono uppercase text-zinc-500">Date</span>
<span class="text-sm font-mono text-zinc-300">%s</span>
</div>
</div>
<div class="mt-6">
<a href="/payments" class="btn-ghost btn-sm">Back</a>
</div>
</div>
</div>`, paidPill, p.Amount, htmlEscape(p.PaymentMethod), htmlEscape(p.PaymentDate))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Payment", "payments")
}
func (a *App) UpdatePayment(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
amount, _ := strconv.ParseFloat(r.FormValue("amount"), 64)
hasPaid := r.FormValue("has_paid") == "on"
_, 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 {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) DeletePayment(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
a.DB.Exec("DELETE FROM payments WHERE payment_id = ?", id)
}
// --- package-level shims ---
func ListPayments(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListPayments(w, r)
}
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)
}
+483
View File
@@ -0,0 +1,483 @@
package handlers
import (
"fmt"
"net/http"
"strconv"
"time"
"go-crm/internal/db"
"go-crm/internal/templates"
"github.com/go-chi/chi/v5"
)
func (a *App) ListQuestions(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
clientID, _ := strconv.ParseInt(r.URL.Query().Get("client_id"), 10, 64)
if limit == 0 {
limit = 20
}
questions, err := db.ListQuestions(a.DB, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
customers, err := db.ListCustomers(a.DB, accountID, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
var clientOptions, customerOptions string
clientNames := make(map[int64]string)
customerNames := make(map[int64]string)
for _, c := range clients {
clientOptions += fmt.Sprintf(`<option value="%d">%s</option>`, c.ClientID, htmlEscape(c.Name))
clientNames[c.ClientID] = c.Name
}
for _, cu := range customers {
customerOptions += fmt.Sprintf(`<option value="%d">%s</option>`, cu.CustomerID, htmlEscape(cu.Name))
customerNames[cu.CustomerID] = cu.Name
}
buf := templates.BufRender()
actions := `<button type="button" onclick="document.getElementById('questionForm').classList.toggle('hidden')" class="btn-primary"><svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/></svg> Add Question</button>`
fmt.Fprint(buf, templates.PageHeader("Questions", "Customer inquiries and Q&A", actions))
fmt.Fprintf(buf, `
<div id="questionForm" class="hidden mb-6 animate-slide-up">
<div class="card-industrial p-5">
<h3 class="text-sm font-semibold text-zinc-200 mb-4">New Question</h3>
<form hx-post="/questions" hx-target="#questionList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
<select name="client_id" required class="input-industrial"><option value="">Select Client</option>%s</select>
<select name="customer_id" required class="input-industrial"><option value="">Select Customer</option>%s</select>
<textarea name="question" placeholder="Question text" required class="input-industrial sm:col-span-2" rows="2"></textarea>
<select name="status" class="input-industrial"><option value="pending">Pending</option><option value="answered">Answered</option></select>
<div class="flex items-end"><button type="submit" class="btn-primary">Save</button></div>
</form>
</div>
</div>`, clientOptions, customerOptions)
if len(questions) == 0 {
fmt.Fprint(buf, templates.EmptyState(`<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M8.228 9c.549-1.165 2.03-2 3.772-2 2.21 0 4 1.343 4 3 0 1.4-1.278 2.575-3.006 2.907-.542.104-.994.54-.994 1.093m0 3h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"/>`, "No questions recorded yet."))
} else {
fmt.Fprintf(buf, `<div class="card-industrial overflow-hidden animate-slide-up stagger-1"><div class="overflow-x-auto">`)
fmt.Fprint(buf, templates.TableStart([]string{"Client", "Customer", "Question", "Status", "Actions"}))
for _, q := range questions {
clientName := clientNames[q.ClientID]
if clientName == "" {
clientName = strconv.FormatInt(q.ClientID, 10)
}
customerName := customerNames[q.CustomerID]
if customerName == "" {
customerName = strconv.FormatInt(q.CustomerID, 10)
}
statusPill := `<span class="pill pill-amber">pending</span>`
if q.Status == "answered" {
statusPill = `<span class="pill pill-emerald">answered</span>`
}
fmt.Fprintf(buf, `<tr>
<td class="text-zinc-300 text-sm">%s</td>
<td class="text-zinc-300 text-sm">%s</td>
<td class="text-zinc-400 text-xs max-w-xs truncate">%s</td>
<td>%s</td>
<td>
<div class="flex items-center gap-2">
<a href="/questions/%d" class="btn-ghost btn-sm">View</a>
<button type="button" onclick="document.getElementById('editQ%d').classList.toggle('hidden')" class="btn-ghost btn-sm">Edit</button>
<form hx-delete="/questions/%d" hx-target="closest tr" hx-swap="outerHTML" style="display:inline">
<button type="submit" class="btn-danger btn-sm" onclick="return confirm('Delete?')">Delete</button>
</form>
</div>
</td>
</tr>`, htmlEscape(clientName), htmlEscape(customerName), htmlEscape(q.Question), statusPill, q.QuestionID, q.QuestionID, q.QuestionID)
}
fmt.Fprint(buf, templates.TableEnd())
fmt.Fprintf(buf, `</div></div>`)
for _, q := range questions {
clientName := clientNames[q.ClientID]
customerName := customerNames[q.CustomerID]
fmt.Fprintf(buf, `
<div id="editQ%d" class="hidden mt-4 animate-slide-up">
<div class="card-industrial p-5 border-amber-400/10">
<h3 class="text-sm font-semibold text-zinc-200 mb-3">Edit Question #%d</h3>
<form hx-put="/questions/%d" hx-target="#questionList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-3">
<select name="client_id" class="input-industrial text-xs"><option value="%d">%s</option>%s</select>
<select name="customer_id" class="input-industrial text-xs"><option value="%d">%s</option>%s</select>
<textarea name="question" class="input-industrial text-xs sm:col-span-2" rows="2">%s</textarea>
<select name="status" class="input-industrial text-xs"><option value="%s">%s</option><option value="pending">Pending</option><option value="answered">Answered</option></select>
<div class="flex items-end gap-2">
<button type="submit" class="btn-primary btn-sm">Save</button>
<button type="button" onclick="document.getElementById('editQ%d').classList.add('hidden')" class="btn-ghost btn-sm">Cancel</button>
</div>
</form>
</div>
</div>`, q.QuestionID, q.QuestionID, q.QuestionID, q.ClientID, htmlEscape(clientName), clientOptions, q.CustomerID, htmlEscape(customerName), customerOptions, htmlEscape(q.Question), q.Status, q.Status, q.QuestionID)
}
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Questions", "questions")
}
func (a *App) CreateQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
question := db.Question{
ClientID: clientID,
CustomerID: customerID,
Question: r.FormValue("question"),
Timestamp: time.Now().Unix(),
Status: r.FormValue("status"),
CreatedAt: time.Now().Unix(),
}
if err := question.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) ViewQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
var q db.Question
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 {
http.Error(w, "Question not found", http.StatusNotFound)
return
}
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader("Question", "Inquiry details"))
statusPill := `<span class="pill pill-amber">pending</span>`
if q.Status == "answered" {
statusPill = `<span class="pill pill-emerald">answered</span>`
}
fmt.Fprintf(buf, `
<div class="max-w-lg animate-slide-up">
<div class="card-industrial p-6">
<div class="flex items-center gap-2 mb-4">%s</div>
<div class="text-sm text-zinc-200 leading-relaxed mb-6">%s</div>
<div class="space-y-2 text-xs text-zinc-500 font-mono">
<div>Client ID: %d</div>
<div>Customer ID: %d</div>
</div>
<div class="mt-6">
<a href="/questions" class="btn-ghost btn-sm">Back</a>
</div>
</div>
</div>`, statusPill, htmlEscape(q.Question), q.ClientID, q.CustomerID)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Question", "questions")
}
func (a *App) UpdateQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
_, 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 {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) DeleteQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
a.DB.Exec("DELETE FROM questions WHERE question_id = ?", id)
}
// --- Answers (in same file as original) ---
func (a *App) ListAnswers(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
questionID, _ := strconv.ParseInt(r.URL.Query().Get("question_id"), 10, 64)
if limit == 0 {
limit = 20
}
answers, err := db.ListAnswersWithDetails(a.DB, accountID, questionID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
questions, err := db.ListQuestions(a.DB, 0, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
var questionOptions string
questionText := make(map[int64]string)
for _, q := range questions {
questionOptions += fmt.Sprintf(`<option value="%d">%s</option>`, q.QuestionID, htmlEscape(q.Question))
questionText[q.QuestionID] = q.Question
}
buf := templates.BufRender()
actions := `<button type="button" onclick="document.getElementById('answerForm').classList.toggle('hidden')" class="btn-primary"><svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/></svg> Add Answer</button>`
fmt.Fprint(buf, templates.PageHeader("Answers", "Responses to customer questions", actions))
fmt.Fprintf(buf, `
<div id="answerForm" class="hidden mb-6 animate-slide-up">
<div class="card-industrial p-5">
<h3 class="text-sm font-semibold text-zinc-200 mb-4">New Answer</h3>
<form hx-post="/answers" hx-target="#answerList" hx-swap="innerHTML" class="grid grid-cols-1 gap-4">
<select name="question_id" required class="input-industrial max-w-md"><option value="">Select Question</option>%s</select>
<textarea name="answer" placeholder="Answer text" required class="input-industrial" rows="3"></textarea>
<div><button type="submit" class="btn-primary">Save</button></div>
</form>
</div>
</div>`, questionOptions)
if len(answers) == 0 {
fmt.Fprint(buf, templates.EmptyState(`<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M7 8h10M7 12h4m1 8l-4-4H5a2 2 0 01-2-2V6a2 2 0 012-2h14a2 2 0 012 2v8a2 2 0 01-2 2h-3l-4 4z"/>`, "No answers recorded yet."))
} else {
fmt.Fprintf(buf, `<div class="card-industrial overflow-hidden animate-slide-up stagger-1"><div class="overflow-x-auto">`)
fmt.Fprint(buf, templates.TableStart([]string{"Client", "Customer", "Question", "Answer", "Actions"}))
for _, a2 := range answers {
qText := a2.QuestionText
if qText == "" {
qText = questionText[a2.QuestionID]
if qText == "" {
qText = strconv.FormatInt(a2.QuestionID, 10)
}
}
clientName := a2.ClientName
if clientName == "" {
clientName = strconv.FormatInt(a2.ClientID, 10)
}
customerName := a2.CustomerName
if customerName == "" {
customerName = "Unknown"
}
fmt.Fprintf(buf, `<tr>
<td class="text-zinc-300 text-sm">%s</td>
<td class="text-zinc-300 text-sm">%s</td>
<td class="text-zinc-400 text-xs max-w-[200px] truncate">%s</td>
<td class="text-zinc-400 text-xs max-w-[300px] truncate">%s</td>
<td>
<div class="flex items-center gap-2">
<a href="/answers/%d" class="btn-ghost btn-sm">View</a>
<button type="button" onclick="document.getElementById('editA%d').classList.toggle('hidden')" class="btn-ghost btn-sm">Edit</button>
<form hx-delete="/answers/%d" hx-target="closest tr" hx-swap="outerHTML" style="display:inline">
<button type="submit" class="btn-danger btn-sm" onclick="return confirm('Delete?')">Delete</button>
</form>
</div>
</td>
</tr>`, htmlEscape(clientName), htmlEscape(customerName), htmlEscape(qText), htmlEscape(a2.Answer), a2.AnswerID, a2.AnswerID, a2.AnswerID)
}
fmt.Fprint(buf, templates.TableEnd())
fmt.Fprintf(buf, `</div></div>`)
for _, a2 := range answers {
qText := a2.QuestionText
if qText == "" {
qText = questionText[a2.QuestionID]
if qText == "" {
qText = strconv.FormatInt(a2.QuestionID, 10)
}
}
fmt.Fprintf(buf, `
<div id="editA%d" class="hidden mt-4 animate-slide-up">
<div class="card-industrial p-5 border-amber-400/10">
<h3 class="text-sm font-semibold text-zinc-200 mb-3">Edit Answer #%d</h3>
<form hx-put="/answers/%d" hx-target="#answerList" hx-swap="innerHTML" class="grid grid-cols-1 gap-3">
<select name="question_id" class="input-industrial text-xs max-w-md"><option value="%d">%s</option>%s</select>
<textarea name="answer" class="input-industrial text-xs" rows="3">%s</textarea>
<div class="flex items-end gap-2">
<button type="submit" class="btn-primary btn-sm">Save</button>
<button type="button" onclick="document.getElementById('editA%d').classList.add('hidden')" class="btn-ghost btn-sm">Cancel</button>
</div>
</form>
</div>
</div>`, a2.AnswerID, a2.AnswerID, a2.AnswerID, a2.QuestionID, htmlEscape(qText), questionOptions, htmlEscape(a2.Answer), a2.AnswerID)
}
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Answers", "answers")
}
func (a *App) CreateAnswer(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
r.ParseForm()
questionID, _ := strconv.ParseInt(r.FormValue("question_id"), 10, 64)
var clientID int64
err := a.DB.QueryRow("SELECT client_id FROM questions WHERE question_id = ?", questionID).Scan(&clientID)
if err != nil {
http.Error(w, "Question not found", http.StatusBadRequest)
return
}
var checkID int64
err = a.DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID)
if err != nil {
http.Error(w, "Invalid question", http.StatusBadRequest)
return
}
answer := db.Answer{
ClientID: clientID,
QuestionID: questionID,
Answer: r.FormValue("answer"),
Timestamp: time.Now().Unix(),
Status: "active",
CreatedAt: time.Now().Unix(),
}
if err := answer.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) ViewAnswer(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
var ans db.Answer
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 {
http.Error(w, "Answer not found", http.StatusNotFound)
return
}
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader("Answer", "Response details"))
fmt.Fprintf(buf, `
<div class="max-w-lg animate-slide-up">
<div class="card-industrial p-6">
<div class="text-sm text-zinc-200 leading-relaxed mb-6">%s</div>
<div class="space-y-2 text-xs text-zinc-500 font-mono">
<div>Question ID: %d</div>
<div>Client ID: %d</div>
</div>
<div class="mt-6">
<a href="/answers" class="btn-ghost btn-sm">Back</a>
</div>
</div>
</div>`, htmlEscape(ans.Answer), ans.QuestionID, ans.ClientID)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Answer", "answers")
}
func (a *App) UpdateAnswer(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm()
questionID, _ := strconv.ParseInt(r.FormValue("question_id"), 10, 64)
_, err := a.DB.Exec("UPDATE answers SET question_id=?, answer=? WHERE answer_id=?", questionID, r.FormValue("answer"), id)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) DeleteAnswer(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
a.DB.Exec("DELETE FROM answers WHERE answer_id = ?", id)
}
// --- package-level shims ---
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"
"html/template"
"math"
"net/http"
"time"
"go-crm/internal/templates"
)
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
}
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)
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader("Monthly Report", fmt.Sprintf("Performance for %s", rd.MonthLabel)))
// Overview KPIs
fmt.Fprintf(buf, `<div class="grid grid-cols-1 sm:grid-cols-3 gap-4 mb-6">`)
fmt.Fprint(buf, templates.KPICard("Total Leads", fmt.Sprintf("%d", rd.TotalLeads), "", "amber", `<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M17 20h5v-2a3 3 0 00-5.356-1.857M17 20H7m10 0v-2c0-.656-.126-1.283-.356-1.857M7 20H2v-2a3 3 0 015.356-1.857M7 20v-2c0-.656.126-1.283.356-1.857m0 0a5.002 5.002 0 019.288 0M15 7a3 3 0 11-6 0 3 3 0 016 0z"/>`, 1))
fmt.Fprint(buf, templates.KPICard("Scheduled", fmt.Sprintf("%d", rd.TotalScheduled), fmt.Sprintf("%.1f%% conversion", rd.ConversionRate), "emerald", `<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z"/>`, 2))
fmt.Fprint(buf, templates.KPICard("Revenue", fmt.Sprintf("R$ %.2f", rd.TotalRevenue), fmt.Sprintf("%d sales", rd.TotalSales), "sky", `<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8c-1.657 0-3 .895-3 2s1.343 2 3 2 3-.895 3-2-1.343-2-3-2zm0 0v1m0 0v1m0-1h1m-1 0H9m12 0a2 2 0 012 2v4.5a2.5 2.5 0 01-2.5 2.5h-15a2.5 2.5 0 01-2.5-2.5V10a2 2 0 012-2h15z"/>`, 3))
fmt.Fprintf(buf, `</div>`)
// Revenue details
fmt.Fprintf(buf, `<div class="grid grid-cols-1 sm:grid-cols-3 gap-3 mb-6">`)
miniCards := []struct{ label, value string }{
{"Total Sales", fmt.Sprintf("%d", rd.TotalSales)},
{"Average Ticket", fmt.Sprintf("R$ %.2f", rd.AverageTicket)},
{"Pending Review", fmt.Sprintf("%d", reviewCount)},
}
for _, mc := range miniCards {
fmt.Fprintf(buf, `
<div class="bg-zinc-900 border border-white/[0.06] rounded-lg p-3 animate-slide-up">
<div class="text-[10px] font-mono uppercase tracking-wider text-zinc-500 mb-1">%s</div>
<div class="text-lg font-mono font-semibold text-zinc-200">%s</div>
</div>`, mc.label, mc.value)
}
fmt.Fprintf(buf, `</div>`)
// Tables
fmt.Fprintf(buf, `<div class="grid grid-cols-1 lg:grid-cols-2 gap-6">`)
// Service interest table
serviceTable := renderServiceTable(rd.ServiceCounts, rd.TotalLeads)
fmt.Fprint(buf, templates.SectionCard("Leads by Service Interest", "Distribution of service requests", template.HTML(serviceTable)))
// Status table
statusTable := renderServiceTable(rd.StatusCounts, rd.TotalLeads)
fmt.Fprint(buf, templates.SectionCard("Leads by Status", "Pipeline breakdown", template.HTML(statusTable)))
fmt.Fprintf(buf, `</div>`)
// Top services
if len(rd.TopServices) > 0 {
topTable := renderTopServicesTable(rd.TopServices)
fmt.Fprintf(buf, `<div class="mt-6">%s</div>`, templates.SectionCard("Top 5 Services Sold", "Best performing services this month", template.HTML(topTable)))
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Monthly Report", "report")
}
func renderServiceTable(counts []serviceCount, total int) template.HTML {
if len(counts) == 0 {
return template.HTML(`<p class="text-sm text-zinc-500 py-4">No data for this month.</p>`)
}
out := string(templates.TableStart([]string{"Name", "Quantity", "Percentage"}))
for _, sc := range counts {
pct := 0.0
if total > 0 {
pct = math.Round(float64(sc.Count)/float64(total)*100*10) / 10
}
barWidth := int(pct)
if barWidth > 100 {
barWidth = 100
}
out += fmt.Sprintf(`<tr>
<td class="text-zinc-200">%s</td>
<td class="font-mono text-xs">%d</td>
<td>
<div class="flex items-center gap-2">
<div class="flex-1 h-1.5 bg-zinc-800 rounded-full overflow-hidden max-w-[120px]">
<div class="h-full bg-amber-400 rounded-full" style="width:%d%%"></div>
</div>
<span class="text-xs text-zinc-400 font-mono">%.1f%%</span>
</div>
</td>
</tr>`, htmlEscape(sc.Name), sc.Count, barWidth, pct)
}
out += string(templates.TableEnd())
return template.HTML(out)
}
func renderTopServicesTable(counts []serviceCount) template.HTML {
if len(counts) == 0 {
return template.HTML(`<p class="text-sm text-zinc-500 py-4">No sales data for this month.</p>`)
}
out := string(templates.TableStart([]string{"Service", "Sales"}))
for _, sc := range counts {
out += fmt.Sprintf(`<tr><td class="text-zinc-200">%s</td><td class="font-mono text-xs text-emerald-400">%d</td></tr>`, htmlEscape(sc.Name), sc.Count)
}
out += string(templates.TableEnd())
return template.HTML(out)
}
// MonthlyReport is the package-level shim.
func MonthlyReport(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).MonthlyReport(w, r)
}
+288
View File
@@ -0,0 +1,288 @@
package handlers
import (
"fmt"
"net/http"
"strconv"
"time"
"go-crm/internal/db"
"go-crm/internal/templates"
"github.com/go-chi/chi/v5"
)
func (a *App) ListSchedules(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
clientID, _ := strconv.ParseInt(r.URL.Query().Get("client_id"), 10, 64)
customerID, _ := strconv.ParseInt(r.URL.Query().Get("customer_id"), 10, 64)
if limit == 0 {
limit = 20
}
schedules, err := db.ListSchedules(a.DB, clientID, customerID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
customers, err := db.ListCustomers(a.DB, accountID, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
services, err := db.ListServices(a.DB, accountID, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
var clientOptions, customerOptions, serviceOptions string
clientNames := make(map[int64]string)
customerNames := make(map[int64]string)
serviceNames := make(map[int64]string)
for _, c := range clients {
clientOptions += fmt.Sprintf(`<option value="%d">%s</option>`, c.ClientID, htmlEscape(c.Name))
clientNames[c.ClientID] = c.Name
}
for _, cu := range customers {
customerOptions += fmt.Sprintf(`<option value="%d">%s</option>`, cu.CustomerID, htmlEscape(cu.Name))
customerNames[cu.CustomerID] = cu.Name
}
for _, s := range services {
serviceOptions += fmt.Sprintf(`<option value="%d">%s</option>`, s.ServiceID, htmlEscape(s.Name))
serviceNames[s.ServiceID] = s.Name
}
buf := templates.BufRender()
actions := `<button type="button" onclick="document.getElementById('scheduleForm').classList.toggle('hidden')" class="btn-primary"><svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/></svg> Add Schedule</button>`
fmt.Fprint(buf, templates.PageHeader("Scheduling", "Appointments and calendar", actions))
fmt.Fprintf(buf, `
<div id="scheduleForm" class="hidden mb-6 animate-slide-up">
<div class="card-industrial p-5">
<h3 class="text-sm font-semibold text-zinc-200 mb-4">New Appointment</h3>
<form hx-post="/scheduling" hx-target="#scheduleList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
<select name="client_id" required class="input-industrial"><option value="">Select Client</option>%s</select>
<select name="customer_id" required class="input-industrial"><option value="">Select Customer</option>%s</select>
<select name="service_id" required class="input-industrial"><option value="">Select Service</option>%s</select>
<input type="date" name="plan_date" class="input-industrial">
<input type="time" name="time" class="input-industrial">
<select name="status" class="input-industrial"><option value="pending">Pending</option><option value="confirmed">Confirmed</option><option value="cancelled">Cancelled</option></select>
<div class="flex items-end"><button type="submit" class="btn-primary">Save</button></div>
</form>
</div>
</div>`, clientOptions, customerOptions, serviceOptions)
if len(schedules) == 0 {
fmt.Fprint(buf, templates.EmptyState(`<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z"/>`, "No appointments scheduled yet."))
} else {
fmt.Fprintf(buf, `<div class="card-industrial overflow-hidden animate-slide-up stagger-1"><div class="overflow-x-auto">`)
fmt.Fprint(buf, templates.TableStart([]string{"Client", "Customer", "Service", "Date", "Time", "Status", "Actions"}))
for _, s := range schedules {
clientName := clientNames[s.ClientID]
if clientName == "" {
clientName = strconv.FormatInt(s.ClientID, 10)
}
customerName := customerNames[s.CustomerID]
if customerName == "" {
customerName = strconv.FormatInt(s.CustomerID, 10)
}
serviceName := serviceNames[s.ServiceID]
if serviceName == "" {
serviceName = strconv.FormatInt(s.ServiceID, 10)
}
statusPill := statusPillForSchedule(s.Status)
fmt.Fprintf(buf, `<tr>
<td class="text-zinc-300 text-sm">%s</td>
<td class="text-zinc-300 text-sm">%s</td>
<td class="text-zinc-400 text-xs">%s</td>
<td class="font-mono text-xs text-zinc-300">%s</td>
<td class="font-mono text-xs text-zinc-300">%s</td>
<td>%s</td>
<td>
<div class="flex items-center gap-2">
<a href="/scheduling/%d" class="btn-ghost btn-sm">View</a>
<button type="button" onclick="document.getElementById('editSched%d').classList.toggle('hidden')" class="btn-ghost btn-sm">Edit</button>
<form hx-delete="/scheduling/%d" hx-target="closest tr" hx-swap="outerHTML" style="display:inline">
<button type="submit" class="btn-danger btn-sm" onclick="return confirm('Delete?')">Delete</button>
</form>
</div>
</td>
</tr>`, htmlEscape(clientName), htmlEscape(customerName), htmlEscape(serviceName), htmlEscape(s.PlanDate), htmlEscape(s.Time), statusPill, s.ScheduleID, s.ScheduleID, s.ScheduleID)
}
fmt.Fprint(buf, templates.TableEnd())
fmt.Fprintf(buf, `</div></div>`)
for _, s := range schedules {
clientName := clientNames[s.ClientID]
customerName := customerNames[s.CustomerID]
serviceName := serviceNames[s.ServiceID]
fmt.Fprintf(buf, `
<div id="editSched%d" class="hidden mt-4 animate-slide-up">
<div class="card-industrial p-5 border-amber-400/10">
<h3 class="text-sm font-semibold text-zinc-200 mb-3">Edit Appointment #%d</h3>
<form hx-put="/scheduling/%d" hx-target="#scheduleList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-3">
<select name="client_id" class="input-industrial text-xs"><option value="%d">%s</option>%s</select>
<select name="customer_id" class="input-industrial text-xs"><option value="%d">%s</option>%s</select>
<select name="service_id" class="input-industrial text-xs"><option value="%d">%s</option>%s</select>
<input type="date" name="plan_date" value="%s" class="input-industrial text-xs">
<input type="time" name="time" value="%s" class="input-industrial text-xs">
<select name="status" class="input-industrial text-xs"><option value="%s">%s</option><option value="pending">Pending</option><option value="confirmed">Confirmed</option><option value="cancelled">Cancelled</option></select>
<div class="flex items-end gap-2">
<button type="submit" class="btn-primary btn-sm">Save</button>
<button type="button" onclick="document.getElementById('editSched%d').classList.add('hidden')" class="btn-ghost btn-sm">Cancel</button>
</div>
</form>
</div>
</div>`, s.ScheduleID, s.ScheduleID, s.ScheduleID, s.ClientID, htmlEscape(clientName), clientOptions, s.CustomerID, htmlEscape(customerName), customerOptions, s.ServiceID, htmlEscape(serviceName), serviceOptions, htmlEscape(s.PlanDate), htmlEscape(s.Time), s.Status, s.Status, s.ScheduleID)
}
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Scheduling", "scheduling")
}
func statusPillForSchedule(status string) string {
switch status {
case "confirmed":
return `<span class="pill pill-emerald">confirmed</span>`
case "cancelled":
return `<span class="pill pill-rose">cancelled</span>`
default:
return `<span class="pill pill-amber">pending</span>`
}
}
func (a *App) CreateSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
serviceID, _ := strconv.ParseInt(r.FormValue("service_id"), 10, 64)
schedule := db.Schedule{
ClientID: clientID,
CustomerID: customerID,
ServiceID: serviceID,
PlanDate: r.FormValue("plan_date"),
Time: r.FormValue("time"),
Status: r.FormValue("status"),
CreatedAt: time.Now().Unix(),
}
if err := schedule.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) ViewSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
var sch db.Schedule
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 {
http.Error(w, "Schedule not found", http.StatusNotFound)
return
}
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader("Appointment", "Schedule details"))
statusPill := statusPillForSchedule(sch.Status)
fmt.Fprintf(buf, `
<div class="max-w-lg animate-slide-up">
<div class="card-industrial p-6">
<div class="flex items-center gap-2 mb-6">%s</div>
<div class="space-y-3">
<div class="flex justify-between py-3 border-b border-white/[0.04]">
<span class="text-xs font-mono uppercase text-zinc-500">Date</span>
<span class="text-sm font-mono text-zinc-300">%s</span>
</div>
<div class="flex justify-between py-3 border-b border-white/[0.04]">
<span class="text-xs font-mono uppercase text-zinc-500">Time</span>
<span class="text-sm font-mono text-zinc-300">%s</span>
</div>
<div class="flex justify-between py-3">
<span class="text-xs font-mono uppercase text-zinc-500">Client / Customer / Service</span>
<span class="text-sm text-zinc-300 text-right font-mono">%d / %d / %d</span>
</div>
</div>
<div class="mt-6">
<a href="/scheduling" class="btn-ghost btn-sm">Back</a>
</div>
</div>
</div>`, statusPill, htmlEscape(sch.PlanDate), htmlEscape(sch.Time), sch.ClientID, sch.CustomerID, sch.ServiceID)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Appointment", "scheduling")
}
func (a *App) UpdateSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
serviceID, _ := strconv.ParseInt(r.FormValue("service_id"), 10, 64)
_, 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 {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) DeleteSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
a.DB.Exec("DELETE FROM scheduling WHERE schedule_id = ?", id)
}
// --- package-level shims ---
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)
}
+234
View File
@@ -0,0 +1,234 @@
package handlers
import (
"fmt"
"net/http"
"strconv"
"time"
"go-crm/internal/db"
"go-crm/internal/templates"
"github.com/go-chi/chi/v5"
)
func (a *App) ListServices(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
clientID, _ := strconv.ParseInt(r.URL.Query().Get("client_id"), 10, 64)
if limit == 0 {
limit = 20
}
services, err := db.ListServices(a.DB, accountID, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
var clientOptions string
for _, c := range clients {
clientOptions += fmt.Sprintf(`<option value="%d">%s</option>`, c.ClientID, htmlEscape(c.Name))
}
buf := templates.BufRender()
actions := `<button type="button" onclick="document.getElementById('serviceForm').classList.toggle('hidden')" class="btn-primary"><svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/></svg> Add Service</button>`
fmt.Fprint(buf, templates.PageHeader("Services", "Your service catalog and pricing", actions))
fmt.Fprintf(buf, `
<div id="serviceForm" class="hidden mb-6 animate-slide-up">
<div class="card-industrial p-5">
<h3 class="text-sm font-semibold text-zinc-200 mb-4">New Service</h3>
<form hx-post="/services" hx-target="#serviceList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
<input type="text" name="name" placeholder="Service Name" required class="input-industrial">
<input type="number" name="price" placeholder="Price" step="0.01" class="input-industrial">
<input type="text" name="duration" placeholder="Duration" class="input-industrial">
<select name="client_id" required class="input-industrial"><option value="">Select Client</option>%s</select>
<textarea name="description" placeholder="Description" class="input-industrial sm:col-span-2 lg:col-span-3" rows="2"></textarea>
<div class="flex items-end"><button type="submit" class="btn-primary">Save</button></div>
</form>
</div>
</div>`, clientOptions)
if len(services) == 0 {
fmt.Fprint(buf, templates.EmptyState(`<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M10.325 4.317c.426-1.756 2.924-1.756 3.35 0a1.724 1.724 0 002.573 1.066c1.543-.94 3.31.826 2.37 2.37a1.724 1.724 0 001.065 2.572c1.756.426 1.756 2.924 0 3.35a1.724 1.724 0 00-1.066 2.573c.94 1.543-.826 3.31-2.37 2.37a1.724 1.724 0 00-2.572 1.065c-.426 1.756-2.924 1.756-3.35 0a1.724 1.724 0 00-2.573-1.066c-1.543.94-3.31-.826-2.37-2.37a1.724 1.724 0 00-1.065-2.572c-1.756-.426-1.756-2.924 0-3.35a1.724 1.724 0 001.066-2.573c-.94-1.543.826-3.31 2.37-2.37 1.608.536 3.135-.493 3.35-2.572zM15 12a3 3 0 11-6 0 3 3 0 016 0z"/>`, "No services yet. Add your first service to the catalog."))
} else {
fmt.Fprintf(buf, `<div class="card-industrial overflow-hidden animate-slide-up stagger-1"><div class="overflow-x-auto">`)
fmt.Fprint(buf, templates.TableStart([]string{"Name", "Price", "Duration", "Actions"}))
for _, s := range services {
fmt.Fprintf(buf, `<tr>
<td class="font-medium text-zinc-200">%s</td>
<td class="font-mono text-sm text-emerald-400">R$ %.2f</td>
<td class="text-xs text-zinc-400">%s</td>
<td>
<div class="flex items-center gap-2">
<a href="/services/%d" class="btn-ghost btn-sm">View</a>
<button type="button" onclick="document.getElementById('editServ%d').classList.toggle('hidden')" class="btn-ghost btn-sm">Edit</button>
<form hx-delete="/services/%d" hx-target="closest tr" hx-swap="outerHTML" style="display:inline">
<button type="submit" class="btn-danger btn-sm" onclick="return confirm('Delete?')">Delete</button>
</form>
</div>
</td>
</tr>`, htmlEscape(s.Name), s.Price, htmlEscape(s.Duration), s.ServiceID, s.ServiceID, s.ServiceID)
}
fmt.Fprint(buf, templates.TableEnd())
fmt.Fprintf(buf, `</div></div>`)
for _, s := range services {
fmt.Fprintf(buf, `
<div id="editServ%d" class="hidden mt-4 animate-slide-up">
<div class="card-industrial p-5 border-amber-400/10">
<h3 class="text-sm font-semibold text-zinc-200 mb-3">Edit %s</h3>
<form hx-put="/services/%d" hx-target="#serviceList" hx-swap="innerHTML" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-3">
<input type="text" name="name" value="%s" class="input-industrial text-xs">
<input type="number" name="price" value="%.2f" step="0.01" class="input-industrial text-xs">
<input type="text" name="duration" value="%s" class="input-industrial text-xs">
<select name="client_id" class="input-industrial text-xs"><option value="%d">%s</option>%s</select>
<textarea name="description" class="input-industrial text-xs sm:col-span-2 lg:col-span-3" rows="2">%s</textarea>
<div class="flex items-end gap-2">
<button type="submit" class="btn-primary btn-sm">Save</button>
<button type="button" onclick="document.getElementById('editServ%d').classList.add('hidden')" class="btn-ghost btn-sm">Cancel</button>
</div>
</form>
</div>
</div>`, s.ServiceID, htmlEscape(s.Name), s.ServiceID, htmlEscape(s.Name), s.Price, htmlEscape(s.Duration), s.ClientID, htmlEscape(s.Name), clientOptions, htmlEscape(s.Description), s.ServiceID)
}
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, "Services", "services")
}
func (a *App) CreateService(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
var checkID int64
err := a.DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID)
if err != nil {
http.Error(w, "Invalid client", http.StatusBadRequest)
return
}
price, _ := strconv.ParseFloat(r.FormValue("price"), 64)
service := db.Service{
ClientID: clientID,
Name: r.FormValue("name"),
Price: price,
Description: r.FormValue("description"),
Duration: r.FormValue("duration"),
CreatedAt: time.Now().Unix(),
}
if err := service.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) ViewService(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
var s db.Service
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 {
http.Error(w, "Service not found", http.StatusNotFound)
return
}
buf := templates.BufRender()
fmt.Fprint(buf, templates.PageHeader(htmlEscape(s.Name), "Service details"))
fmt.Fprintf(buf, `
<div class="max-w-lg animate-slide-up">
<div class="card-industrial p-6">
<div class="space-y-4">
<div class="flex justify-between py-3 border-b border-white/[0.04]">
<span class="text-xs font-mono uppercase text-zinc-500">Price</span>
<span class="text-lg font-mono font-semibold text-emerald-400">R$ %.2f</span>
</div>
<div class="flex justify-between py-3 border-b border-white/[0.04]">
<span class="text-xs font-mono uppercase text-zinc-500">Duration</span>
<span class="text-sm text-zinc-300">%s</span>
</div>
<div class="flex justify-between py-3">
<span class="text-xs font-mono uppercase text-zinc-500">Description</span>
<span class="text-sm text-zinc-300 text-right max-w-xs">%s</span>
</div>
</div>
<div class="mt-6">
<a href="/services" class="btn-ghost btn-sm">Back</a>
</div>
</div>
</div>`, s.Price, htmlEscape(s.Duration), htmlEscape(s.Description))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
templates.WritePage(w, buf, s.Name, "services")
}
func (a *App) UpdateService(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
price, _ := strconv.ParseFloat(r.FormValue("price"), 64)
_, 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 {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("HX-Refresh", "true")
}
func (a *App) DeleteService(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
a.DB.Exec("DELETE FROM services WHERE service_id = ?", id)
}
// --- package-level shims ---
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)
}
+37
View File
@@ -0,0 +1,37 @@
package handlers
import (
"database/sql"
"time"
"go-crm/internal/whatsapp"
"go-crm/pkg/usecase"
)
// 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
WAConnector = wa
}
func getCurrentTimestamp() int64 {
return time.Now().Unix()
}
@@ -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 := `bg-emerald-400`
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)
}
}
}
+4
View File
@@ -0,0 +1,4 @@
{{ define "content" }}
<h1>Welcome to CRM</h1>
<p>Manage your clients, customers, and scheduling.</p>
{{ end }}
+78
View File
@@ -0,0 +1,78 @@
package templates
import (
"html/template"
"sync"
)
var (
templates *template.Template
mu sync.RWMutex
)
func Init() {
templates = template.Must(template.New("").ParseGlob("internal/templates/*.html"))
}
func Layout(title, content string) *template.Template {
mu.RLock()
defer mu.RUnlock()
tmpl := template.Must(template.New("layout.html").Parse(`<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{{ .Title }}</title>
<script src="https://unpkg.com/[email protected]"></script>
<style>
* { box-sizing: border-box; margin: 0; padding: 0; }
body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #f5f5f5; }
.container { max-width: 1200px; margin: 0 auto; padding: 20px; }
nav { background: white; border-bottom: 1px solid #e0e0e0; padding: 1rem 0; margin-bottom: 2rem; }
nav ul { list-style: none; display: flex; gap: 1.5rem; max-width: 1200px; margin: 0 auto; padding: 0 20px; }
nav a { color: #333; text-decoration: none; }
nav a:hover { color: #007bff; }
.card { background: white; border-radius: 8px; padding: 1.5rem; margin-bottom: 1rem; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
.btn { display: inline-block; padding: 0.5rem 1rem; background: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer; text-decoration: none; }
.btn:hover { background: #0056b3; }
.btn-secondary { background: #6c757d; }
.btn-danger { background: #dc3545; }
table { width: 100%; border-collapse: collapse; }
th, td { padding: 0.75rem; text-align: left; border-bottom: 1px solid #e0e0e0; }
th { background: #f8f9fa; font-weight: 600; }
form { display: flex; flex-direction: column; gap: 1rem; max-width: 500px; }
input, textarea, select { padding: 0.5rem; border: 1px solid #ddd; border-radius: 4px; width: 100%; }
textarea { min-height: 100px; }
.error { color: #dc3545; }
.success { color: #28a745; }
</style>
</head>
<body>
<nav>
<ul>
<li><a href="/">Home</a></li>
<li><a href="/leads">Leads</a></li>
<li><a href="/clients">Clients</a></li>
<li><a href="/customers">Customers</a></li>
<li><a href="/services">Services</a></li>
<li><a href="/scheduling">Scheduling</a></li>
<li><a href="/payments">Payments</a></li>
<li><a href="/questions">Questions</a></li>
<li><a href="/answers">Answers</a></li>
</ul>
</nav>
<div class="container">
{{ .Content }}
</div>
</body>
</html>`))
return tmpl
}
func Get(name string) *template.Template {
mu.RLock()
defer mu.RUnlock()
return templates.Lookup(name)
}
+490
View File
@@ -0,0 +1,490 @@
package templates
import (
"bytes"
"fmt"
"html/template"
"io"
"strings"
)
// Page renders a full HTML page with the industrial terminal layout.
type Page struct {
Title string
ActiveNav string
Content template.HTML
ExtraHead template.HTML
}
// NavItem defines a navigation entry.
type NavItem struct {
Label string
Href string
Icon string
ID string
}
var navItems = []NavItem{
{Label: "Dashboard", Href: "/", Icon: "M3 12l2-2m0 0l7-7 7 7M5 10v10a1 1 0 001 1h3m10-11l2 2m-2-2v10a1 1 0 01-1 1h-3m-6 0a1 1 0 001-1v-4a1 1 0 011-1h2a1 1 0 011 1v4a1 1 0 001 1m-6 0h6", ID: "dashboard"},
{Label: "Review Queue", Href: "/leads/review", Icon: "M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4", ID: "review"},
{Label: "All Leads", Href: "/leads/all", Icon: "M17 20h5v-2a3 3 0 00-5.356-1.857M17 20H7m10 0v-2c0-.656-.126-1.283-.356-1.857M7 20H2v-2a3 3 0 015.356-1.857M7 20v-2c0-.656.126-1.283.356-1.857m0 0a5.002 5.002 0 019.288 0M15 7a3 3 0 11-6 0 3 3 0 016 0zm6 3a2 2 0 11-4 0 2 2 0 014 0z", ID: "leads"},
{Label: "Report", Href: "/report", Icon: "M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6m10 0v-6a2 2 0 012-2h2a2 2 0 012 2v6m-6 0V7a2 2 0 012-2h2a2 2 0 012 2v12", ID: "report"},
{Label: "Clients", Href: "/clients", Icon: "M19 21V5a2 2 0 00-2-2H7a2 2 0 00-2 2v16m14 0h2m-2 0h-5m-9 0H3m2 0h5M9 7h1m-1 4h1m4-4h1m-1 4h1m-5 10v-5a1 1 0 011-1h2a1 1 0 011 1v5", ID: "clients"},
{Label: "Customers", Href: "/customers", Icon: "M12 4.354a4 4 0 110 5.292M15 21H3v-1a6 6 0 0112 0v1zm0 0h6v-1a6 6 0 00-9-5.197M13 7a4 4 0 11-8 0 4 4 0 018 0z", ID: "customers"},
{Label: "Services", Href: "/services", Icon: "M10.325 4.317c.426-1.756 2.924-1.756 3.35 0a1.724 1.724 0 002.573 1.066c1.543-.94 3.31.826 2.37 2.37a1.724 1.724 0 001.065 2.572c1.756.426 1.756 2.924 0 3.35a1.724 1.724 0 00-1.066 2.573c.94 1.543-.826 3.31-2.37 2.37a1.724 1.724 0 00-2.572 1.065c-.426 1.756-2.924 1.756-3.35 0a1.724 1.724 0 00-2.573-1.066c-1.543.94-3.31-.826-2.37-2.37a1.724 1.724 0 00-1.065-2.572c-1.756-.426-1.756-2.924 0-3.35a1.724 1.724 0 001.066-2.573c-.94-1.543.826-3.31 2.37-2.37 1.608.536 3.135-.493 3.35-2.572zM15 12a3 3 0 11-6 0 3 3 0 016 0z", ID: "services"},
{Label: "Scheduling", Href: "/scheduling", Icon: "M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z", ID: "scheduling"},
{Label: "Payments", Href: "/payments", Icon: "M12 8c-1.657 0-3 .895-3 2s1.343 2 3 2 3-.895 3-2-1.343-2-3-2zm0 0v1m0 0v1m0-1h1m-1 0H9m12 0a2 2 0 012 2v4.5a2.5 2.5 0 01-2.5 2.5h-15a2.5 2.5 0 01-2.5-2.5V10a2 2 0 012-2h15z", ID: "payments"},
{Label: "Questions", Href: "/questions", Icon: "M8.228 9c.549-1.165 2.03-2 3.772-2 2.21 0 4 1.343 4 3 0 1.4-1.278 2.575-3.006 2.907-.542.104-.994.54-.994 1.093m0 3h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z", ID: "questions"},
{Label: "Answers", Href: "/answers", Icon: "M7 8h10M7 12h4m1 8l-4-4H5a2 2 0 01-2-2V6a2 2 0 012-2h14a2 2 0 012 2v8a2 2 0 01-2 2h-3l-4 4z", ID: "answers"},
}
const layoutTemplate = `<!DOCTYPE html>
<html lang="en" class="dark">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{{.Title}} — go-crm</title>
<script src="https://unpkg.com/[email protected]"></script>
<script src="https://unpkg.com/htmx.org/dist/ext/loading-states.js"></script>
<script src="https://cdn.tailwindcss.com"></script>
<script>
tailwind.config = {
darkMode: 'class',
theme: {
extend: {
colors: {
zinc: { 950: '#0a0a0f', 900: '#111118', 850: '#15151e', 800: '#1a1a24', 750: '#1e1e2a', 700: '#272736', 600: '#3f3f50', 500: '#5a5a6e', 400: '#7a7a8f', 300: '#a1a1b3', 200: '#c4c4d4', 100: '#e2e2eb', 50: '#f4f4f8' },
amber: { 450: '#d97706', 400: '#f59e0b', 300: '#fbbf24' },
emerald: { 450: '#059669', 400: '#10b981', 300: '#34d399' },
rose: { 450: '#e11d48', 400: '#f43f5e', 300: '#fb7185' },
sky: { 450: '#0284c7', 400: '#0ea5e9', 300: '#38bdf8' },
},
fontFamily: {
mono: ['"JetBrains Mono"', 'ui-monospace', 'SFMono-Regular', 'Menlo', 'Monaco', 'Consolas', 'monospace'],
sans: ['"Inter"', 'system-ui', '-apple-system', 'BlinkMacSystemFont', 'sans-serif'],
},
}
}
}
</script>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@300;400;500;600;700&display=swap" rel="stylesheet">
<style>
/* Industrial Terminal Aesthetic */
:root {
--bg-primary: #0a0a0f;
--bg-secondary: #111118;
--bg-tertiary: #1a1a24;
--bg-elevated: #1e1e2a;
--border-subtle: rgba(255,255,255,0.06);
--border-medium: rgba(255,255,255,0.1);
--border-strong: rgba(255,255,255,0.15);
--text-primary: #e2e2eb;
--text-secondary: #a1a1b3;
--text-muted: #7a7a8f;
--accent-amber: #f59e0b;
--accent-emerald: #10b981;
--accent-rose: #f43f5e;
--accent-sky: #0ea5e9;
}
body {
background-color: var(--bg-primary);
color: var(--text-primary);
font-family: 'Inter', system-ui, sans-serif;
}
/* Grid overlay */
.grid-overlay {
background-image:
linear-gradient(rgba(255,255,255,0.015) 1px, transparent 1px),
linear-gradient(90deg, rgba(255,255,255,0.015) 1px, transparent 1px);
background-size: 40px 40px;
}
/* Subtle noise texture */
.noise-overlay::before {
content: '';
position: fixed;
top: 0; left: 0; width: 100%; height: 100%;
opacity: 0.025;
pointer-events: none;
background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 256 256' xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='4' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)'/%3E%3C/svg%3E");
z-index: 9999;
}
/* Scrollbar */
::-webkit-scrollbar { width: 6px; height: 6px; }
::-webkit-scrollbar-track { background: var(--bg-primary); }
::-webkit-scrollbar-thumb { background: var(--bg-tertiary); border-radius: 3px; }
::-webkit-scrollbar-thumb:hover { background: var(--bg-elevated); }
/* HTMX transitions */
.htmx-swapping { opacity: 0.5; transition: opacity 200ms ease; }
.htmx-settling { opacity: 0; animation: fadeIn 250ms ease forwards; }
@keyframes fadeIn { to { opacity: 1; } }
/* Loading spinner */
.htmx-request .spinner { display: inline-block !important; }
.spinner { display: none; width: 16px; height: 16px; border: 2px solid rgba(255,255,255,0.1); border-top-color: var(--accent-amber); border-radius: 50%; animation: spin 0.6s linear infinite; }
@keyframes spin { to { transform: rotate(360deg); } }
/* Table styles */
.data-table { width: 100%; border-collapse: separate; border-spacing: 0; }
.data-table th { background: var(--bg-secondary); color: var(--text-muted); font-family: 'JetBrains Mono', monospace; font-size: 0.7rem; text-transform: uppercase; letter-spacing: 0.05em; font-weight: 500; padding: 0.75rem 1rem; border-bottom: 1px solid var(--border-medium); text-align: left; white-space: nowrap; }
.data-table td { padding: 0.875rem 1rem; border-bottom: 1px solid var(--border-subtle); color: var(--text-secondary); font-size: 0.875rem; vertical-align: middle; }
.data-table tbody tr:hover td { background: rgba(255,255,255,0.02); }
.data-table tbody tr:last-child td { border-bottom: none; }
/* Form inputs */
.input-industrial {
background: var(--bg-secondary);
border: 1px solid var(--border-medium);
color: var(--text-primary);
padding: 0.5rem 0.75rem;
border-radius: 0.375rem;
font-size: 0.875rem;
transition: border-color 150ms, box-shadow 150ms;
outline: none;
width: 100%;
}
.input-industrial:focus { border-color: var(--accent-amber); box-shadow: 0 0 0 2px rgba(245,158,11,0.1); }
.input-industrial::placeholder { color: var(--text-muted); }
select.input-industrial { appearance: none; background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 24 24' stroke='%237a7a8f'%3E%3Cpath stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M19 9l-7 7-7-7'/%3E%3C/svg%3E"); background-repeat: no-repeat; background-position: right 0.5rem center; background-size: 1.25rem; padding-right: 2.5rem; }
/* Buttons */
.btn-primary {
background: var(--accent-amber);
color: #0a0a0f;
font-weight: 600;
font-size: 0.8rem;
text-transform: uppercase;
letter-spacing: 0.025em;
padding: 0.5rem 1rem;
border-radius: 0.375rem;
border: none;
cursor: pointer;
transition: all 150ms;
font-family: 'JetBrains Mono', monospace;
display: inline-flex; align-items: center; gap: 0.5rem;
}
.btn-primary:hover { background: #fbbf24; transform: translateY(-1px); box-shadow: 0 4px 12px rgba(245,158,11,0.2); }
.btn-primary:active { transform: translateY(0); }
.btn-ghost {
background: transparent;
color: var(--text-secondary);
border: 1px solid var(--border-medium);
font-weight: 500;
font-size: 0.8rem;
padding: 0.5rem 1rem;
border-radius: 0.375rem;
cursor: pointer;
transition: all 150ms;
display: inline-flex; align-items: center; gap: 0.5rem;
}
.btn-ghost:hover { background: rgba(255,255,255,0.05); color: var(--text-primary); border-color: var(--border-strong); }
.btn-danger {
background: rgba(244,63,94,0.1);
color: var(--accent-rose);
border: 1px solid rgba(244,63,94,0.2);
font-weight: 500;
font-size: 0.8rem;
padding: 0.5rem 1rem;
border-radius: 0.375rem;
cursor: pointer;
transition: all 150ms;
}
.btn-danger:hover { background: rgba(244,63,94,0.2); }
.btn-sm { padding: 0.375rem 0.75rem; font-size: 0.75rem; }
/* Cards */
.card-industrial {
background: var(--bg-secondary);
border: 1px solid var(--border-subtle);
border-radius: 0.5rem;
position: relative;
overflow: hidden;
}
.card-industrial::before {
content: '';
position: absolute;
top: 0; left: 0; right: 0;
height: 1px;
background: linear-gradient(90deg, transparent, rgba(255,255,255,0.08), transparent);
}
/* Status pills */
.pill {
display: inline-flex;
align-items: center;
gap: 0.375rem;
padding: 0.25rem 0.625rem;
border-radius: 9999px;
font-size: 0.7rem;
font-weight: 600;
font-family: 'JetBrains Mono', monospace;
text-transform: uppercase;
letter-spacing: 0.03em;
white-space: nowrap;
}
.pill-amber { background: rgba(245,158,11,0.1); color: var(--accent-amber); border: 1px solid rgba(245,158,11,0.15); }
.pill-emerald { background: rgba(16,185,129,0.1); color: var(--accent-emerald); border: 1px solid rgba(16,185,129,0.15); }
.pill-rose { background: rgba(244,63,94,0.1); color: var(--accent-rose); border: 1px solid rgba(244,63,94,0.15); }
.pill-sky { background: rgba(14,165,233,0.1); color: var(--accent-sky); border: 1px solid rgba(14,165,233,0.15); }
.pill-zinc { background: rgba(255,255,255,0.05); color: var(--text-muted); border: 1px solid var(--border-medium); }
/* Nav */
.nav-link {
display: flex; align-items: center; gap: 0.75rem;
padding: 0.625rem 1rem;
border-radius: 0.375rem;
color: var(--text-muted);
font-size: 0.8rem;
font-weight: 500;
transition: all 150ms;
text-decoration: none;
border: 1px solid transparent;
}
.nav-link:hover { background: rgba(255,255,255,0.03); color: var(--text-secondary); }
.nav-link.active { background: rgba(245,158,11,0.08); color: var(--accent-amber); border-color: rgba(245,158,11,0.15); }
.nav-link svg { width: 18px; height: 18px; flex-shrink: 0; }
/* Animation */
@keyframes slideUp { from { opacity: 0; transform: translateY(8px); } to { opacity: 1; transform: translateY(0); } }
.animate-slide-up { animation: slideUp 0.4s ease forwards; }
.stagger-1 { animation-delay: 0.05s; opacity: 0; }
.stagger-2 { animation-delay: 0.1s; opacity: 0; }
.stagger-3 { animation-delay: 0.15s; opacity: 0; }
.stagger-4 { animation-delay: 0.2s; opacity: 0; }
.stagger-5 { animation-delay: 0.25s; opacity: 0; }
/* Mobile */
@media (max-width: 1024px) {
.sidebar { transform: translateX(-100%); transition: transform 300ms ease; }
.sidebar.open { transform: translateX(0); }
.sidebar-backdrop { display: none; }
.sidebar.open + .sidebar-backdrop { display: block; position: fixed; inset: 0; background: rgba(0,0,0,0.5); z-index: 30; }
}
</style>
{{.ExtraHead}}
</head>
<body class="noise-overlay grid-overlay min-h-screen antialiased">
<div class="flex min-h-screen">
<!-- Sidebar -->
<aside id="sidebar" class="sidebar fixed lg:static inset-y-0 left-0 w-64 bg-zinc-900 border-r border-white/[0.06] z-40 flex flex-col">
<div class="p-5 border-b border-white/[0.06]">
<div class="flex items-center gap-3">
<div class="w-8 h-8 rounded bg-amber-400/10 border border-amber-400/20 flex items-center justify-center">
<svg class="w-4 h-4 text-amber-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 10V3L4 14h7v7l9-11h-7z"/></svg>
</div>
<div>
<div class="font-mono text-sm font-bold text-zinc-100 tracking-tight">go-crm</div>
<div class="font-mono text-[10px] text-zinc-500 uppercase tracking-wider">v2.0.0-industrial</div>
</div>
</div>
</div>
<nav class="flex-1 overflow-y-auto p-3 space-y-0.5">
{{range .NavItems}}
<a href="{{.Href}}" class="nav-link {{if .Active}}active{{end}}">
<svg fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="{{.Icon}}"/></svg>
<span>{{.Label}}</span>
</a>
{{end}}
</nav>
<div class="p-4 border-t border-white/[0.06]">
<a href="/auth/account" class="flex items-center gap-3 p-2 rounded-lg hover:bg-white/[0.03] transition-colors">
<div class="w-8 h-8 rounded-full bg-zinc-800 border border-white/[0.08] flex items-center justify-center">
<svg class="w-4 h-4 text-zinc-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M16 7a4 4 0 11-8 0 4 4 0 018 0zM12 14a7 7 0 00-7 7h14a7 7 0 00-7-7z"/></svg>
</div>
<div class="min-w-0">
<div class="text-xs font-medium text-zinc-300 truncate">Account</div>
<div class="text-[10px] text-zinc-500">Settings</div>
</div>
</a>
<form method="POST" action="/auth/logout" class="mt-2">
<button type="submit" class="w-full flex items-center gap-2 px-3 py-2 text-xs text-zinc-500 hover:text-rose-400 hover:bg-rose-400/5 rounded-lg transition-colors font-mono">
<svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M17 16l4-4m0 0l-4-4m4 4H7m6 4v1a3 3 0 01-3 3H6a3 3 0 01-3-3V7a3 3 0 013-3h4a3 3 0 013 3v1"/></svg>
Sign Out
</button>
</form>
</div>
</aside>
<div class="sidebar-backdrop lg:hidden" onclick="document.getElementById('sidebar').classList.remove('open')"></div>
<!-- Main content -->
<div class="flex-1 flex flex-col min-w-0 lg:ml-0">
<!-- Top bar -->
<header class="h-14 bg-zinc-900/80 backdrop-blur border-b border-white/[0.06] flex items-center justify-between px-4 lg:px-6 sticky top-0 z-30">
<div class="flex items-center gap-3">
<button onclick="document.getElementById('sidebar').classList.toggle('open')" class="lg:hidden p-2 -ml-2 text-zinc-400 hover:text-zinc-200">
<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 6h16M4 12h16M4 18h16"/></svg>
</button>
<h1 class="font-mono text-sm font-semibold text-zinc-200 tracking-tight">{{.Title}}</h1>
<div class="spinner ml-2"></div>
</div>
<div class="flex items-center gap-3">
<a href="/leads/keywords" class="hidden sm:flex items-center gap-2 px-3 py-1.5 text-xs font-mono text-zinc-400 bg-zinc-800/50 border border-white/[0.06] rounded hover:text-amber-400 hover:border-amber-400/20 transition-colors">
<svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 20l4-16m4 4l4 4-4 4M6 16l-4-4 4-4"/></svg>
Keywords
</a>
</div>
</header>
<!-- Page content -->
<main class="flex-1 p-4 lg:p-6 overflow-x-hidden">
{{.Content}}
</main>
</div>
</div>
</body>
</html>`
// NavItemRender is used in the layout template.
type NavItemRender struct {
Label string
Href string
Icon string
Active bool
}
// RenderPage writes a complete HTML page with the industrial layout.
func RenderPage(w io.Writer, title, activeNav string, content template.HTML) error {
var items []NavItemRender
for _, ni := range navItems {
items = append(items, NavItemRender{
Label: ni.Label,
Href: ni.Href,
Icon: ni.Icon,
Active: ni.ID == activeNav,
})
}
tmpl, err := template.New("layout").Parse(layoutTemplate)
if err != nil {
return err
}
return tmpl.Execute(w, struct {
Title string
NavItems []NavItemRender
Content template.HTML
ExtraHead template.HTML
}{
Title: title,
NavItems: items,
Content: content,
})
}
// ---------------------------------------------------------------------------
// Page Sections / Helpers
// ---------------------------------------------------------------------------
// PageHeader generates a page header with title and optional action buttons.
func PageHeader(title, subtitle string, actions ...string) template.HTML {
var actionHTML string
if len(actions) > 0 {
actionHTML = `<div class="flex items-center gap-2">` + strings.Join(actions, "") + `</div>`
}
return template.HTML(fmt.Sprintf(`
<div class="mb-6 animate-slide-up">
<div class="flex flex-col sm:flex-row sm:items-end sm:justify-between gap-4">
<div>
<h1 class="text-xl font-bold text-zinc-100 tracking-tight">%s</h1>
<p class="text-sm text-zinc-500 mt-1">%s</p>
</div>
%s
</div>
</div>`, template.HTMLEscapeString(title), template.HTMLEscapeString(subtitle), actionHTML))
}
// KPI card for dashboards.
func KPICard(label, value, trend, colorClass, iconSVG string, stagger int) template.HTML {
borderColor := "border-white/[0.06]"
textColor := "text-zinc-300"
switch colorClass {
case "amber":
borderColor = "border-amber-400/15"
textColor = "text-amber-400"
case "emerald":
borderColor = "border-emerald-400/15"
textColor = "text-emerald-400"
case "rose":
borderColor = "border-rose-400/15"
textColor = "text-rose-400"
case "sky":
borderColor = "border-sky-400/15"
textColor = "text-sky-400"
}
trendHTML := ""
if trend != "" {
trendHTML = fmt.Sprintf(`<span class="text-[10px] font-mono text-zinc-500 mt-1">%s</span>`, template.HTMLEscapeString(trend))
}
return template.HTML(fmt.Sprintf(`
<div class="card-industrial p-5 border %s animate-slide-up stagger-%d">
<div class="flex items-start justify-between">
<div>
<div class="text-[10px] font-mono uppercase tracking-wider text-zinc-500 mb-2">%s</div>
<div class="text-2xl font-mono font-bold %s">%s</div>
%s
</div>
<div class="p-2 rounded-lg bg-white/[0.03] border border-white/[0.06]">
<svg class="w-5 h-5 %s" fill="none" stroke="currentColor" viewBox="0 0 24 24">%s</svg>
</div>
</div>
</div>`, borderColor, stagger,
template.HTMLEscapeString(label),
textColor,
template.HTMLEscapeString(value),
trendHTML,
textColor,
iconSVG))
}
// TableStart begins a data table.
func TableStart(headers []string) template.HTML {
var ths string
for _, h := range headers {
ths += fmt.Sprintf(`<th>%s</th>`, template.HTMLEscapeString(h))
}
return template.HTML(fmt.Sprintf(`<table class="data-table"><thead><tr>%s</tr></thead><tbody>`, ths))
}
// TableEnd closes a data table.
func TableEnd() template.HTML {
return template.HTML(`</tbody></table>`)
}
// EmptyState shows when no data exists.
func EmptyState(icon, message string) template.HTML {
return template.HTML(fmt.Sprintf(`
<div class="flex flex-col items-center justify-center py-16 text-center animate-slide-up">
<div class="w-16 h-16 rounded-full bg-white/[0.03] border border-white/[0.06] flex items-center justify-center mb-4">
<svg class="w-8 h-8 text-zinc-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">%s</svg>
</div>
<p class="text-zinc-500 text-sm">%s</p>
</div>`, icon, template.HTMLEscapeString(message)))
}
// SectionCard wraps content in a card with title.
func SectionCard(title, subtitle string, content template.HTML) template.HTML {
return template.HTML(fmt.Sprintf(`
<div class="card-industrial animate-slide-up">
<div class="px-5 py-4 border-b border-white/[0.06]">
<h2 class="text-sm font-semibold text-zinc-200">%s</h2>
<p class="text-xs text-zinc-500 mt-0.5">%s</p>
</div>
<div class="p-5">%s</div>
</div>`, template.HTMLEscapeString(title), template.HTMLEscapeString(subtitle), content))
}
// ---------------------------------------------------------------------------
// Render helpers that write to a buffer then to a ResponseWriter
// ---------------------------------------------------------------------------
// BufRender starts a bytes.Buffer for collecting HTML content.
func BufRender() *bytes.Buffer {
return &bytes.Buffer{}
}
// WritePage renders the full page from a buffer to a ResponseWriter.
func WritePage(w io.Writer, buf *bytes.Buffer, title, activeNav string) error {
return RenderPage(w, title, activeNav, template.HTML(buf.String()))
}
// ---------------------------------------------------------------------------
// Convenience: write raw HTML directly to ResponseWriter with layout
// ---------------------------------------------------------------------------
// WriteHTMLPage takes an io.Writer, writes the layout wrapping the given HTML string.
func WriteHTMLPage(w io.Writer, title, activeNav, html string) error {
return RenderPage(w, title, activeNav, template.HTML(html))
}
@@ -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
}
+191
View File
@@ -0,0 +1,191 @@
package main
import (
"fmt"
"log"
"net/http"
"strconv"
"go-crm/config"
"go-crm/internal/db"
"go-crm/internal/handlers"
"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/middleware"
"github.com/go-chi/cors"
)
func main() {
fmt.Println("main: starting db init")
database, err := db.Init(config.DatabasePath())
fmt.Println("main: db init returned")
if err != nil {
log.Fatalf("Failed to initialize database: %v", err)
}
defer database.Close()
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.Use(middleware.Logger)
r.Use(middleware.Recoverer)
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()
r.Get("/", app.Dashboard)
r.Route("/auth", func(r chi.Router) {
r.Get("/signup", app.SignupPage)
r.Post("/signup", app.Signup)
r.Get("/login", app.LoginPage)
r.Post("/login", app.Login)
r.Post("/logout", app.Logout)
r.Get("/account", app.AccountPage)
r.Post("/account", app.UpdateAccount)
})
r.Route("/clients", func(r chi.Router) {
r.Get("/", app.ListClients)
r.Post("/", app.CreateClient)
r.Get("/{id}", app.ViewClient)
r.Put("/{id}", app.UpdateClient)
r.Delete("/{id}", app.DeleteClient)
})
r.Route("/customers", func(r chi.Router) {
r.Get("/", app.ListCustomers)
r.Post("/", app.CreateCustomer)
r.Get("/{id}", app.ViewCustomer)
r.Put("/{id}", app.UpdateCustomer)
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.Get("/", app.ListServices)
r.Post("/", app.CreateService)
r.Get("/{id}", app.ViewService)
r.Put("/{id}", app.UpdateService)
r.Delete("/{id}", app.DeleteService)
})
r.Route("/scheduling", func(r chi.Router) {
r.Get("/", app.ListSchedules)
r.Post("/", app.CreateSchedule)
r.Get("/{id}", app.ViewSchedule)
r.Put("/{id}", app.UpdateSchedule)
r.Delete("/{id}", app.DeleteSchedule)
})
r.Route("/payments", func(r chi.Router) {
r.Get("/", app.ListPayments)
r.Post("/", app.CreatePayment)
r.Get("/{id}", app.ViewPayment)
r.Put("/{id}", app.UpdatePayment)
r.Delete("/{id}", app.DeletePayment)
})
r.Route("/questions", func(r chi.Router) {
r.Get("/", app.ListQuestions)
r.Post("/", app.CreateQuestion)
r.Get("/{id}", app.ViewQuestion)
r.Put("/{id}", app.UpdateQuestion)
r.Delete("/{id}", app.DeleteQuestion)
})
r.Route("/answers", func(r chi.Router) {
r.Get("/", app.ListAnswers)
r.Post("/", app.CreateAnswer)
r.Get("/{id}", app.ViewAnswer)
r.Put("/{id}", app.UpdateAnswer)
r.Delete("/{id}", app.DeleteAnswer)
})
fmt.Println("main: ready to serve")
fmt.Println("CRM server running on http://localhost:8080")
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": {
"better-sqlite3": "^12.8.0",
"node-cron": "3.0.3",
"node-cron": "^4.2.1",
"qrcode-terminal": "0.12.0",
"sql.js": "1.10.2",
"whatsapp-web.js": "1.23.0"
"whatsapp-web.js": "^1.34.7"
},
"devDependencies": {
"@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.
+47
View File
@@ -0,0 +1,47 @@
# ADR Format
ADRs live in `docs/adr/` and use sequential numbering: `0001-slug.md`, `0002-slug.md`, etc.
Create the `docs/adr/` directory lazily — only when the first ADR is needed.
## Template
```md
# {Short title of the decision}
{1-3 sentences: what's the context, what did we decide, and why.}
```
That's it. An ADR can be a single paragraph. The value is in recording *that* a decision was made and *why* — not in filling out sections.
## Optional sections
Only include these when they add genuine value. Most ADRs won't need them.
- **Status** frontmatter (`proposed | accepted | deprecated | superseded by ADR-NNNN`) — useful when decisions are revisited
- **Considered Options** — only when the rejected alternatives are worth remembering
- **Consequences** — only when non-obvious downstream effects need to be called out
## Numbering
Scan `docs/adr/` for the highest existing number and increment by one.
## When to offer an ADR
All three of these must be true:
1. **Hard to reverse** — the cost of changing your mind later is meaningful
2. **Surprising without context** — a future reader will look at the code and wonder "why on earth did they do it this way?"
3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
If a decision is easy to reverse, skip it — you'll just reverse it. If it's not surprising, nobody will wonder why. If there was no real alternative, there's nothing to record beyond "we did the obvious thing."
### What qualifies
- **Architectural shape.** "We're using a monorepo." "The write model is event-sourced, the read model is projected into Postgres."
- **Integration patterns between contexts.** "Ordering and Billing communicate via domain events, not synchronous HTTP."
- **Technology choices that carry lock-in.** Database, message bus, auth provider, deployment target. Not every library — just the ones that would take a quarter to swap out.
- **Boundary and scope decisions.** "Customer data is owned by the Customer context; other contexts reference it by ID only." The explicit no-s are as valuable as the yes-s.
- **Deliberate deviations from the obvious path.** "We're using manual SQL instead of an ORM because X." Anything where a reasonable reader would assume the opposite. These stop the next engineer from "fixing" something that was deliberate.
- **Constraints not visible in the code.** "We can't use AWS because of compliance requirements." "Response times must be under 200ms because of the partner API contract."
- **Rejected alternatives when the rejection is non-obvious.** If you considered GraphQL and picked REST for subtle reasons, record it — otherwise someone will suggest GraphQL again in six months.
+77
View File
@@ -0,0 +1,77 @@
# CONTEXT.md Format
## Structure
```md
# {Context Name}
{One or two sentence description of what this context is and why it exists.}
## Language
**Order**:
A customer's request to purchase one or more items.
_Avoid_: Purchase, transaction
**Invoice**:
A request for payment sent to a customer after delivery.
_Avoid_: Bill, payment request
**Customer**:
A person or organization that places orders.
_Avoid_: Client, buyer, account
## Relationships
- An **Order** produces one or more **Invoices**
- An **Invoice** belongs to exactly one **Customer**
## Example dialogue
> **Dev:** "When a **Customer** places an **Order**, do we create the **Invoice** immediately?"
> **Domain expert:** "No — an **Invoice** is only generated once a **Fulfillment** is confirmed."
## Flagged ambiguities
- "account" was used to mean both **Customer** and **User** — resolved: these are distinct concepts.
```
## Rules
- **Be opinionated.** When multiple words exist for the same concept, pick the best one and list the others as aliases to avoid.
- **Flag conflicts explicitly.** If a term is used ambiguously, call it out in "Flagged ambiguities" with a clear resolution.
- **Keep definitions tight.** One sentence max. Define what it IS, not what it does.
- **Show relationships.** Use bold term names and express cardinality where obvious.
- **Only include terms specific to this project's context.** General programming concepts (timeouts, error types, utility patterns) don't belong even if the project uses them extensively. Before adding a term, ask: is this a concept unique to this context, or a general programming concept? Only the former belongs.
- **Group terms under subheadings** when natural clusters emerge. If all terms belong to a single cohesive area, a flat list is fine.
- **Write an example dialogue.** A conversation between a dev and a domain expert that demonstrates how the terms interact naturally and clarifies boundaries between related concepts.
## Single vs multi-context repos
**Single context (most repos):** One `CONTEXT.md` at the repo root.
**Multiple contexts:** A `CONTEXT-MAP.md` at the repo root lists the contexts, where they live, and how they relate to each other:
```md
# Context Map
## Contexts
- [Ordering](./src/ordering/CONTEXT.md) — receives and tracks customer orders
- [Billing](./src/billing/CONTEXT.md) — generates invoices and processes payments
- [Fulfillment](./src/fulfillment/CONTEXT.md) — manages warehouse picking and shipping
## Relationships
- **Ordering → Fulfillment**: Ordering emits `OrderPlaced` events; Fulfillment consumes them to start picking
- **Fulfillment → Billing**: Fulfillment emits `ShipmentDispatched` events; Billing consumes them to generate invoices
- **Ordering ↔ Billing**: Shared types for `CustomerId` and `Money`
```
The skill infers which structure applies:
- If `CONTEXT-MAP.md` exists, read it to find contexts
- If only a root `CONTEXT.md` exists, single context
- If neither exists, create a root `CONTEXT.md` lazily when the first term is resolved
When multiple contexts exist, infer which one the current topic relates to. If unclear, ask.
+81
View File
@@ -0,0 +1,81 @@
---
name: domain-model
description: Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.
disable-model-invocation: true
---
Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
Ask the questions one at a time, waiting for feedback on each question before continuing.
If a question can be answered by exploring the codebase, explore the codebase instead.
## Domain awareness
During codebase exploration, also look for existing documentation:
### File structure
Most repos have a single context:
```
/
├── CONTEXT.md
├── docs/
│ └── adr/
│ ├── 0001-event-sourced-orders.md
│ └── 0002-postgres-for-write-model.md
└── src/
```
If a `CONTEXT-MAP.md` exists at the root, the repo has multiple contexts. The map points to where each one lives:
```
/
├── CONTEXT-MAP.md
├── docs/
│ └── adr/ ← system-wide decisions
├── src/
│ ├── ordering/
│ │ ├── CONTEXT.md
│ │ └── docs/adr/ ← context-specific decisions
│ └── billing/
│ ├── CONTEXT.md
│ └── docs/adr/
```
Create files lazily — only when you have something to write. If no `CONTEXT.md` exists, create one when the first term is resolved. If no `docs/adr/` exists, create it when the first ADR is needed.
## During the session
### Challenge against the glossary
When the user uses a term that conflicts with the existing language in `CONTEXT.md`, call it out immediately. "Your glossary defines 'cancellation' as X, but you seem to mean Y — which is it?"
### Sharpen fuzzy language
When the user uses vague or overloaded terms, propose a precise canonical term. "You're saying 'account' — do you mean the Customer or the User? Those are different things."
### Discuss concrete scenarios
When domain relationships are being discussed, stress-test them with specific scenarios. Invent scenarios that probe edge cases and force the user to be precise about the boundaries between concepts.
### Cross-reference with code
When the user states how something works, check whether the code agrees. If you find a contradiction, surface it: "Your code cancels entire Orders, but you just said partial cancellation is possible — which is right?"
### Update CONTEXT.md inline
When a term is resolved, update `CONTEXT.md` right there. Don't batch these up — capture them as they happen. Use the format in [CONTEXT-FORMAT.md](./CONTEXT-FORMAT.md).
Don't couple `CONTEXT.md` to implementation details. Only include terms that are meaningful to domain experts.
### Offer ADRs sparingly
Only offer to create an ADR when all three are true:
1. **Hard to reverse** — the cost of changing your mind later is meaningful
2. **Surprising without context** — a future reader will wonder "why did they do it this way?"
3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
If any of the three is missing, skip the ADR. Use the format in [ADR-FORMAT.md](./ADR-FORMAT.md).
+10
View File
@@ -0,0 +1,10 @@
---
name: grill-me
description: Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
---
Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
Ask the questions one at a time.
If a question can be answered by exploring the codebase, explore the codebase instead.
@@ -0,0 +1,37 @@
# Deepening
How to deepen a cluster of shallow modules safely, given its dependencies. Assumes the vocabulary in [LANGUAGE.md](LANGUAGE.md) — **module**, **interface**, **seam**, **adapter**.
## Dependency categories
When assessing a candidate for deepening, classify its dependencies. The category determines how the deepened module is tested across its seam.
### 1. In-process
Pure computation, in-memory state, no I/O. Always deepenable — merge the modules and test through the new interface directly. No adapter needed.
### 2. Local-substitutable
Dependencies that have local test stand-ins (PGLite for Postgres, in-memory filesystem). Deepenable if the stand-in exists. The deepened module is tested with the stand-in running in the test suite. The seam is internal; no port at the module's external interface.
### 3. Remote but owned (Ports & Adapters)
Your own services across a network boundary (microservices, internal APIs). Define a **port** (interface) at the seam. The deep module owns the logic; the transport is injected as an **adapter**. Tests use an in-memory adapter. Production uses an HTTP/gRPC/queue adapter.
Recommendation shape: *"Define a port at the seam, implement an HTTP adapter for production and an in-memory adapter for testing, so the logic sits in one deep module even though it's deployed across a network."*
### 4. True external (Mock)
Third-party services (Stripe, Twilio, etc.) you don't control. The deepened module takes the external dependency as an injected port; tests provide a mock adapter.
## Seam discipline
- **One adapter means a hypothetical seam. Two adapters means a real one.** Don't introduce a port unless at least two adapters are justified (typically production + test). A single-adapter seam is just indirection.
- **Internal seams vs external seams.** A deep module can have internal seams (private to its implementation, used by its own tests) as well as the external seam at its interface. Don't expose internal seams through the interface just because tests use them.
## Testing strategy: replace, don't layer
- Old unit tests on shallow modules become waste once tests at the deepened module's interface exist — delete them.
- Write new tests at the deepened module's interface. The **interface is the test surface**.
- Tests assert on observable outcomes through the interface, not internal state.
- Tests should survive internal refactors — they describe behaviour, not implementation. If a test has to change when the implementation changes, it's testing past the interface.
@@ -0,0 +1,44 @@
# Interface Design
When the user wants to explore alternative interfaces for a chosen deepening candidate, use this parallel sub-agent pattern. Based on "Design It Twice" (Ousterhout) — your first idea is unlikely to be the best.
Uses the vocabulary in [LANGUAGE.md](LANGUAGE.md) — **module**, **interface**, **seam**, **adapter**, **leverage**.
## Process
### 1. Frame the problem space
Before spawning sub-agents, write a user-facing explanation of the problem space for the chosen candidate:
- The constraints any new interface would need to satisfy
- The dependencies it would rely on, and which category they fall into (see [DEEPENING.md](DEEPENING.md))
- A rough illustrative code sketch to ground the constraints — not a proposal, just a way to make the constraints concrete
Show this to the user, then immediately proceed to Step 2. The user reads and thinks while the sub-agents work in parallel.
### 2. Spawn sub-agents
Spawn 3+ sub-agents in parallel using the Agent tool. Each must produce a **radically different** interface for the deepened module.
Prompt each sub-agent with a separate technical brief (file paths, coupling details, dependency category from [DEEPENING.md](DEEPENING.md), what sits behind the seam). The brief is independent of the user-facing problem-space explanation in Step 1. Give each agent a different design constraint:
- Agent 1: "Minimize the interface — aim for 1–3 entry points max. Maximise leverage per entry point."
- Agent 2: "Maximise flexibility — support many use cases and extension."
- Agent 3: "Optimise for the most common caller — make the default case trivial."
- Agent 4 (if applicable): "Design around ports & adapters for cross-seam dependencies."
Include both [LANGUAGE.md](LANGUAGE.md) vocabulary and CONTEXT.md vocabulary in the brief so each sub-agent names things consistently with the architecture language and the project's domain language.
Each sub-agent outputs:
1. Interface (types, methods, params — plus invariants, ordering, error modes)
2. Usage example showing how callers use it
3. What the implementation hides behind the seam
4. Dependency strategy and adapters (see [DEEPENING.md](DEEPENING.md))
5. Trade-offs — where leverage is high, where it's thin
### 3. Present and compare
Present designs sequentially so the user can absorb each one, then compare them in prose. Contrast by **depth** (leverage at the interface), **locality** (where change concentrates), and **seam placement**.
After comparing, give your own recommendation: which design you think is strongest and why. If elements from different designs would combine well, propose a hybrid. Be opinionated — the user wants a strong read, not a menu.
@@ -0,0 +1,53 @@
# Language
Shared vocabulary for every suggestion this skill makes. Use these terms exactly — don't substitute "component," "service," "API," or "boundary." Consistent language is the whole point.
## Terms
**Module**
Anything with an interface and an implementation. Deliberately scale-agnostic — applies equally to a function, class, package, or tier-spanning slice.
_Avoid_: unit, component, service.
**Interface**
Everything a caller must know to use the module correctly. Includes the type signature, but also invariants, ordering constraints, error modes, required configuration, and performance characteristics.
_Avoid_: API, signature (too narrow — those refer only to the type-level surface).
**Implementation**
What's inside a module — its body of code. Distinct from **Adapter**: a thing can be a small adapter with a large implementation (a Postgres repo) or a large adapter with a small implementation (an in-memory fake). Reach for "adapter" when the seam is the topic; "implementation" otherwise.
**Depth**
Leverage at the interface — the amount of behaviour a caller (or test) can exercise per unit of interface they have to learn. A module is **deep** when a large amount of behaviour sits behind a small interface. A module is **shallow** when the interface is nearly as complex as the implementation.
**Seam** _(from Michael Feathers)_
A place where you can alter behaviour without editing in that place. The *location* at which a module's interface lives. Choosing where to put the seam is its own design decision, distinct from what goes behind it.
_Avoid_: boundary (overloaded with DDD's bounded context).
**Adapter**
A concrete thing that satisfies an interface at a seam. Describes *role* (what slot it fills), not substance (what's inside).
**Leverage**
What callers get from depth. More capability per unit of interface they have to learn. One implementation pays back across N call sites and M tests.
**Locality**
What maintainers get from depth. Change, bugs, knowledge, and verification concentrate at one place rather than spreading across callers. Fix once, fixed everywhere.
## Principles
- **Depth is a property of the interface, not the implementation.** A deep module can be internally composed of small, mockable, swappable parts — they just aren't part of the interface. A module can have **internal seams** (private to its implementation, used by its own tests) as well as the **external seam** at its interface.
- **The deletion test.** Imagine deleting the module. If complexity vanishes, the module wasn't hiding anything (it was a pass-through). If complexity reappears across N callers, the module was earning its keep.
- **The interface is the test surface.** Callers and tests cross the same seam. If you want to test *past* the interface, the module is probably the wrong shape.
- **One adapter means a hypothetical seam. Two adapters means a real one.** Don't introduce a seam unless something actually varies across it.
## Relationships
- A **Module** has exactly one **Interface** (the surface it presents to callers and tests).
- **Depth** is a property of a **Module**, measured against its **Interface**.
- A **Seam** is where a **Module**'s **Interface** lives.
- An **Adapter** sits at a **Seam** and satisfies the **Interface**.
- **Depth** produces **Leverage** for callers and **Locality** for maintainers.
## Rejected framings
- **Depth as ratio of implementation-lines to interface-lines** (Ousterhout): rewards padding the implementation. We use depth-as-leverage instead.
- **"Interface" as the TypeScript `interface` keyword or a class's public methods**: too narrow — interface here includes every fact a caller must know.
- **"Boundary"**: overloaded with DDD's bounded context. Say **seam** or **interface**.
@@ -0,0 +1,76 @@
---
name: improve-codebase-architecture
description: Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.
---
# Improve Codebase Architecture
Surface architectural friction and propose **deepening opportunities** — refactors that turn shallow modules into deep ones. The aim is testability and AI-navigability.
## Glossary
Use these terms exactly in every suggestion. Consistent language is the point — don't drift into "component," "service," "API," or "boundary." Full definitions in [LANGUAGE.md](LANGUAGE.md).
- **Module** — anything with an interface and an implementation (function, class, package, slice).
- **Interface** — everything a caller must know to use the module: types, invariants, error modes, ordering, config. Not just the type signature.
- **Implementation** — the code inside.
- **Depth** — leverage at the interface: a lot of behaviour behind a small interface. **Deep** = high leverage. **Shallow** = interface nearly as complex as the implementation.
- **Seam** — where an interface lives; a place behaviour can be altered without editing in place. (Use this, not "boundary.")
- **Adapter** — a concrete thing satisfying an interface at a seam.
- **Leverage** — what callers get from depth.
- **Locality** — what maintainers get from depth: change, bugs, knowledge concentrated in one place.
Key principles (see [LANGUAGE.md](LANGUAGE.md) for the full list):
- **Deletion test**: imagine deleting the module. If complexity vanishes, it was a pass-through. If complexity reappears across N callers, it was earning its keep.
- **The interface is the test surface.**
- **One adapter = hypothetical seam. Two adapters = real seam.**
This skill is _informed_ by the project's domain model — `CONTEXT.md` and any `docs/adr/`. The domain language gives names to good seams; ADRs record decisions the skill should not re-litigate. See [CONTEXT-FORMAT.md](../domain-model/CONTEXT-FORMAT.md) and [ADR-FORMAT.md](../domain-model/ADR-FORMAT.md).
## Process
### 1. Explore
Read existing documentation first:
- `CONTEXT.md` (or `CONTEXT-MAP.md` + each `CONTEXT.md` in a multi-context repo)
- Relevant ADRs in `docs/adr/` (and any context-scoped `docs/adr/` directories)
If any of these files don't exist, proceed silently — don't flag their absence or suggest creating them upfront.
Then use the Agent tool with `subagent_type=Explore` to walk the codebase. Don't follow rigid heuristics — explore organically and note where you experience friction:
- Where does understanding one concept require bouncing between many small modules?
- Where are modules **shallow** — interface nearly as complex as the implementation?
- Where have pure functions been extracted just for testability, but the real bugs hide in how they're called (no **locality**)?
- Where do tightly-coupled modules leak across their seams?
- Which parts of the codebase are untested, or hard to test through their current interface?
Apply the **deletion test** to anything you suspect is shallow: would deleting it concentrate complexity, or just move it? A "yes, concentrates" is the signal you want.
### 2. Present candidates
Present a numbered list of deepening opportunities. For each candidate:
- **Files** — which files/modules are involved
- **Problem** — why the current architecture is causing friction
- **Solution** — plain English description of what would change
- **Benefits** — explained in terms of locality and leverage, and also in how tests would improve
**Use CONTEXT.md vocabulary for the domain, and [LANGUAGE.md](LANGUAGE.md) vocabulary for the architecture.** If `CONTEXT.md` defines "Order," talk about "the Order intake module" — not "the FooBarHandler," and not "the Order service."
**ADR conflicts**: if a candidate contradicts an existing ADR, only surface it when the friction is real enough to warrant revisiting the ADR. Mark it clearly (e.g. _"contradicts ADR-0007 — but worth reopening because…"_). Don't list every theoretical refactor an ADR forbids.
Do NOT propose interfaces yet. Ask the user: "Which of these would you like to explore?"
### 3. Grilling loop
Once the user picks a candidate, drop into a grilling conversation. Walk the design tree with them — constraints, dependencies, the shape of the deepened module, what sits behind the seam, what tests survive.
Side effects happen inline as decisions crystallize:
- **Naming a deepened module after a concept not in `CONTEXT.md`?** Add the term to `CONTEXT.md` — same discipline as `/domain-model` (see [CONTEXT-FORMAT.md](../domain-model/CONTEXT-FORMAT.md)). Create the file lazily if it doesn't exist.
- **Sharpening a fuzzy term during the conversation?** Update `CONTEXT.md` right there.
- **User rejects the candidate with a load-bearing reason?** Offer an ADR, framed as: _"Want me to record this as an ADR so future architecture reviews don't re-suggest it?"_ Only offer when the reason would actually be needed by a future explorer to avoid re-suggesting the same thing — skip ephemeral reasons ("not worth it right now") and self-evident ones. See [ADR-FORMAT.md](../domain-model/ADR-FORMAT.md).
- **Want to explore alternative interfaces for the deepened module?** See [INTERFACE-DESIGN.md](INTERFACE-DESIGN.md).
+73
View File
@@ -0,0 +1,73 @@
---
name: to-prd
description: Turn the current conversation context into a PRD and submit it as a GitHub issue. Use when user wants to create a PRD from the current context.
---
This skill takes the current conversation context and codebase understanding and produces a PRD. Do NOT interview the user — just synthesize what you already know.
## Process
1. Explore the repo to understand the current state of the codebase, if you haven't already.
2. Sketch out the major modules you will need to build or modify to complete the implementation. Actively look for opportunities to extract deep modules that can be tested in isolation.
A deep module (as opposed to a shallow module) is one which encapsulates a lot of functionality in a simple, testable interface which rarely changes.
Check with the user that these modules match their expectations. Check with the user which modules they want tests written for.
3. Write the PRD using the template below and submit it as a GitHub issue.
<prd-template>
## Problem Statement
The problem that the user is facing, from the user's perspective.
## Solution
The solution to the problem, from the user's perspective.
## User Stories
A LONG, numbered list of user stories. Each user story should be in the format of:
1. As an <actor>, I want a <feature>, so that <benefit>
<user-story-example>
1. As a mobile bank customer, I want to see balance on my accounts, so that I can make better informed decisions about my spending
</user-story-example>
This list of user stories should be extremely extensive and cover all aspects of the feature.
## Implementation Decisions
A list of implementation decisions that were made. This can include:
- The modules that will be built/modified
- The interfaces of those modules that will be modified
- Technical clarifications from the developer
- Architectural decisions
- Schema changes
- API contracts
- Specific interactions
Do NOT include specific file paths or code snippets. They may end up being outdated very quickly.
## Testing Decisions
A list of testing decisions that were made. Include:
- A description of what makes a good test (only test external behavior, not implementation details)
- Which modules will be tested
- Prior art for the tests (i.e. similar types of tests in the codebase)
## Out of Scope
A description of the things that are out of scope for this PRD.
## Further Notes
Any further notes about the feature.
</prd-template>
+107
View File
@@ -0,0 +1,107 @@
---
name: tdd
description: Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development.
---
# Test-Driven Development
## Philosophy
**Core principle**: Tests should verify behavior through public interfaces, not implementation details. Code can change entirely; tests shouldn't.
**Good tests** are integration-style: they exercise real code paths through public APIs. They describe _what_ the system does, not _how_ it does it. A good test reads like a specification - "user can checkout with valid cart" tells you exactly what capability exists. These tests survive refactors because they don't care about internal structure.
**Bad tests** are coupled to implementation. They mock internal collaborators, test private methods, or verify through external means (like querying a database directly instead of using the interface). The warning sign: your test breaks when you refactor, but behavior hasn't changed. If you rename an internal function and tests fail, those tests were testing implementation, not behavior.
See [tests.md](tests.md) for examples and [mocking.md](mocking.md) for mocking guidelines.
## Anti-Pattern: Horizontal Slices
**DO NOT write all tests first, then all implementation.** This is "horizontal slicing" - treating RED as "write all tests" and GREEN as "write all code."
This produces **crap tests**:
- Tests written in bulk test _imagined_ behavior, not _actual_ behavior
- You end up testing the _shape_ of things (data structures, function signatures) rather than user-facing behavior
- Tests become insensitive to real changes - they pass when behavior breaks, fail when behavior is fine
- You outrun your headlights, committing to test structure before understanding the implementation
**Correct approach**: Vertical slices via tracer bullets. One test → one implementation → repeat. Each test responds to what you learned from the previous cycle. Because you just wrote the code, you know exactly what behavior matters and how to verify it.
```
WRONG (horizontal):
RED: test1, test2, test3, test4, test5
GREEN: impl1, impl2, impl3, impl4, impl5
RIGHT (vertical):
RED→GREEN: test1→impl1
RED→GREEN: test2→impl2
RED→GREEN: test3→impl3
...
```
## Workflow
### 1. Planning
Before writing any code:
- [ ] Confirm with user what interface changes are needed
- [ ] Confirm with user which behaviors to test (prioritize)
- [ ] Identify opportunities for [deep modules](deep-modules.md) (small interface, deep implementation)
- [ ] Design interfaces for [testability](interface-design.md)
- [ ] List the behaviors to test (not implementation steps)
- [ ] Get user approval on the plan
Ask: "What should the public interface look like? Which behaviors are most important to test?"
**You can't test everything.** Confirm with the user exactly which behaviors matter most. Focus testing effort on critical paths and complex logic, not every possible edge case.
### 2. Tracer Bullet
Write ONE test that confirms ONE thing about the system:
```
RED: Write test for first behavior → test fails
GREEN: Write minimal code to pass → test passes
```
This is your tracer bullet - proves the path works end-to-end.
### 3. Incremental Loop
For each remaining behavior:
```
RED: Write next test → fails
GREEN: Minimal code to pass → passes
```
Rules:
- One test at a time
- Only enough code to pass current test
- Don't anticipate future tests
- Keep tests focused on observable behavior
### 4. Refactor
After all tests pass, look for [refactor candidates](refactoring.md):
- [ ] Extract duplication
- [ ] Deepen modules (move complexity behind simple interfaces)
- [ ] Apply SOLID principles where natural
- [ ] Consider what new code reveals about existing code
- [ ] Run tests after each refactor step
**Never refactor while RED.** Get to GREEN first.
## Checklist Per Cycle
```
[ ] Test describes behavior, not implementation
[ ] Test uses public interface only
[ ] Test would survive internal refactor
[ ] Code is minimal for this test
[ ] No speculative features added
```
+33
View File
@@ -0,0 +1,33 @@
# Deep Modules
From "A Philosophy of Software Design":
**Deep module** = small interface + lots of implementation
```
┌─────────────────────┐
│ Small Interface │ ← Few methods, simple params
├─────────────────────┤
│ │
│ │
│ Deep Implementation│ ← Complex logic hidden
│ │
│ │
└─────────────────────┘
```
**Shallow module** = large interface + little implementation (avoid)
```
┌─────────────────────────────────┐
│ Large Interface │ ← Many methods, complex params
├─────────────────────────────────┤
│ Thin Implementation │ ← Just passes through
└─────────────────────────────────┘
```
When designing interfaces, ask:
- Can I reduce the number of methods?
- Can I simplify the parameters?
- Can I hide more complexity inside?
+31
View File
@@ -0,0 +1,31 @@
# Interface Design for Testability
Good interfaces make testing natural:
1. **Accept dependencies, don't create them**
```typescript
// Testable
function processOrder(order, paymentGateway) {}
// Hard to test
function processOrder(order) {
const gateway = new StripeGateway();
}
```
2. **Return results, don't produce side effects**
```typescript
// Testable
function calculateDiscount(cart): Discount {}
// Hard to test
function applyDiscount(cart): void {
cart.total -= discount;
}
```
3. **Small surface area**
- Fewer methods = fewer tests needed
- Fewer params = simpler test setup
+59
View File
@@ -0,0 +1,59 @@
# When to Mock
Mock at **system boundaries** only:
- External APIs (payment, email, etc.)
- Databases (sometimes - prefer test DB)
- Time/randomness
- File system (sometimes)
Don't mock:
- Your own classes/modules
- Internal collaborators
- Anything you control
## Designing for Mockability
At system boundaries, design interfaces that are easy to mock:
**1. Use dependency injection**
Pass external dependencies in rather than creating them internally:
```typescript
// Easy to mock
function processPayment(order, paymentClient) {
return paymentClient.charge(order.total);
}
// Hard to mock
function processPayment(order) {
const client = new StripeClient(process.env.STRIPE_KEY);
return client.charge(order.total);
}
```
**2. Prefer SDK-style interfaces over generic fetchers**
Create specific functions for each external operation instead of one generic function with conditional logic:
```typescript
// GOOD: Each function is independently mockable
const api = {
getUser: (id) => fetch(`/users/${id}`),
getOrders: (userId) => fetch(`/users/${userId}/orders`),
createOrder: (data) => fetch('/orders', { method: 'POST', body: data }),
};
// BAD: Mocking requires conditional logic inside the mock
const api = {
fetch: (endpoint, options) => fetch(endpoint, options),
};
```
The SDK approach means:
- Each mock returns one specific shape
- No conditional logic in test setup
- Easier to see which endpoints a test exercises
- Type safety per endpoint
Loaded 100 of 104 files, more files were not shown because too many files have changed in this diff. Show more