gabspereira/workspace
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(go-crm): full auth, routing, middleware, and supporting infra

Browse Source 
- 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
This commit is contained in:
Gabriel Pereira
2026-05-23 16:55:55 -03:00
parent 57920d45d6
commit 744868caa1
52 changed files with 4868 additions and 1068 deletions
Download Patch File Download Diff File Expand all files Collapse all files

307
apps/go-crm/internal/handlers/auth.go
View File

@@ -9,8 +9,11 @@ import (
"golang.org/x/crypto/bcrypt"
)
func SignupPage(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
// 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) {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html>
<html lang="en">
<head>
@@ -30,7 +33,7 @@ func SignupPage(w http.ResponseWriter, r *http.Request) {
</html>`))
}
func Signup(w http.ResponseWriter, r *http.Request) {
func (a *App) Signup(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
email := r.FormValue("email")
name := r.FormValue("name")
@@ -47,21 +50,17 @@ func Signup(w http.ResponseWriter, r *http.Request) {
return
}
account := struct {
Email string
Name string
Password string
CreatedAt int64
}{
Email: email,
Name: name,
Password: string(hashedPassword),
CreatedAt: time.Now().Unix(),
// Use a transaction so account + client + session are atomic.
tx, err := a.DB.Begin()
if err != nil {
http.Error(w, "Failed to start transaction", http.StatusInternalServerError)
return
}
defer tx.Rollback()
_, err = DB.Exec(
_, err = tx.Exec(
"INSERT INTO accounts (email, name, password, created_at) VALUES (?, ?, ?, ?)",
account.Email, account.Name, account.Password, account.CreatedAt,
email, name, string(hashedPassword), time.Now().Unix(),
)
if err != nil {
http.Error(w, "Email already exists", http.StatusBadRequest)
@@ -69,45 +68,40 @@ func Signup(w http.ResponseWriter, r *http.Request) {
}
var accountID int64
err = DB.QueryRow("SELECT account_id FROM accounts WHERE email = ?", email).Scan(&accountID)
if err != nil {
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
}
client := struct {
AccountID int64
Name string
CreatedAt int64
}{
AccountID: accountID,
Name: name,
CreatedAt: time.Now().Unix(),
}
_, err = DB.Exec(
if _, err = tx.Exec(
"INSERT INTO clients (account_id, name, created_at) VALUES (?, ?, ?)",
client.AccountID, client.Name, client.CreatedAt,
)
if err != nil {
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()
_, err = DB.Exec("INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)", sessionID, accountID, expires)
if err != nil {
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 LoginPage(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
func (a *App) LoginPage(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html>
<html lang="en">
<head>
@@ -126,16 +120,14 @@ func LoginPage(w http.ResponseWriter, r *http.Request) {
</html>`))
}
var DB *sql.DB
func Login(w http.ResponseWriter, r *http.Request) {
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 := DB.QueryRow("SELECT account_id, password FROM accounts WHERE email = ?", email).Scan(&accountID, &hashedPassword)
err := a.DB.QueryRow("SELECT account_id, password FROM accounts WHERE email = ?", email).Scan(&accountID, &hashedPassword)
if err != nil {
http.Error(w, "Invalid credentials", http.StatusUnauthorized)
return
@@ -149,7 +141,7 @@ func Login(w http.ResponseWriter, r *http.Request) {
sessionID := generateSessionID()
expires := time.Now().Add(24 * time.Hour).Unix()
_, err = DB.Exec("INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)", sessionID, accountID, expires)
_, err = a.DB.Exec("INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)", sessionID, accountID, expires)
if err != nil {
http.Error(w, "Failed to create session", http.StatusInternalServerError)
return
@@ -159,16 +151,152 @@ func Login(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "/", http.StatusFound)
}
func Logout(w http.ResponseWriter, r *http.Request) {
func (a *App) Logout(w http.ResponseWriter, r *http.Request) {
cookie, err := r.Cookie("session")
if err == nil {
DB.Exec("DELETE FROM sessions WHERE session_id = ?", cookie.Value)
a.DB.Exec("DELETE FROM sessions WHERE session_id = ?", cookie.Value)
}
http.SetCookie(w, &http.Cookie{Name: "session", Value: "", Path: "/", MaxAge: -1})
http.Redirect(w, r, "/auth/login", http.StatusFound)
}
func (a *App) AccountPage(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
var name, email string
err := a.DB.QueryRow("SELECT name, email FROM accounts WHERE account_id = ?", accountID).Scan(&name, &email)
if err != nil {
http.Error(w, "Account not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><html><head><title>Account</title></head><body><h1>Account Settings</h1><form method="POST" action="/auth/account">
<p>Name: <input type="text" name="name" value="` + name + `"></p>
<p>Email: <input type="email" value="` + email + `" disabled></p>
<p>New Password: <input type="password" name="password" placeholder="Leave blank to keep current"></p>
<button type="submit">Update</button>
</form>
<a href="/">Back to Dashboard</a></body></html>`))
}
func (a *App) UpdateAccount(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
r.ParseForm()
name := r.FormValue("name")
password := r.FormValue("password")
if name != "" {
a.DB.Exec("UPDATE accounts SET name = ? WHERE account_id = ?", name, accountID)
}
if password != "" {
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err == nil {
a.DB.Exec("UPDATE accounts SET password = ? WHERE account_id = ?", string(hashedPassword), accountID)
}
}
http.Redirect(w, r, "/auth/account", http.StatusFound)
}
// --- session helpers on App --------------------------------------------------
func (a *App) getSession(r *http.Request) (int64, error) {
cookie, err := r.Cookie("session")
if err != nil {
return 0, err
}
var accountID int64
err = a.DB.QueryRow(
"SELECT account_id FROM sessions WHERE session_id = ? AND expires > ?",
cookie.Value, time.Now().Unix(),
).Scan(&accountID)
return accountID, err
}
func (a *App) GetAccountID(r *http.Request) (int64, error) {
return a.getSession(r)
}
func (a *App) requireAuth(w http.ResponseWriter, r *http.Request) (int64, bool) {
accountID, err := a.getSession(r)
if err != nil {
if isAPIRequest(r) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(`{"error":"unauthorized"}`))
} else {
http.Redirect(w, r, "/auth/login", http.StatusFound)
}
return 0, false
}
return accountID, true
}
func (a *App) clientIDForAccount(accountID int64) int64 {
var clientID int64
a.DB.QueryRow("SELECT client_id FROM clients WHERE account_id = ? LIMIT 1", accountID).Scan(&clientID)
return clientID
}
// --- package-level shims kept for existing tests that set the global DB ------
func GetAccountID(r *http.Request) (int64, error) {
return getSession(r)
}
func getSession(r *http.Request) (int64, error) {
cookie, err := r.Cookie("session")
if err != nil {
return 0, err
}
var accountID int64
err = DB.QueryRow(
"SELECT account_id FROM sessions WHERE session_id = ? AND expires > ?",
cookie.Value, time.Now().Unix(),
).Scan(&accountID)
return accountID, err
}
func requireAuth(w http.ResponseWriter, r *http.Request) (int64, bool) {
accountID, err := getSession(r)
if err != nil {
if isAPIRequest(r) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(`{"error":"unauthorized"}`))
} else {
http.Redirect(w, r, "/auth/login", http.StatusFound)
}
return 0, false
}
return accountID, true
}
func clientIDForAccount(accountID int64) int64 {
var clientID int64
DB.QueryRow("SELECT client_id FROM clients WHERE account_id = ? LIMIT 1", accountID).Scan(&clientID)
return clientID
}
func isAPIRequest(r *http.Request) bool {
accept := r.Header.Get("Accept")
return accept == "application/json" || r.URL.Path == "/leads/qr"
}
func SetupAuthHandlers(db *sql.DB) {
DB = db
chi.RegisterMethod("GET")
}
// --- session ID generation ---------------------------------------------------
func generateSessionID() string {
return time.Now().Format("20060102150405") + "-" + randomString(32)
}
@@ -182,88 +310,41 @@ func randomString(n int) string {
return string(b)
}
func getSession(r *http.Request) (int64, error) {
cookie, err := r.Cookie("session")
if err != nil {
return 0, err
}
// 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.
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 SignupPage(w http.ResponseWriter, r *http.Request) {
a := &App{DB: DB, WAConnector: WAConnector}
a.SignupPage(w, r)
}
func GetAccountID(r *http.Request) (int64, error) {
return getSession(r)
func Signup(w http.ResponseWriter, r *http.Request) {
a := &App{DB: DB, WAConnector: WAConnector}
a.Signup(w, r)
}
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")
w.Write([]byte(`{"error":"unauthorized"}`))
} else {
http.Redirect(w, r, "/auth/login", http.StatusFound)
}
return 0, false
}
return accountID, true
func LoginPage(w http.ResponseWriter, r *http.Request) {
a := &App{DB: DB, WAConnector: WAConnector}
a.LoginPage(w, r)
}
func isAPIRequest(r *http.Request) bool {
accept := r.Header.Get("Accept")
return accept == "application/json" || r.URL.Path == "/leads/qr"
func Login(w http.ResponseWriter, r *http.Request) {
a := &App{DB: DB, WAConnector: WAConnector}
a.Login(w, r)
}
func SetupAuthHandlers(db *sql.DB) {
DB = db
chi.RegisterMethod("GET")
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) {
accountID, ok := requireAuth(w, r)
if !ok {
return
}
var name, email string
err := DB.QueryRow("SELECT name, email FROM accounts WHERE account_id = ?", accountID).Scan(&name, &email)
if err != nil {
http.Error(w, "Account not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "text/html")
w.Write([]byte(`<!DOCTYPE html><html><head><title>Account</title></head><body><h1>Account Settings</h1><form method="POST" action="/auth/account">
<p>Name: <input type="text" name="name" value="` + name + `"></p>
<p>Email: <input type="email" value="` + email + `" disabled></p>
<p>New Password: <input type="password" name="password" placeholder="Leave blank to keep current"></p>
<button type="submit">Update</button>
</form>
<a href="/">Back to Dashboard</a></body></html>`))
a := &App{DB: DB, WAConnector: WAConnector}
a.AccountPage(w, r)
}
func UpdateAccount(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
if !ok {
return
}
r.ParseForm()
name := r.FormValue("name")
password := r.FormValue("password")
if name != "" {
DB.Exec("UPDATE accounts SET name = ? WHERE account_id = ?", name, accountID)
}
if password != "" {
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err == nil {
DB.Exec("UPDATE accounts SET password = ? WHERE account_id = ?", string(hashedPassword), accountID)
}
}
http.Redirect(w, r, "/auth/account", http.StatusFound)
}
a := &App{DB: DB, WAConnector: WAConnector}
a.UpdateAccount(w, r)
}

110
apps/go-crm/internal/handlers/clients.go
View File

@@ -10,8 +10,8 @@ import (
"github.com/go-chi/chi/v5"
)
func ListClients(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) ListClients(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -22,13 +22,13 @@ func ListClients(w http.ResponseWriter, r *http.Request) {
limit = 20
}
clients, err := db.ListClients(DB, accountID, limit, offset)
clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html>
<html>
<head>
@@ -60,8 +60,14 @@ func ListClients(w http.ResponseWriter, r *http.Request) {
`))
for _, c := range clients {
var whatsappCell string
if c.WhatsAppConnected == 1 && c.WhatsAppNumber != "" {
whatsappCell = c.WhatsAppNumber
connected := false
if c.WhatsAppNumber != "" && a.WAConnector != nil {
connected, _ = a.WAConnector.IsConnected(r.Context(), c.ClientID)
}
if connected {
whatsappCell = c.WhatsAppNumber + ` <span style="color:#28a745">&#9679;</span>`
} else if c.WhatsAppConnected == 1 && c.WhatsAppNumber != "" {
whatsappCell = c.WhatsAppNumber + ` <span style="color:#dc3545">&#9675;</span> <a href="/leads/connect?client_id=` + strconv.FormatInt(c.ClientID, 10) + `">Reconnect</a>`
} else {
whatsappCell = `<a href="/leads/connect?client_id=` + strconv.FormatInt(c.ClientID, 10) + `">Connect</a>`
}
@@ -88,11 +94,13 @@ func ListClients(w http.ResponseWriter, r *http.Request) {
</td>
</tr>`))
}
w.Write([]byte(`</tbody></table></body></html>`))
w.Write([]byte(`</tbody></table>
<p><a href="/">Back to Home</a></p>
</body></html>`))
}
func CreateClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) CreateClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -104,33 +112,57 @@ func CreateClient(w http.ResponseWriter, r *http.Request) {
Phone: r.FormValue("phone"),
Email: r.FormValue("email"),
Address: r.FormValue("address"),
Notes: r.FormValue("notes"),
Notes: r.FormValue("notes"),
CreatedAt: time.Now().Unix(),
}
if err := client.Create(DB); err != nil {
if err := client.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("HX-Refresh", "true")
}
func ViewClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
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(DB, accountID, id)
client, err := db.GetClientByID(a.DB, accountID, id)
if err != nil {
http.Error(w, "Client not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
var whatsappSection string
if client.WhatsAppNumber != "" {
connected := false
if a.WAConnector != nil {
connected, _ = a.WAConnector.IsConnected(r.Context(), client.ClientID)
}
status := "Not connected"
style := "color:#999"
if connected {
status = "Connected"
style = "color:#28a745"
} else if client.WhatsAppConnected == 1 {
status = "Disconnected (was connected)"
style = "color:#dc3545"
}
whatsappSection = `
<p>WhatsApp: <strong>` + client.WhatsAppNumber + `</strong> <span style="` + style + `">(` + status + `)</span></p>
<p><a href="/leads/connect?client_id=` + strconv.FormatInt(client.ClientID, 10) + `">Reconnect WhatsApp</a></p>`
} else {
whatsappSection = `
<p>WhatsApp: Not configured <a href="/leads/connect?client_id=` + strconv.FormatInt(client.ClientID, 10) + `">Connect</a></p>`
}
w.Write([]byte(`<!DOCTYPE html>
<html>
<head></head>
@@ -140,13 +172,13 @@ func ViewClient(w http.ResponseWriter, r *http.Request) {
<p>Phone: ` + client.Phone + `</p>
<p>Email: ` + client.Email + `</p>
<p>Address: ` + client.Address + `</p>
<p>Notes: ` + client.Notes + `</p>
<p>Notes: ` + client.Notes + `</p>` + whatsappSection + `
<a href="/clients">Back</a>
</body></html>`))
}
func UpdateClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) UpdateClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -156,14 +188,14 @@ func UpdateClient(w http.ResponseWriter, r *http.Request) {
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"),
Name: r.FormValue("name"),
Phone: r.FormValue("phone"),
Email: r.FormValue("email"),
Address: r.FormValue("address"),
Notes: r.FormValue("notes"),
}
if err := client.Update(DB); err != nil {
if err := client.Update(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
@@ -171,19 +203,37 @@ func UpdateClient(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true")
}
func DeleteClient(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
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(DB); err != nil {
if err := client.Delete(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte("OK"))
}
}
// --- package-level shims kept for existing tests ---
func ListClients(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListClients(w, r)
}
func CreateClient(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreateClient(w, r)
}
func ViewClient(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewClient(w, r)
}
func UpdateClient(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateClient(w, r)
}
func DeleteClient(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteClient(w, r)
}

126
apps/go-crm/internal/handlers/clients_test.go
View File

@@ -210,4 +210,128 @@ func TestLeadsQRPolling(t *testing.T) {
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 (?, ?, ?, ?)",
"test@example.com", "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 = ?", "test@example.com").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 (?, ?, ?, ?)",
"test@example.com", "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 = ?", "test@example.com").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")
}
}

85
apps/go-crm/internal/handlers/dashboard.go Normal file
View File

@@ -0,0 +1,85 @@
package handlers
import (
"fmt"
"net/http"
)
func (a *App) Dashboard(w http.ResponseWriter, r *http.Request) {
accountID, err := a.getSession(r)
if err != nil {
http.Redirect(w, r, "/auth/login", http.StatusFound)
return
}
var clientID int64
a.DB.QueryRow("SELECT client_id FROM clients WHERE account_id = ? LIMIT 1", accountID).Scan(&clientID)
var reviewCount int
if clientID > 0 {
a.DB.QueryRow("SELECT COUNT(*) FROM leads WHERE client_id = ? AND needs_review = 1", clientID).Scan(&reviewCount)
}
waStatus := "disconnected"
waStyle := "color:#dc3545"
connectLink := ""
if a.WAConnector != nil {
if connected, _ := a.WAConnector.IsConnected(r.Context(), clientID); connected {
waStatus = "connected"
waStyle = "color:#28a745"
} else if clientID > 0 {
// Fallback: check DB column when in-memory state not available.
var dbConnected int
a.DB.QueryRow("SELECT whatsapp_connected FROM clients WHERE client_id = ?", clientID).Scan(&dbConnected)
if dbConnected == 1 {
waStatus = "connected"
waStyle = "color:#28a745"
} else {
connectLink = fmt.Sprintf(` <a href="/leads/connect?client_id=%d" style="color:#28a745">Connect</a>`, clientID)
}
} else {
connectLink = ` <a href="/clients" style="color:#28a745">Create client to connect</a>`
}
}
badge := ""
if reviewCount > 0 {
badge = fmt.Sprintf(` <span style="background:#dc3545;color:#fff;border-radius:1rem;padding:0.15rem 0.5rem;font-size:0.8rem">%d</span>`, reviewCount)
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprintf(w, `<!DOCTYPE html>
<html>
<head>
<title>Dashboard</title>
<style>
body { font-family: sans-serif; padding: 1.5rem; }
nav a { margin-right: 1rem; text-decoration: none; color: #2c7be5; }
nav a:hover { text-decoration: underline; }
.wa-status { font-size: 0.9rem; }
</style>
</head>
<body>
<h1>CRM Dashboard</h1>
<p class="wa-status">WhatsApp: <strong style="%s">%s</strong>%s</p>
<nav>
<a href="/leads/review">Review Queue%s</a>
<a href="/leads/all">All Leads</a>
<a href="/report">Monthly Report</a>
<a href="/leads/keywords">Keyword Mapping</a>
<a href="/clients">Clients</a>
<a href="/services">Services</a>
<a href="/scheduling">Scheduling</a>
<a href="/payments">Payments</a>
<a href="/auth/account">Account</a>
<form method="POST" action="/auth/logout" style="display:inline">
<button type="submit">Logout</button>
</form>
</nav>
</body></html>`, waStyle, waStatus, connectLink, badge)
}
// --- package-level shim kept for existing tests ---
func Dashboard(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).Dashboard(w, r)
}

291
apps/go-crm/internal/handlers/dashboard_test.go Normal file
View File

@@ -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 (?, ?, ?, ?)",
"test@example.com", "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 = ?", "test@example.com").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 (?, ?, ?, ?)",
"test@example.com", "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 = ?", "test@example.com").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 (?, ?, ?, ?)",
"test@example.com", "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 = ?", "test@example.com").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 (?, ?, ?, ?)",
"test@example.com", "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 = ?", "test@example.com").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")
}
}

151
apps/go-crm/internal/handlers/leads.go
View File

@@ -6,6 +6,7 @@ import (
"log"
"net/http"
"strconv"
"strings"
"time"
"go-crm/internal/db"
@@ -14,8 +15,8 @@ import (
"github.com/go-chi/chi/v5"
)
func ListLeads(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) ListLeads(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -27,7 +28,7 @@ func ListLeads(w http.ResponseWriter, r *http.Request) {
limit = 20
}
query := "SELECT customer_id, client_id, name, phone, birth_date, instagram, created_at FROM customers WHERE client_id IN (SELECT client_id FROM clients WHERE account_id = ?)"
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 != "" {
@@ -36,10 +37,10 @@ func ListLeads(w http.ResponseWriter, r *http.Request) {
args = append(args, searchPat, searchPat)
}
query += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
query += " ORDER BY cu.created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
rows, err := DB.Query(query, args...)
rows, err := a.DB.Query(query, args...)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
@@ -49,13 +50,13 @@ func ListLeads(w http.ResponseWriter, r *http.Request) {
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); err != nil {
if err := rows.Scan(&c.CustomerID, &c.ClientID, &c.Name, &c.Phone, &c.BirthDate, &c.Instagram, &c.CreatedAt, &c.WhatsAppConnected, &c.WhatsAppNumber); err != nil {
continue
}
customers = append(customers, c)
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html>
<html>
<head>
@@ -80,17 +81,24 @@ func ListLeads(w http.ResponseWriter, r *http.Request) {
</div>
<table>
<thead>
<tr><th>Name</th><th>Phone</th><th>Birth Date</th><th>Instagram</th><th>Actions</th></tr>
<tr><th>Name</th><th>Phone</th><th>Birth Date</th><th>Instagram</th><th>WhatsApp</th><th>Actions</th></tr>
</thead>
<tbody id="leadList">
`))
for _, c := range customers {
waStatus := "Not connected"
waStyle := "color: #999;"
if c.WhatsAppConnected == 1 && c.WhatsAppNumber != "" {
waStatus = c.WhatsAppNumber
waStyle = "color: #28a745; font-weight: 600;"
}
w.Write([]byte(`<tr>
<td>` + c.Name + `</td>
<td>` + c.Phone + `</td>
<td>` + c.BirthDate + `</td>
<td>` + c.Instagram + `</td>
<td style="` + waStyle + `">` + waStatus + `</td>
<td>
<button type="button" onclick="document.getElementById('editLead` + strconv.FormatInt(c.CustomerID, 10) + `').style.display='table-row'">Edit</button>
<form method="DELETE" style="display:inline" hx-delete="/leads/` + strconv.FormatInt(c.CustomerID, 10) + `" hx-target="closest tr">
@@ -99,7 +107,7 @@ func ListLeads(w http.ResponseWriter, r *http.Request) {
</td>
</tr>
<tr id="editLead` + strconv.FormatInt(c.CustomerID, 10) + `" class="edit-row">
<td colspan="5">
<td colspan="6">
<form hx-put="/leads/` + strconv.FormatInt(c.CustomerID, 10) + `" hx-target="#leadList" hx-swap="innerHTML">
<input type="text" name="name" value="` + c.Name + `">
<input type="tel" name="phone" value="` + c.Phone + `">
@@ -112,12 +120,12 @@ func ListLeads(w http.ResponseWriter, r *http.Request) {
}
w.Write([]byte(`</tbody></table>
<p><a href="/clients">Back to Clients</a></p>
<p><a href="/">Back to Home</a> | <a href="/clients">Back to Clients</a></p>
</body></html>`))
}
func UpdateLead(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) UpdateLead(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -125,7 +133,7 @@ func UpdateLead(w http.ResponseWriter, r *http.Request) {
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm()
_, err := DB.Exec(
_, 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,
)
@@ -134,18 +142,18 @@ func UpdateLead(w http.ResponseWriter, r *http.Request) {
return
}
ListLeads(w, r)
a.ListLeads(w, r)
}
func DeleteLead(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(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 := DB.Exec(
_, err := a.DB.Exec(
"DELETE FROM customers WHERE customer_id = ? AND client_id IN (SELECT client_id FROM clients WHERE account_id = ?)",
id, accountID,
)
@@ -154,24 +162,24 @@ func DeleteLead(w http.ResponseWriter, r *http.Request) {
return
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte("OK"))
}
func LeadsConnectPage(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
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(DB, accountID, clientID)
client, err := db.GetClientByID(a.DB, accountID, clientID)
if err != nil {
http.Error(w, "Client not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html>
<html>
<head>
@@ -196,7 +204,6 @@ func LeadsConnectPage(w http.ResponseWriter, r *http.Request) {
.then(r => r.json())
.then(data => {
if (data.qr) {
// Only re-render QR if the code actually changed.
if (data.qr !== lastQR) {
lastQR = data.qr;
document.getElementById('qrcode').innerHTML = '';
@@ -209,12 +216,29 @@ func LeadsConnectPage(w http.ResponseWriter, r *http.Request) {
document.getElementById('status').textContent = 'Scan with WhatsApp';
setTimeout(pollQR, 5000);
} else if (data.status === 'ready') {
document.getElementById('status').textContent = 'Connected!';
document.getElementById('status').textContent = 'Connected! Verifying phone...';
document.getElementById('qrcode').innerHTML = '&#10003;';
// Stop polling — connected.
setTimeout(() => {
fetch('/leads/verify/` + strconv.FormatInt(client.ClientID, 10) + `')
.then(r => r.json())
.then(v => {
var msg = 'WhatsApp: ' + (v.wa_phone || 'unknown');
if (v.match === 'yes') {
document.getElementById('status').textContent = msg + ' — matches ' + (v.client_phone || '') + ' ✓';
document.getElementById('status').style.color = '#28a745';
} else if (v.match === 'no') {
document.getElementById('status').textContent = msg + ' — does NOT match client phone ' + (v.client_phone || '') + ' ⚠';
document.getElementById('status').style.color = '#dc3545';
} else {
document.getElementById('status').textContent = msg + ' (client phone unknown — verify manually)';
}
})
.catch(() => {
document.getElementById('status').textContent = 'Connected! (could not verify phone)';
});
}, 1500);
} else if (data.status === 'error') {
document.getElementById('status').textContent = 'Error: ' + (data.error || 'Unknown') + ' — retrying...';
// Back off longer on error to let server recover.
setTimeout(pollQR, 8000);
} else {
document.getElementById('status').textContent = 'Status: ' + data.status;
@@ -228,7 +252,7 @@ func LeadsConnectPage(w http.ResponseWriter, r *http.Request) {
}
pollQR();
</script>
<p><a href="/clients">Back to Clients</a></p>
<p><a href="/">Back to Home</a> | <a href="/clients">Back to Clients</a></p>
</body></html>`))
}
@@ -237,46 +261,44 @@ func jsonEscape(s string) string {
return string(b)
}
func LeadsQR(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
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(DB, accountID, clientID)
client, err := db.GetClientByID(a.DB, accountID, clientID)
if err != nil {
w.Header().Set("Content-Type", "application/json")
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 WAConnector == nil {
w.Header().Set("Content-Type", "application/json")
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 := WAConnector.IsConnected(r.Context(), clientID)
connected, err := a.WAConnector.IsConnected(r.Context(), clientID)
if err != nil {
w.Header().Set("Content-Type", "application/json")
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")
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")
w.Header().Set("Content-Type", "application/json; charset=utf-8")
log.Printf("QR: Starting Connect for client %d", clientID)
// Use context.Background() so the WA session goroutine outlives this HTTP request.
// The handler returns after the first QR frame; subsequent polls reuse the same session.
qrChan, err := WAConnector.Connect(context.Background(), 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()) + `}`))
@@ -311,3 +333,52 @@ func LeadsQR(w http.ResponseWriter, r *http.Request) {
}
}
func (a *App) VerifyLead(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID, _ := strconv.ParseInt(chi.URLParam(r, "client_id"), 10, 64)
client, err := db.GetClientByID(a.DB, accountID, clientID)
if err != nil {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(`{"status":"error","error":"client not found"}`))
return
}
match := "unknown"
if client.WhatsAppNumber != "" && client.Phone != "" {
cleanWA := strings.TrimPrefix(client.WhatsAppNumber, "+")
cleanClient := strings.TrimPrefix(client.Phone, "+")
if cleanWA == cleanClient {
match = "yes"
} else {
match = "no"
}
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(`{"status":"ok","wa_phone":"` + jsonEscape(client.WhatsAppNumber) + `","client_phone":"` + jsonEscape(client.Phone) + `","match":"` + match + `","client_name":"` + jsonEscape(client.Name) + `"}`))
}
// --- package-level shims kept for existing tests ---
func ListLeads(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListLeads(w, r)
}
func UpdateLead(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateLead(w, r)
}
func DeleteLead(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteLead(w, r)
}
func LeadsConnectPage(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).LeadsConnectPage(w, r)
}
func LeadsQR(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).LeadsQR(w, r)
}
func VerifyLead(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).VerifyLead(w, r)
}

61
apps/go-crm/internal/handlers/payments.go
View File

@@ -10,8 +10,8 @@ import (
"github.com/go-chi/chi/v5"
)
func ListPayments(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) ListPayments(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -23,19 +23,19 @@ func ListPayments(w http.ResponseWriter, r *http.Request) {
limit = 20
}
payments, err := db.ListPayments(DB, clientID, limit, offset)
payments, err := db.ListPayments(a.DB, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
clients, err := db.ListClients(DB, accountID, limit, offset)
clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
customers, err := db.ListCustomers(DB, accountID, clientID, limit, offset)
customers, err := db.ListCustomers(a.DB, accountID, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
@@ -53,7 +53,7 @@ func ListPayments(w http.ResponseWriter, r *http.Request) {
customerNames[cu.CustomerID] = cu.Name
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/htmx.org@1.9.10"></script><style>.edit-row{display:none}</style></head><body><h1>Payments</h1><button class="btn" onclick="document.getElementById('paymentForm').style.display='block'">Add Payment</button><div id="paymentForm" style="display:none; margin-top:1rem;"><form hx-post="/payments" hx-target="#paymentList"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><select name="customer_id" required><option value="">Select Customer</option>` + customerOptions + `</select><input type="checkbox" name="has_paid"><label>Paid</label><input type="number" name="amount" placeholder="Amount" step="0.01"><input type="date" name="payment_date"><select name="payment_method"><option value="">Select Payment Method</option><option value="PIX">PIX</option><option value="Dinheiro">Dinheiro</option><option value="Débito">Débito</option><option value="Crédito à Vista">Crédito à Vista</option><option value="Parcelado">Parcelado</option><option value="Boleto">Boleto</option><option value="Transferência Bancária">Transferência Bancária</option></select><button type="submit">Add</button></form></div><table><thead><tr><th>Client</th><th>Customer</th><th>Amount</th><th>Paid</th><th>Date</th><th>Method</th><th>Actions</th></tr></thead><tbody id="paymentList">`))
for _, p := range payments {
paid := "No"
@@ -73,8 +73,8 @@ func ListPayments(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`</tbody></table></body></html>`))
}
func CreatePayment(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
func (a *App) CreatePayment(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -97,7 +97,7 @@ func CreatePayment(w http.ResponseWriter, r *http.Request) {
CreatedAt: time.Now().Unix(),
}
if err := payment.Create(DB); err != nil {
if err := payment.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
@@ -105,8 +105,8 @@ func CreatePayment(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true")
}
func ViewPayment(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
func (a *App) ViewPayment(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -114,19 +114,19 @@ func ViewPayment(w http.ResponseWriter, r *http.Request) {
id, _ := strconv.ParseInt(r.URL.Query().Get("id"), 10, 64)
var p db.Payment
var hasPaid int
err := DB.QueryRow("SELECT payment_id, client_id, customer_id, schedule_id, has_paid, amount, payment_date, payment_method, created_at FROM payments WHERE payment_id = ?", id).Scan(&p.PaymentID, &p.ClientID, &p.CustomerID, &p.ScheduleID, &hasPaid, &p.Amount, &p.PaymentDate, &p.PaymentMethod, &p.CreatedAt)
err := a.DB.QueryRow("SELECT payment_id, client_id, customer_id, schedule_id, has_paid, amount, payment_date, payment_method, created_at FROM payments WHERE payment_id = ?", id).Scan(&p.PaymentID, &p.ClientID, &p.CustomerID, &p.ScheduleID, &hasPaid, &p.Amount, &p.PaymentDate, &p.PaymentMethod, &p.CreatedAt)
if err != nil {
http.Error(w, "Payment not found", http.StatusNotFound)
return
}
p.HasPaid = hasPaid == 1
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><body><h1>Payment</h1><p>Amount: ` + strconv.FormatFloat(p.Amount, 'f', 2, 64) + `</p><p>Paid: ` + strconv.FormatBool(p.HasPaid) + `</p><p>Method: ` + p.PaymentMethod + `</p><a href="/payments">Back</a></body></html>`))
}
func UpdatePayment(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
func (a *App) UpdatePayment(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -137,7 +137,7 @@ func UpdatePayment(w http.ResponseWriter, r *http.Request) {
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
amount, _ := strconv.ParseFloat(r.FormValue("amount"), 64)
hasPaid := r.FormValue("has_paid") == "on"
_, err := DB.Exec("UPDATE payments SET client_id=?, customer_id=?, has_paid=?, amount=?, payment_date=?, payment_method=? WHERE payment_id=?", clientID, customerID, hasPaid, amount, r.FormValue("payment_date"), r.FormValue("payment_method"), id)
_, err := a.DB.Exec("UPDATE payments SET client_id=?, customer_id=?, has_paid=?, amount=?, payment_date=?, payment_method=? WHERE payment_id=?", clientID, customerID, hasPaid, amount, r.FormValue("payment_date"), r.FormValue("payment_method"), id)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
@@ -145,19 +145,30 @@ func UpdatePayment(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true")
}
func DeletePayment(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
func (a *App) DeletePayment(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
id, _ := strconv.ParseInt(r.URL.Query().Get("id"), 10, 64)
DB.Exec("DELETE FROM payments WHERE payment_id = ?", id)
a.DB.Exec("DELETE FROM payments WHERE payment_id = ?", id)
}
func boolToStr(b bool) string {
if b {
return "Yes"
}
return "No"
}
// --- package-level shims kept for existing tests ---
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)
}

161
apps/go-crm/internal/handlers/questions.go
View File

@@ -10,8 +10,8 @@ import (
"github.com/go-chi/chi/v5"
)
func ListQuestions(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) ListQuestions(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -23,19 +23,19 @@ func ListQuestions(w http.ResponseWriter, r *http.Request) {
limit = 20
}
questions, err := db.ListQuestions(DB, clientID, limit, offset)
questions, err := db.ListQuestions(a.DB, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
clients, err := db.ListClients(DB, accountID, limit, offset)
clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
customers, err := db.ListCustomers(DB, accountID, clientID, limit, offset)
customers, err := db.ListCustomers(a.DB, accountID, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
@@ -53,7 +53,7 @@ func ListQuestions(w http.ResponseWriter, r *http.Request) {
customerNames[cu.CustomerID] = cu.Name
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/htmx.org@1.9.10"></script><style>.edit-row{display:none}</style></head><body><h1>Questions</h1><button class="btn" onclick="document.getElementById('questionForm').style.display='block'">Add Question</button><div id="questionForm" style="display:none; margin-top:1rem;"><form hx-post="/questions" hx-target="#questionList"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><select name="customer_id" required><option value="">Select Customer</option>` + customerOptions + `</select><textarea name="question" placeholder="Question" required></textarea><select name="status"><option value="pending">Pending</option><option value="answered">Answered</option></select><button type="submit">Add</button></form></div><table><thead><tr><th>Client</th><th>Customer</th><th>Question</th><th>Status</th><th>Actions</th></tr></thead><tbody id="questionList">`))
for _, q := range questions {
clientName := clientNames[q.ClientID]
@@ -69,8 +69,8 @@ func ListQuestions(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`</tbody></table></body></html>`))
}
func CreateQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
func (a *App) CreateQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -81,13 +81,13 @@ func CreateQuestion(w http.ResponseWriter, r *http.Request) {
question := db.Question{
ClientID: clientID,
CustomerID: customerID,
Question: r.FormValue("question"),
Timestamp: time.Now().Unix(),
Status: r.FormValue("status"),
CreatedAt: time.Now().Unix(),
Question: r.FormValue("question"),
Timestamp: time.Now().Unix(),
Status: r.FormValue("status"),
CreatedAt: time.Now().Unix(),
}
if err := question.Create(DB); err != nil {
if err := question.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
@@ -95,26 +95,26 @@ func CreateQuestion(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true")
}
func ViewQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
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 := DB.QueryRow("SELECT question_id, client_id, customer_id, question, timestamp, status, created_at FROM questions WHERE question_id = ?", id).Scan(&q.QuestionID, &q.ClientID, &q.CustomerID, &q.Question, &q.Timestamp, &q.Status, &q.CreatedAt)
err := a.DB.QueryRow("SELECT question_id, client_id, customer_id, question, timestamp, status, created_at FROM questions WHERE question_id = ?", id).Scan(&q.QuestionID, &q.ClientID, &q.CustomerID, &q.Question, &q.Timestamp, &q.Status, &q.CreatedAt)
if err != nil {
http.Error(w, "Question not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><body><h1>Question</h1><p>Client ID: ` + strconv.FormatInt(q.ClientID, 10) + `</p><p>Customer ID: ` + strconv.FormatInt(q.CustomerID, 10) + `</p><p>Question: ` + q.Question + `</p><p>Status: ` + q.Status + `</p><a href="/questions">Back</a></body></html>`))
}
func UpdateQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
func (a *App) UpdateQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -123,7 +123,7 @@ func UpdateQuestion(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
_, err := DB.Exec("UPDATE questions SET client_id=?, customer_id=?, question=?, status=? WHERE question_id=?", clientID, customerID, r.FormValue("question"), r.FormValue("status"), id)
_, err := a.DB.Exec("UPDATE questions SET client_id=?, customer_id=?, question=?, status=? WHERE question_id=?", clientID, customerID, r.FormValue("question"), r.FormValue("status"), id)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
@@ -131,18 +131,18 @@ func UpdateQuestion(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true")
}
func DeleteQuestion(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
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)
DB.Exec("DELETE FROM questions WHERE question_id = ?", id)
a.DB.Exec("DELETE FROM questions WHERE question_id = ?", id)
}
func ListAnswers(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) ListAnswers(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -154,13 +154,13 @@ func ListAnswers(w http.ResponseWriter, r *http.Request) {
limit = 20
}
answers, err := db.ListAnswersWithDetails(DB, accountID, questionID, limit, offset)
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(DB, 0, limit, offset)
questions, err := db.ListQuestions(a.DB, 0, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
@@ -173,7 +173,7 @@ func ListAnswers(w http.ResponseWriter, r *http.Request) {
questionText[q.QuestionID] = q.Question
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html>
<html>
<head>
@@ -202,19 +202,19 @@ func ListAnswers(w http.ResponseWriter, r *http.Request) {
</thead>
<tbody id="answerList">
`))
for _, a := range answers {
qText := a.QuestionText
for _, a2 := range answers {
qText := a2.QuestionText
if qText == "" {
qText = questionText[a.QuestionID]
qText = questionText[a2.QuestionID]
if qText == "" {
qText = strconv.FormatInt(a.QuestionID, 10)
qText = strconv.FormatInt(a2.QuestionID, 10)
}
}
clientName := a.ClientName
clientName := a2.ClientName
if clientName == "" {
clientName = strconv.FormatInt(a.ClientID, 10)
clientName = strconv.FormatInt(a2.ClientID, 10)
}
customerName := a.CustomerName
customerName := a2.CustomerName
if customerName == "" {
customerName = "Unknown"
}
@@ -223,24 +223,24 @@ func ListAnswers(w http.ResponseWriter, r *http.Request) {
<td>` + clientName + `</td>
<td>` + customerName + `</td>
<td>` + qText + `</td>
<td>` + a.Answer + `</td>
<td>` + a.Status + `</td>
<td>` + a2.Answer + `</td>
<td>` + a2.Status + `</td>
<td>
<a href="/answers/` + strconv.FormatInt(a.AnswerID, 10) + `">View</a>
<button type="button" onclick="document.getElementById('editA`+strconv.FormatInt(a.AnswerID, 10)+`').style.display='table-row'">Edit</button>
<form method="DELETE" style="display:inline" hx-delete="/answers/`+strconv.FormatInt(a.AnswerID, 10)+`" hx-target="closest tr">
<a href="/answers/` + strconv.FormatInt(a2.AnswerID, 10) + `">View</a>
<button type="button" onclick="document.getElementById('editA` + strconv.FormatInt(a2.AnswerID, 10) + `').style.display='table-row'">Edit</button>
<form method="DELETE" style="display:inline" hx-delete="/answers/` + strconv.FormatInt(a2.AnswerID, 10) + `" hx-target="closest tr">
<button type="submit">Delete</button>
</form>
</td>
</tr>
<tr id="editA`+strconv.FormatInt(a.AnswerID, 10)+`" class="edit-row" style="display:none">
<tr id="editA` + strconv.FormatInt(a2.AnswerID, 10) + `" class="edit-row" style="display:none">
<td colspan="6">
<form hx-put="/answers/`+strconv.FormatInt(a.AnswerID, 10)+`" hx-target="#answerList" hx-swap="innerHTML">
<form hx-put="/answers/` + strconv.FormatInt(a2.AnswerID, 10) + `" hx-target="#answerList" hx-swap="innerHTML">
<select name="question_id">
<option value="`+strconv.FormatInt(a.QuestionID, 10)+`">`+qText+`</option>
`+questionOptions+`
<option value="` + strconv.FormatInt(a2.QuestionID, 10) + `">` + qText + `</option>
` + questionOptions + `
</select>
<textarea name="answer">`+a.Answer+`</textarea>
<textarea name="answer">` + a2.Answer + `</textarea>
<button type="submit">Save</button>
</form>
</td>
@@ -253,8 +253,8 @@ func ListAnswers(w http.ResponseWriter, r *http.Request) {
</html>`))
}
func CreateAnswer(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) CreateAnswer(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -263,14 +263,14 @@ func CreateAnswer(w http.ResponseWriter, r *http.Request) {
questionID, _ := strconv.ParseInt(r.FormValue("question_id"), 10, 64)
var clientID int64
err := DB.QueryRow("SELECT client_id FROM questions WHERE question_id = ?", questionID).Scan(&clientID)
err := a.DB.QueryRow("SELECT client_id FROM questions WHERE question_id = ?", questionID).Scan(&clientID)
if err != nil {
http.Error(w, "Question not found", http.StatusBadRequest)
return
}
var checkID int64
err = DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID)
err = a.DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID)
if err != nil {
http.Error(w, "Invalid question", http.StatusBadRequest)
return
@@ -282,10 +282,10 @@ func CreateAnswer(w http.ResponseWriter, r *http.Request) {
Answer: r.FormValue("answer"),
Timestamp: time.Now().Unix(),
Status: "active",
CreatedAt: time.Now().Unix(),
CreatedAt: time.Now().Unix(),
}
if err := answer.Create(DB); err != nil {
if err := answer.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
@@ -293,26 +293,26 @@ func CreateAnswer(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true")
}
func ViewAnswer(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
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 a db.Answer
err := DB.QueryRow("SELECT answer_id, client_id, question_id, answer, timestamp, status, created_at FROM answers WHERE answer_id = ?", id).Scan(&a.AnswerID, &a.ClientID, &a.QuestionID, &a.Answer, &a.Timestamp, &a.Status, &a.CreatedAt)
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
}
w.Header().Set("Content-Type", "text/html")
w.Write([]byte(`<!DOCTYPE html><body><h1>Answer</h1><p>Question ID: ` + strconv.FormatInt(a.QuestionID, 10) + `</p><p>Answer: ` + a.Answer + `</p><a href="/answers">Back</a></body></html>`))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><body><h1>Answer</h1><p>Question ID: ` + strconv.FormatInt(ans.QuestionID, 10) + `</p><p>Answer: ` + ans.Answer + `</p><a href="/answers">Back</a></body></html>`))
}
func UpdateAnswer(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
func (a *App) UpdateAnswer(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -320,7 +320,7 @@ func UpdateAnswer(w http.ResponseWriter, r *http.Request) {
id, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
r.ParseForm()
questionID, _ := strconv.ParseInt(r.FormValue("question_id"), 10, 64)
_, err := DB.Exec("UPDATE answers SET question_id=?, answer=? WHERE answer_id=?", questionID, r.FormValue("answer"), id)
_, err := a.DB.Exec("UPDATE answers SET question_id=?, answer=? WHERE answer_id=?", questionID, r.FormValue("answer"), id)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
@@ -328,12 +328,45 @@ func UpdateAnswer(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true")
}
func DeleteAnswer(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
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)
DB.Exec("DELETE FROM answers WHERE answer_id = ?", id)
}
a.DB.Exec("DELETE FROM answers WHERE answer_id = ?", id)
}
// --- package-level shims kept for existing tests ---
func ListQuestions(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListQuestions(w, r)
}
func CreateQuestion(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreateQuestion(w, r)
}
func ViewQuestion(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewQuestion(w, r)
}
func UpdateQuestion(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateQuestion(w, r)
}
func DeleteQuestion(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteQuestion(w, r)
}
func ListAnswers(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListAnswers(w, r)
}
func CreateAnswer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreateAnswer(w, r)
}
func ViewAnswer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewAnswer(w, r)
}
func UpdateAnswer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateAnswer(w, r)
}
func DeleteAnswer(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteAnswer(w, r)
}

219
apps/go-crm/internal/handlers/report.go Normal file
View File

@@ -0,0 +1,219 @@
package handlers
import (
"fmt"
"math"
"net/http"
"time"
)
type serviceCount struct {
Name string
Count int
}
type reportData struct {
TotalLeads int
ServiceCounts []serviceCount
StatusCounts []serviceCount
TotalScheduled int
ConversionRate float64
TotalRevenue float64
TotalSales int
AverageTicket float64
TopServices []serviceCount
MonthLabel string
}
// MonthlyReport renders the monthly performance report for the current month.
// GET /report
func (a *App) MonthlyReport(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
clientID := a.clientIDForAccount(accountID)
if clientID == 0 {
http.Error(w, "No client found for account", http.StatusBadRequest)
return
}
now := time.Now()
monthStart := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location()).Unix()
nextMonth := time.Date(now.Year(), now.Month()+1, 1, 0, 0, 0, 0, now.Location()).Unix()
rd := reportData{MonthLabel: now.Format("January 2006")}
a.DB.QueryRow(
"SELECT COUNT(*) FROM leads WHERE client_id = ? AND created_at >= ? AND created_at < ?",
clientID, monthStart, nextMonth,
).Scan(&rd.TotalLeads)
rows, err := a.DB.Query(
`SELECT service_interest, COUNT(*) as cnt FROM leads
WHERE client_id = ? AND created_at >= ? AND created_at < ?
GROUP BY service_interest ORDER BY cnt DESC`,
clientID, monthStart, nextMonth,
)
if err == nil {
defer rows.Close()
for rows.Next() {
var sc serviceCount
rows.Scan(&sc.Name, &sc.Count)
rd.ServiceCounts = append(rd.ServiceCounts, sc)
}
}
statusRows, err := a.DB.Query(
`SELECT status, COUNT(*) as cnt FROM leads
WHERE client_id = ? AND created_at >= ? AND created_at < ?
GROUP BY status ORDER BY cnt DESC`,
clientID, monthStart, nextMonth,
)
if err == nil {
defer statusRows.Close()
for statusRows.Next() {
var sc serviceCount
statusRows.Scan(&sc.Name, &sc.Count)
rd.StatusCounts = append(rd.StatusCounts, sc)
}
}
a.DB.QueryRow(
"SELECT COUNT(*) FROM leads WHERE client_id = ? AND status = 'Agendou' AND created_at >= ? AND created_at < ?",
clientID, monthStart, nextMonth,
).Scan(&rd.TotalScheduled)
if rd.TotalLeads > 0 {
rd.ConversionRate = math.Round(float64(rd.TotalScheduled)/float64(rd.TotalLeads)*100*10) / 10
}
a.DB.QueryRow(
`SELECT COALESCE(SUM(amount),0), COUNT(*) FROM payments
WHERE client_id = ? AND has_paid = 1 AND created_at >= ? AND created_at < ?`,
clientID, monthStart, nextMonth,
).Scan(&rd.TotalRevenue, &rd.TotalSales)
if rd.TotalSales > 0 {
rd.AverageTicket = math.Round(rd.TotalRevenue/float64(rd.TotalSales)*100) / 100
}
topRows, err := a.DB.Query(
`SELECT s.name, COUNT(*) as cnt
FROM payments p
JOIN scheduling sch ON p.schedule_id = sch.schedule_id
JOIN services s ON sch.service_id = s.service_id
WHERE p.client_id = ? AND p.has_paid = 1 AND p.created_at >= ? AND p.created_at < ?
GROUP BY s.name ORDER BY cnt DESC LIMIT 5`,
clientID, monthStart, nextMonth,
)
if err == nil {
defer topRows.Close()
for topRows.Next() {
var sc serviceCount
topRows.Scan(&sc.Name, &sc.Count)
rd.TopServices = append(rd.TopServices, sc)
}
}
var reviewCount int
a.DB.QueryRow("SELECT COUNT(*) FROM leads WHERE client_id = ? AND needs_review = 1", clientID).Scan(&reviewCount)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprintf(w, `<!DOCTYPE html>
<html>
<head>
<title>Monthly Report — %s</title>
<style>
body { font-family: sans-serif; padding: 1rem; max-width: 900px; margin: 0 auto; }
h1, h2 { color: #333; }
.grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
.card { border: 1px solid #ddd; border-radius: 8px; padding: 1rem; background: #fafafa; }
.card .value { font-size: 2rem; font-weight: bold; color: #2c7be5; }
.card .label { color: #666; font-size: 0.9rem; margin-top: 0.25rem; }
table { border-collapse: collapse; width: 100%%; margin-bottom: 1.5rem; }
th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
th { background: #f5f5f5; }
.badge { background: #dc3545; color: #fff; border-radius: 1rem; padding: 0.2rem 0.6rem; font-size: 0.8rem; }
nav { margin-bottom: 1rem; }
</style>
</head>
<body>
<h1>Monthly Report — %s</h1>
<nav>
<a href="/">Home</a> |
<a href="/leads/review">Review Queue <span class="badge">%d</span></a> |
<a href="/leads/all">All Leads</a> |
<a href="/leads/keywords">Keyword Mapping</a>
</nav>
<h2>Overview</h2>
<div class="grid">
<div class="card"><div class="value">%d</div><div class="label">Total Leads</div></div>
<div class="card"><div class="value">%d</div><div class="label">Agendamentos</div></div>
<div class="card"><div class="value">%.1f%%</div><div class="label">Conversion Rate</div></div>
</div>
<h2>Revenue</h2>
<div class="grid">
<div class="card"><div class="value">R$ %.2f</div><div class="label">Total Month Revenue</div></div>
<div class="card"><div class="value">%d</div><div class="label">Total Sales</div></div>
<div class="card"><div class="value">R$ %.2f</div><div class="label">Average Ticket</div></div>
</div>
<h2>Leads by Service Interest</h2>
%s
<h2>Leads by Status</h2>
%s
<h2>Top 5 Services Sold</h2>
%s
</body></html>`,
rd.MonthLabel,
rd.MonthLabel,
reviewCount,
rd.TotalLeads, rd.TotalScheduled, rd.ConversionRate,
rd.TotalRevenue, rd.TotalSales, rd.AverageTicket,
renderServiceTable(rd.ServiceCounts, rd.TotalLeads),
renderServiceTable(rd.StatusCounts, rd.TotalLeads),
renderTopServicesTable(rd.TopServices),
)
}
func renderServiceTable(counts []serviceCount, total int) string {
if len(counts) == 0 {
return `<p style="color:#888">No data for this month.</p>`
}
out := `<table><thead><tr><th>Name</th><th>Quantity</th><th>%</th></tr></thead><tbody>`
for _, sc := range counts {
pct := 0.0
if total > 0 {
pct = math.Round(float64(sc.Count)/float64(total)*100*10) / 10
}
out += fmt.Sprintf(`<tr><td>%s</td><td>%d</td><td>%.1f%%</td></tr>`,
htmlEscape(sc.Name), sc.Count, pct)
}
out += `</tbody></table>`
return out
}
func renderTopServicesTable(counts []serviceCount) string {
if len(counts) == 0 {
return `<p style="color:#888">No sales data for this month.</p>`
}
out := `<table><thead><tr><th>Service</th><th>Sales</th></tr></thead><tbody>`
for _, sc := range counts {
out += fmt.Sprintf(`<tr><td>%s</td><td>%d</td></tr>`, htmlEscape(sc.Name), sc.Count)
}
out += `</tbody></table>`
return out
}
// --- package-level shim kept for existing tests ---
func MonthlyReport(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).MonthlyReport(w, r)
}

68
apps/go-crm/internal/handlers/scheduling.go
View File

@@ -10,8 +10,8 @@ import (
"github.com/go-chi/chi/v5"
)
func ListSchedules(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) ListSchedules(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -24,25 +24,25 @@ func ListSchedules(w http.ResponseWriter, r *http.Request) {
limit = 20
}
schedules, err := db.ListSchedules(DB, clientID, customerID, limit, offset)
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(DB, accountID, limit, offset)
clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
customers, err := db.ListCustomers(DB, accountID, clientID, limit, offset)
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(DB, accountID, clientID, limit, offset)
services, err := db.ListServices(a.DB, accountID, clientID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
@@ -65,7 +65,7 @@ func ListSchedules(w http.ResponseWriter, r *http.Request) {
serviceNames[s.ServiceID] = s.Name
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/htmx.org@1.9.10"></script><style>.edit-row{display:none}</style></head><body><h1>Scheduling</h1><button class="btn" onclick="document.getElementById('scheduleForm').style.display='block'">Add Schedule</button><div id="scheduleForm" style="display:none; margin-top:1rem;"><form hx-post="/scheduling" hx-target="#scheduleList"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><select name="customer_id" required><option value="">Select Customer</option>` + customerOptions + `</select><select name="service_id" required><option value="">Select Service</option>` + serviceOptions + `</select><input type="date" name="plan_date"><input type="time" name="time"><select name="status"><option value="pending">Pending</option><option value="confirmed">Confirmed</option><option value="cancelled">Cancelled</option></select><button type="submit">Add</button></form></div><table><thead><tr><th>Client</th><th>Customer</th><th>Service</th><th>Date</th><th>Hour</th><th>Status</th><th>Actions</th></tr></thead><tbody id="scheduleList">`))
for _, s := range schedules {
clientName := clientNames[s.ClientID]
@@ -85,8 +85,8 @@ func ListSchedules(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`</tbody></table></body></html>`))
}
func CreateSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
func (a *App) CreateSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -96,16 +96,16 @@ func CreateSchedule(w http.ResponseWriter, r *http.Request) {
customerID, _ := strconv.ParseInt(r.FormValue("customer_id"), 10, 64)
serviceID, _ := strconv.ParseInt(r.FormValue("service_id"), 10, 64)
schedule := db.Schedule{
ClientID: clientID,
ClientID: clientID,
CustomerID: customerID,
ServiceID: serviceID,
PlanDate: r.FormValue("plan_date"),
Time: r.FormValue("time"),
Status: r.FormValue("status"),
CreatedAt: time.Now().Unix(),
Time: r.FormValue("time"),
Status: r.FormValue("status"),
CreatedAt: time.Now().Unix(),
}
if err := schedule.Create(DB); err != nil {
if err := schedule.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
@@ -113,26 +113,26 @@ func CreateSchedule(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true")
}
func ViewSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
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 := DB.QueryRow("SELECT schedule_id, client_id, customer_id, service_id, plan_date, time, status, created_at FROM scheduling WHERE schedule_id = ?", id).Scan(&sch.ScheduleID, &sch.ClientID, &sch.CustomerID, &sch.ServiceID, &sch.PlanDate, &sch.Time, &sch.Status, &sch.CreatedAt)
err := a.DB.QueryRow("SELECT schedule_id, client_id, customer_id, service_id, plan_date, time, status, created_at FROM scheduling WHERE schedule_id = ?", id).Scan(&sch.ScheduleID, &sch.ClientID, &sch.CustomerID, &sch.ServiceID, &sch.PlanDate, &sch.Time, &sch.Status, &sch.CreatedAt)
if err != nil {
http.Error(w, "Schedule not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><body><h1>Schedule</h1><p>Client ID: ` + strconv.FormatInt(sch.ClientID, 10) + `</p><p>Customer ID: ` + strconv.FormatInt(sch.CustomerID, 10) + `</p><p>Service ID: ` + strconv.FormatInt(sch.ServiceID, 10) + `</p><p>Date: ` + sch.PlanDate + `</p><p>Time: ` + sch.Time + `</p><p>Status: ` + sch.Status + `</p><a href="/scheduling">Back</a></body></html>`))
}
func UpdateSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
func (a *App) UpdateSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -142,7 +142,7 @@ func UpdateSchedule(w http.ResponseWriter, r *http.Request) {
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 := DB.Exec("UPDATE scheduling SET client_id=?, customer_id=?, service_id=?, plan_date=?, time=?, status=? WHERE schedule_id=?", clientID, customerID, serviceID, r.FormValue("plan_date"), r.FormValue("time"), r.FormValue("status"), id)
_, err := a.DB.Exec("UPDATE scheduling SET client_id=?, customer_id=?, service_id=?, plan_date=?, time=?, status=? WHERE schedule_id=?", clientID, customerID, serviceID, r.FormValue("plan_date"), r.FormValue("time"), r.FormValue("status"), id)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
@@ -150,12 +150,30 @@ func UpdateSchedule(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true")
}
func DeleteSchedule(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
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)
DB.Exec("DELETE FROM scheduling WHERE schedule_id = ?", id)
}
a.DB.Exec("DELETE FROM scheduling WHERE schedule_id = ?", id)
}
// --- package-level shims kept for existing tests ---
func ListSchedules(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListSchedules(w, r)
}
func CreateSchedule(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreateSchedule(w, r)
}
func ViewSchedule(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewSchedule(w, r)
}
func UpdateSchedule(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateSchedule(w, r)
}
func DeleteSchedule(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteSchedule(w, r)
}

66
apps/go-crm/internal/handlers/services.go
View File

@@ -10,8 +10,8 @@ import (
"github.com/go-chi/chi/v5"
)
func ListServices(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) ListServices(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -23,13 +23,13 @@ func ListServices(w http.ResponseWriter, r *http.Request) {
limit = 20
}
services, err := db.ListServices(DB, accountID, clientID, limit, offset)
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(DB, accountID, limit, offset)
clients, err := db.ListClients(a.DB, accountID, limit, offset)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
@@ -40,7 +40,7 @@ func ListServices(w http.ResponseWriter, r *http.Request) {
clientOptions += `<option value="` + strconv.FormatInt(c.ClientID, 10) + `">` + c.Name + `</option>`
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><html><head><script src="https://unpkg.com/htmx.org@1.9.10"></script></head><body><h1>Services</h1><button class="btn" onclick="document.getElementById('serviceForm').style.display='block'">Add Service</button><div id="serviceForm" style="display:none; margin-top:1rem;"><form hx-post="/services" hx-target="#serviceList"><input type="text" name="name" placeholder="Service Name" required><input type="number" name="price" placeholder="Price" step="0.01"><textarea name="description" placeholder="Description"></textarea><input type="text" name="duration" placeholder="Duration"><select name="client_id" required><option value="">Select Client</option>` + clientOptions + `</select><button type="submit">Add</button></form></div><table><thead><tr><th>Name</th><th>Price</th><th>Duration</th><th>Actions</th></tr></thead><tbody id="serviceList">`))
for _, s := range services {
w.Write([]byte(`<tr><td>` + s.Name + `</td><td>` + strconv.FormatFloat(s.Price, 'f', 2, 64) + `</td><td>` + s.Duration + `</td><td><a href="/services/` + strconv.FormatInt(s.ServiceID, 10) + `">View</a><button type="button" onclick="document.getElementById('editServ` + strconv.FormatInt(s.ServiceID, 10) + `').style.display='table-row'">Edit</button><form method="DELETE" style="display:inline" hx-delete="/services/` + strconv.FormatInt(s.ServiceID, 10) + `" hx-target="closest tr"><button type="submit">Delete</button></form></td></tr><tr id="editServ` + strconv.FormatInt(s.ServiceID, 10) + `" style="display:none"><td colspan="4"><form hx-put="/services/` + strconv.FormatInt(s.ServiceID, 10) + `" hx-target="#serviceList" hx-swap="innerHTML"><input type="text" name="name" value="` + s.Name + `"><input type="number" name="price" value="` + strconv.FormatFloat(s.Price, 'f', 2, 64) + `"><textarea name="description">` + s.Description + `</textarea><input type="text" name="duration" value="` + s.Duration + `"><select name="client_id"><option value="` + strconv.FormatInt(s.ClientID, 10) + `">` + s.Name + `</option>` + clientOptions + `</select><button type="submit">Save</button></form></td></tr>`))
@@ -48,8 +48,8 @@ func ListServices(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`</tbody></table></body></html>`))
}
func CreateService(w http.ResponseWriter, r *http.Request) {
accountID, ok := requireAuth(w, r)
func (a *App) CreateService(w http.ResponseWriter, r *http.Request) {
accountID, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -58,7 +58,7 @@ func CreateService(w http.ResponseWriter, r *http.Request) {
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
var checkID int64
err := DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID)
err := a.DB.QueryRow("SELECT client_id FROM clients WHERE client_id = ? AND account_id = ?", clientID, accountID).Scan(&checkID)
if err != nil {
http.Error(w, "Invalid client", http.StatusBadRequest)
return
@@ -67,14 +67,14 @@ func CreateService(w http.ResponseWriter, r *http.Request) {
price, _ := strconv.ParseFloat(r.FormValue("price"), 64)
service := db.Service{
ClientID: clientID,
Name: r.FormValue("name"),
Price: price,
Name: r.FormValue("name"),
Price: price,
Description: r.FormValue("description"),
Duration: r.FormValue("duration"),
CreatedAt: time.Now().Unix(),
Duration: r.FormValue("duration"),
CreatedAt: time.Now().Unix(),
}
if err := service.Create(DB); err != nil {
if err := service.Create(a.DB); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
@@ -82,26 +82,26 @@ func CreateService(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true")
}
func ViewService(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
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 := DB.QueryRow("SELECT service_id, client_id, name, price, description, duration, created_at FROM services WHERE service_id = ?", id).Scan(&s.ServiceID, &s.ClientID, &s.Name, &s.Price, &s.Description, &s.Duration, &s.CreatedAt)
err := a.DB.QueryRow("SELECT service_id, client_id, name, price, description, duration, created_at FROM services WHERE service_id = ?", id).Scan(&s.ServiceID, &s.ClientID, &s.Name, &s.Price, &s.Description, &s.Duration, &s.CreatedAt)
if err != nil {
http.Error(w, "Service not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "text/html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write([]byte(`<!DOCTYPE html><body><h1>` + s.Name + `</h1><p>Price: ` + strconv.FormatFloat(s.Price, 'f', 2, 64) + `</p><p>Description: ` + s.Description + `</p><p>Duration: ` + s.Duration + `</p><a href="/services">Back</a></body></html>`))
}
func UpdateService(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
func (a *App) UpdateService(w http.ResponseWriter, r *http.Request) {
_, ok := a.requireAuth(w, r)
if !ok {
return
}
@@ -110,7 +110,7 @@ func UpdateService(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
clientID, _ := strconv.ParseInt(r.FormValue("client_id"), 10, 64)
price, _ := strconv.ParseFloat(r.FormValue("price"), 64)
_, err := DB.Exec("UPDATE services SET client_id=?, name=?, price=?, description=?, duration=? WHERE service_id=?", clientID, r.FormValue("name"), price, r.FormValue("description"), r.FormValue("duration"), id)
_, err := a.DB.Exec("UPDATE services SET client_id=?, name=?, price=?, description=?, duration=? WHERE service_id=?", clientID, r.FormValue("name"), price, r.FormValue("description"), r.FormValue("duration"), id)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
@@ -118,12 +118,30 @@ func UpdateService(w http.ResponseWriter, r *http.Request) {
w.Header().Set("HX-Refresh", "true")
}
func DeleteService(w http.ResponseWriter, r *http.Request) {
_, ok := requireAuth(w, r)
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)
DB.Exec("DELETE FROM services WHERE service_id = ?", id)
}
a.DB.Exec("DELETE FROM services WHERE service_id = ?", id)
}
// --- package-level shims kept for existing tests ---
func ListServices(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ListServices(w, r)
}
func CreateService(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).CreateService(w, r)
}
func ViewService(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).ViewService(w, r)
}
func UpdateService(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).UpdateService(w, r)
}
func DeleteService(w http.ResponseWriter, r *http.Request) {
(&App{DB: DB, WAConnector: WAConnector}).DeleteService(w, r)
}

20
apps/go-crm/internal/handlers/setup.go
View File

@@ -5,10 +5,28 @@ import (
"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
@@ -16,4 +34,4 @@ func SetupHandlers(db *sql.DB, wa whatsapp.Connector) {
func getCurrentTimestamp() int64 {
return time.Now().Unix()
}
}

118
apps/go-crm/internal/handlers/status_test.go Normal file
View File

@@ -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 (?, ?, ?, ?)",
"test@example.com", "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 = ?", "test@example.com").Scan(&accountID)
if err != nil {
t.Fatalf("failed to get account id: %v", err)
}
_, err = testDB.Exec(
"INSERT INTO clients (account_id, name, phone, whatsapp_number, whatsapp_connected, created_at) VALUES (?, ?, ?, ?, ?, ?)",
accountID, "Connected Client", "+5521987654321", "+5521987654321", 1, time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create connected client: %v", err)
}
_, err = testDB.Exec(
"INSERT INTO clients (account_id, name, phone, whatsapp_number, whatsapp_connected, created_at) VALUES (?, ?, ?, ?, ?, ?)",
accountID, "Disconnected Client", "+5521987654322", "+5521987654322", 1, time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create disconnected client: %v", err)
}
_, err = testDB.Exec(
"INSERT INTO clients (account_id, name, phone, created_at) VALUES (?, ?, ?, ?)",
accountID, "No WhatsApp Client", "+5521987654323", time.Now().Unix(),
)
if err != nil {
t.Fatalf("failed to create no-wa client: %v", err)
}
sessionID := "test-session-status"
expires := time.Now().Add(time.Hour).Unix()
_, err = testDB.Exec(
"INSERT INTO sessions (session_id, account_id, expires) VALUES (?, ?, ?)",
sessionID, accountID, expires,
)
if err != nil {
t.Fatalf("failed to create session: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/clients", nil)
req.AddCookie(&http.Cookie{Name: "session", Value: sessionID})
w := httptest.NewRecorder()
ListClients(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", w.Code)
}
body := w.Body.String()
if !strings.Contains(body, "Connected Client") {
t.Error("expected to find connected client")
}
if !strings.Contains(body, "Disconnected Client") {
t.Error("expected to find disconnected client")
}
if !strings.Contains(body, "No WhatsApp Client") {
t.Error("expected to find no-wa client")
}
if !strings.Contains(body, "Connect") {
t.Error("expected Connect link for clients without active connection")
}
greenDot := `color:#28a745`
if !strings.Contains(body, greenDot) {
t.Error("expected green dot for connected client")
}
}

165
apps/go-crm/internal/handlers/viewclient_test.go Normal file
View File

@@ -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 (?, ?, ?, ?)",
"test@example.com", "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 = ?", "test@example.com").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 (?, ?, ?, ?)",
"test@example.com", "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 = ?", "test@example.com").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
apps/go-crm/internal/middleware/utf8.go Normal file
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
apps/go-crm/internal/parser/parser.go Normal file
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
apps/go-crm/internal/parser/parser_test.go Normal file
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
}{
{"5511999999999@s.whatsapp.net", "+5511999999999"},
{"5511999999999", "+5511999999999"},
{"+5511999999999", "+5511999999999"},
{"55 11 99999-9999", "+5511999999999"},
{"11999999999", "+11999999999"},
}
for _, c := range cases {
got := parser.NormalizePhone(c.raw)
if got != c.want {
t.Errorf("NormalizePhone(%q) = %q, want %q", c.raw, got, c.want)
}
}
}

1
apps/go-crm/internal/templates/layout.go
View File

@@ -52,6 +52,7 @@ func Layout(title, content string) *template.Template {
<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>

1
apps/go-crm/internal/whatsapp/connector.go
View File

@@ -24,6 +24,7 @@ type QRFrame struct {
type Contact struct {
Phone string
Name string
Message string // raw text of the first/incoming message
FromMe bool
Time time.Time
}

36
apps/go-crm/internal/whatsapp/postcontact_test.go Normal file
View File

@@ -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)
}
}

112
apps/go-crm/internal/whatsapp/whatsmeow.go
View File

@@ -9,6 +9,7 @@ import (
"log"
"net/http"
"strconv"
"strings"
"sync"
"time"
@@ -239,24 +240,50 @@ func (a *WhatsmeowAdapter) startQRSession(clientID int64) (<-chan QRFrame, error
}
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
}
if msg.Info.IsFromMe {
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
}
phone := msg.Info.Sender.String()
// 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,
FromMe: false,
Time: time.Now(),
Phone: phone,
Name: pushName,
Message: text,
FromMe: false,
Time: time.Now(),
}
a.postContact(a.appCtx, clientID, contact)
a.postContact(a.appCtx, clientID, contact, msg.Info.ID)
}
})
}
@@ -266,21 +293,35 @@ func (a *WhatsmeowAdapter) syncContacts(client *whatsmeow.Client, clientID int64
// Simplified for build - real implementation would use new API
}
func (a *WhatsmeowAdapter) postContact(ctx context.Context, clientID int64, contact Contact) {
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,
"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+"/customers", httpBody)
req.Header.Set("Content-Type", "application/json")
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}
httpClient.Do(req)
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) {
@@ -323,10 +364,25 @@ func (a *WhatsmeowAdapter) saveJIDOnConnect(client *whatsmeow.Client, clientID i
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
@@ -402,18 +458,32 @@ func (a *WhatsmeowAdapter) IsConnected(ctx context.Context, clientID int64) (boo
if a == nil {
return false, fmt.Errorf("adapter not initialized")
}
a.mu.RLock()
defer a.mu.RUnlock()
client, ok := a.clients[clientID]
if !ok {
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
}
if client == nil {
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
}
}
}
// IsLoggedIn() checks WhatsApp session authentication, not just WebSocket connectivity.
return client.IsLoggedIn(), nil
return false, nil
}