rogee
aeddedf2a3
Restructure the monorepo into clear top-level directories: - backend/: Go module root (cmd, internal, pkg, configs, migrations, docs/swagger, scripts, tests, go.mod, Makefile, .air.toml) - deploy/: Docker (Dockerfile, docker-compose*), quickstart, fluentd - docs/: project documentation + reports/ (moved from repo root) - AGENTS.md: new AI coding-agent guide at repo root Update all references to the new layout: - Dockerfile: COPY backend/go.mod, COPY backend/ (context = repo root) - docker-compose files: context ../.., dockerfile deploy/docker/Dockerfile, env_file ../../.env, volume mounts ../../backend:/app - deploy/quickstart/compose.yaml: dockerfile deploy/docker/Dockerfile - CI: working-directory: backend for go commands, file deploy/docker/Dockerfile, coverage path backend/coverage.out, health_check backend/scripts/ - backend/Makefile: docker target uses -f ../deploy/docker/Dockerfile ../ - README: architecture tree, quickstart, config paths updated Move root stray scripts (rename_models.*, run_m11_tests.sh, verify_build.sh, gorm_bool_main.go) to backend/scripts/legacy/. All moves via git mv to preserve history. Build, vet, SQLite tests, and docker compose config verified.
457 lines
14 KiB
Go
457 lines
14 KiB
Go
package v1
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
|
|
"github.com/gochat/gochat/internal/model"
|
|
"github.com/gochat/gochat/internal/service"
|
|
"github.com/gochat/gochat/pkg/pagination"
|
|
"github.com/gochat/gochat/pkg/response"
|
|
)
|
|
|
|
// AgentBotHandler handles AgentBot CRUD + ResetToken + ResetSecret + DeleteAvatar endpoints.
|
|
// Reference: Chatwoot app/controllers/api/v1/accounts/agent_bots_controller.rb
|
|
type AgentBotHandler struct {
|
|
svc *service.AgentBotService
|
|
}
|
|
|
|
// NewAgentBotHandler creates a new AgentBot handler with service injection.
|
|
func NewAgentBotHandler(svc *service.AgentBotService) *AgentBotHandler {
|
|
return &AgentBotHandler{svc: svc}
|
|
}
|
|
|
|
// --- Account-scoped AgentBot endpoints ---
|
|
// Reference: Chatwoot routes — namespace :agent_bots under :account
|
|
|
|
// List retrieves all agent bots accessible to an account (global + account-scoped), paginated.
|
|
// GET /api/v1/accounts/:account_id/agent_bots
|
|
func (h *AgentBotHandler) List(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
|
|
return
|
|
}
|
|
|
|
bots, svcErr := h.svc.ListAccessibleAll(c.Request.Context(), accountID)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
payload := make([]gin.H, 0, len(bots))
|
|
for i := range bots {
|
|
payload = append(payload, serializeAccountAgentBot(&bots[i], accountID))
|
|
}
|
|
c.JSON(http.StatusOK, payload)
|
|
}
|
|
|
|
// Get retrieves a single agent bot by ID.
|
|
// GET /api/v1/accounts/:account_id/agent_bots/:id
|
|
func (h *AgentBotHandler) Get(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
|
|
return
|
|
}
|
|
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
bot, svcErr := h.svc.GetAccessible(c.Request.Context(), accountID, agentBotID)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, serializeAccountAgentBot(bot, accountID))
|
|
}
|
|
|
|
// Create creates a new agent bot scoped to an account.
|
|
// POST /api/v1/accounts/:account_id/agent_bots
|
|
func (h *AgentBotHandler) Create(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
|
|
return
|
|
}
|
|
|
|
var req service.CreateAgentBotRequest
|
|
if err := c.ShouldBind(&req); err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
|
|
return
|
|
}
|
|
|
|
// Set account scope from URL param
|
|
req.AccountID = &accountID
|
|
|
|
bot, svcErr := h.svc.Create(c.Request.Context(), req)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, serializeAccountAgentBot(bot, accountID))
|
|
}
|
|
|
|
// Update modifies an existing agent bot.
|
|
// PUT /api/v1/accounts/:account_id/agent_bots/:id
|
|
func (h *AgentBotHandler) Update(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
|
|
return
|
|
}
|
|
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
var req service.UpdateAgentBotRequest
|
|
if err := c.ShouldBind(&req); err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
|
|
return
|
|
}
|
|
|
|
bot, svcErr := h.svc.UpdateByAccount(c.Request.Context(), accountID, agentBotID, req)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, serializeAccountAgentBot(bot, accountID))
|
|
}
|
|
|
|
// Delete removes an agent bot by ID.
|
|
// DELETE /api/v1/accounts/:account_id/agent_bots/:id
|
|
func (h *AgentBotHandler) Delete(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
|
|
return
|
|
}
|
|
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
if svcErr := h.svc.DeleteByAccount(c.Request.Context(), accountID, agentBotID); svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
c.Status(http.StatusOK)
|
|
}
|
|
|
|
// ResetToken generates a new access token for the bot.
|
|
// POST /api/v1/accounts/:account_id/agent_bots/:id/reset_token
|
|
// Reference: Chatwoot AgentBotsController#reset_access_token
|
|
func (h *AgentBotHandler) ResetToken(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
|
|
return
|
|
}
|
|
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
bot, svcErr := h.svc.ResetTokenByAccount(c.Request.Context(), accountID, agentBotID)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, serializeAccountAgentBot(bot, accountID))
|
|
}
|
|
|
|
// ResetSecret generates a new webhook signing secret for the bot.
|
|
// POST /api/v1/accounts/:account_id/agent_bots/:id/reset_secret
|
|
// Reference: Chatwoot AgentBotsController#reset_secret
|
|
func (h *AgentBotHandler) ResetSecret(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
|
|
return
|
|
}
|
|
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
bot, svcErr := h.svc.ResetSecretByAccount(c.Request.Context(), accountID, agentBotID)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, serializeAccountAgentBot(bot, accountID))
|
|
}
|
|
|
|
// DeleteAvatar removes the bot's avatar URL.
|
|
// POST /api/v1/accounts/:account_id/agent_bots/:id/delete_avatar
|
|
// Reference: Chatwoot AgentBotsController#destroy_avatar
|
|
func (h *AgentBotHandler) DeleteAvatar(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
|
|
return
|
|
}
|
|
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
bot, svcErr := h.svc.DeleteAvatarByAccount(c.Request.Context(), accountID, agentBotID)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, serializeAccountAgentBot(bot, accountID))
|
|
}
|
|
|
|
func serializeAccountAgentBot(bot *model.AgentBot, accountID uint) gin.H {
|
|
if bot == nil {
|
|
return gin.H{}
|
|
}
|
|
systemBot := bot.AccountID == nil
|
|
payload := gin.H{
|
|
"id": bot.ID,
|
|
"name": bot.Name,
|
|
"description": bot.Description,
|
|
"thumbnail": bot.AvatarURL,
|
|
"bot_type": bot.BotType,
|
|
"bot_config": bot.Config,
|
|
"account_id": bot.AccountID,
|
|
"system_bot": systemBot,
|
|
}
|
|
if !systemBot {
|
|
payload["outgoing_url"] = bot.OutgoingURL
|
|
}
|
|
if bot.AccountID != nil && *bot.AccountID == accountID && bot.AccessToken != "" {
|
|
payload["access_token"] = bot.AccessToken
|
|
}
|
|
if bot.AccountID != nil && *bot.AccountID == accountID && bot.Secret != "" {
|
|
payload["secret"] = bot.Secret
|
|
}
|
|
return payload
|
|
}
|
|
|
|
// --- Platform (super admin) AgentBot endpoints ---
|
|
// Reference: Chatwoot platform-level agent_bots management (super_admin only)
|
|
|
|
// PlatformList lists all agent bots (no account scope filter).
|
|
// GET /platform/api/v1/agent_bots
|
|
func (h *AgentBotHandler) PlatformList(c *gin.Context) {
|
|
page := pagination.Parse(c)
|
|
|
|
// For platform-level, show all bots; use accountID=0 as a sentinel
|
|
// that includes global (account_id IS NULL) bots + all account bots
|
|
// The FindAccessible query uses "account_id IS NULL OR account_id = ?"
|
|
// with accountID=0 won't match any real account, but IS NULL still matches global bots
|
|
// For true platform listing, we need a different approach — just list everything
|
|
// Use a very high accountID so FindAccessible only returns global bots,
|
|
// then we also need account-scoped ones. Let's use the repo directly.
|
|
// Actually, let's just call List with page 0 (no account filter)
|
|
// Service doesn't have a ListAll method, so let's use FindAccessible with a large sentinel
|
|
// Better: we should have the platform view call ListAccessible with a special sentinel
|
|
// For now, let's paginate over all bots accessible as if no account constraint
|
|
// Use account_id = 0 to only get global bots in FindAccessible... not ideal.
|
|
// Simplest: pass account_id as max uint to skip the = clause in FindAccessible
|
|
sentinelID := uint(0)
|
|
// FindAccessible with accountID=0 returns only global bots (account_id IS NULL)
|
|
// because "account_id = 0" won't match any real bot.
|
|
bots, total, svcErr := h.svc.ListAccessible(c.Request.Context(), sentinelID, page.Offset, page.PerPage)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
// Convert total from int64
|
|
response.OKWithMeta(c, bots, page.Page, page.PerPage, total)
|
|
}
|
|
|
|
// PlatformCreate creates a global (platform-level) agent bot with no account scope.
|
|
// POST /platform/api/v1/agent_bots
|
|
func (h *AgentBotHandler) PlatformCreate(c *gin.Context) {
|
|
var req service.CreateAgentBotRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
|
|
return
|
|
}
|
|
|
|
// Platform-level bot: no account scope (AccountID stays nil)
|
|
req.AccountID = nil
|
|
|
|
bot, svcErr := h.svc.Create(c.Request.Context(), req)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
response.Created(c, bot)
|
|
}
|
|
|
|
// PlatformGet retrieves a single agent bot (super admin context, no account filter).
|
|
// GET /platform/api/v1/agent_bots/:id
|
|
func (h *AgentBotHandler) PlatformGet(c *gin.Context) {
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
bot, svcErr := h.svc.Get(c.Request.Context(), agentBotID)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
response.OK(c, bot)
|
|
}
|
|
|
|
// PlatformUpdate modifies an agent bot (super admin context).
|
|
// PUT /platform/api/v1/agent_bots/:id
|
|
func (h *AgentBotHandler) PlatformUpdate(c *gin.Context) {
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
var req service.UpdateAgentBotRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
|
|
return
|
|
}
|
|
|
|
bot, svcErr := h.svc.Update(c.Request.Context(), agentBotID, req)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
response.OK(c, bot)
|
|
}
|
|
|
|
// PlatformDelete removes an agent bot (super admin context).
|
|
// DELETE /platform/api/v1/agent_bots/:id
|
|
func (h *AgentBotHandler) PlatformDelete(c *gin.Context) {
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
if svcErr := h.svc.Delete(c.Request.Context(), agentBotID); svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
response.NoContent(c)
|
|
}
|
|
|
|
// PlatformUpdateAvatar updates the avatar URL for an agent bot (super admin context).
|
|
// PUT /platform/api/v1/agent_bots/:id/avatar
|
|
// Reference: Chatwoot AgentBotsController#update_avatar (platform-level)
|
|
func (h *AgentBotHandler) PlatformUpdateAvatar(c *gin.Context) {
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
var req service.AgentBotUpdateAvatarRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
|
|
return
|
|
}
|
|
|
|
bot, svcErr := h.svc.UpdateAvatar(c.Request.Context(), agentBotID, req)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
response.OK(c, bot)
|
|
}
|
|
|
|
// PlatformResetConfig resets the configuration for an agent bot (super admin context).
|
|
// POST /platform/api/v1/agent_bots/:id/reset
|
|
// Reference: Chatwoot AgentBotsController#reset_config (platform-level)
|
|
func (h *AgentBotHandler) PlatformResetConfig(c *gin.Context) {
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
bot, svcErr := h.svc.ResetConfig(c.Request.Context(), agentBotID)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
response.OK(c, bot)
|
|
}
|
|
|
|
// ListAccessible retrieves agent bots accessible to an account (global + account-scoped), paginated.
|
|
// GET /api/v1/accounts/:account_id/agent_bots/accessible
|
|
func (h *AgentBotHandler) ListAccessible(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
|
|
return
|
|
}
|
|
|
|
page := pagination.Parse(c)
|
|
bots, total, svcErr := h.svc.ListAccessible(c.Request.Context(), accountID, page.Offset, page.PerPage)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
response.OKWithMeta(c, bots, page.Page, page.PerPage, total)
|
|
}
|
|
|
|
// UpdateAvatar sets a new avatar URL for the agent bot.
|
|
// PUT /api/v1/accounts/:account_id/agent_bots/:id/avatar
|
|
// Reference: Chatwoot agent_bots_controller#avatar — handles avatar upload/URL update.
|
|
func (h *AgentBotHandler) UpdateAvatar(c *gin.Context) {
|
|
agentBotID, err := parseUintParam(c, "agent_bot_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid agent bot ID")
|
|
return
|
|
}
|
|
|
|
var req service.AgentBotUpdateAvatarRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
bot, svcErr := h.svc.UpdateAvatar(c.Request.Context(), agentBotID, req)
|
|
if svcErr != nil {
|
|
handleServiceError(c, svcErr)
|
|
return
|
|
}
|
|
|
|
response.OK(c, bot)
|
|
}
|