root/geo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(migrations): Harden task audit tracking and optimize article templates

Browse Source 
- Added migration to harden task audit tracking by modifying audit_logs and related tables.
- Introduced operator_id to several tables for better tracking of actions.
- Updated article_templates with new prompt templates for various article types, enhancing content generation.
- Created prompt_rules and schedule_tasks tables to manage content generation rules and scheduling.
- Added foreign key constraints to articles for better data integrity.
This commit is contained in:
liangxu
2026-04-02 00:31:28 +08:00
parent de30497f59
commit b31d8d0096
101 changed files with 16671 additions and 721 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/internal/tenant/transport/article_handler.go
+71 -4
View File
@@ -15,14 +15,22 @@ import (
)
type ArticleHandler struct {
svc *app.ArticleService
streams *stream.GenerationHub
streamEnabled bool
svc *app.ArticleService
promptGenerateSvc *app.PromptRuleGenerationService
streams *stream.GenerationHub
streamEnabled bool
}
func NewArticleHandler(a *bootstrap.App) *ArticleHandler {
return &ArticleHandler{
svc: app.NewArticleService(a.DB),
svc: app.NewArticleService(a.DB, a.AuditLogs),
promptGenerateSvc: app.NewPromptRuleGenerationService(
a.DB,
a.LLM,
a.GenerationStreams,
a.Config.Generation,
a.Config.LLM.MaxOutputTokens,
),
streams: a.GenerationStreams,
streamEnabled: a.Config.Generation.StreamEnabled,
}
@@ -47,9 +55,30 @@ func (h *ArticleHandler) List(c *gin.Context) {
params.TemplateID = &id
}
}
if v := c.Query("prompt_rule_id"); v != "" {
if id, err := strconv.ParseInt(v, 10, 64); err == nil {
params.PromptRuleID = &id
}
}
if v := c.Query("keyword"); v != "" {
params.Keyword = &v
}
if v := c.Query("created_from"); v != "" {
parsed, err := time.Parse(time.RFC3339, v)
if err != nil {
response.Error(c, response.ErrBadRequest(40014, "invalid_created_from", "created_from must be RFC3339"))
return
}
params.CreatedFrom = &parsed
}
if v := c.Query("created_to"); v != "" {
parsed, err := time.Parse(time.RFC3339, v)
if err != nil {
response.Error(c, response.ErrBadRequest(40015, "invalid_created_to", "created_to must be RFC3339"))
return
}
params.CreatedTo = &parsed
}
data, err := h.svc.List(c.Request.Context(), params)
if err != nil {
@@ -59,6 +88,22 @@ func (h *ArticleHandler) List(c *gin.Context) {
response.Success(c, data)
}
func (h *ArticleHandler) GenerateFromRule(c *gin.Context) {
var req app.GenerateFromRuleRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
data, err := h.promptGenerateSvc.GenerateFromRule(c.Request.Context(), req)
if err != nil {
response.Error(c, err)
return
}
response.SuccessWithStatus(c, http.StatusCreated, data)
}
func (h *ArticleHandler) Detail(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
@@ -87,6 +132,28 @@ func (h *ArticleHandler) Versions(c *gin.Context) {
response.Success(c, data)
}
func (h *ArticleHandler) Update(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "article id must be a number"))
return
}
var req app.UpdateArticleRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40013, "invalid_payload", err.Error()))
return
}
data, err := h.svc.Update(c.Request.Context(), id, req)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *ArticleHandler) Stream(c *gin.Context) {
if !h.streamEnabled {
response.Error(c, response.ErrNotFound(40412, "generation_stream_disabled", "generation stream is disabled"))
server/internal/tenant/transport/brand_handler.go
+1 -1
View File
@@ -15,7 +15,7 @@ type BrandHandler struct {
}
func NewBrandHandler(a *bootstrap.App) *BrandHandler {
return &BrandHandler{svc: app.NewBrandService(a.DB)}
return &BrandHandler{svc: app.NewBrandService(a.DB, a.AuditLogs)}
}
func (h *BrandHandler) List(c *gin.Context) {
server/internal/tenant/transport/prompt_rule_handler.go
+201
View File
@@ -0,0 +1,201 @@
package transport
import (
"strconv"
"github.com/gin-gonic/gin"
"github.com/geo-platform/tenant-api/internal/bootstrap"
"github.com/geo-platform/tenant-api/internal/shared/response"
"github.com/geo-platform/tenant-api/internal/tenant/app"
)
type PromptRuleHandler struct {
svc *app.PromptRuleService
}
func NewPromptRuleHandler(a *bootstrap.App) *PromptRuleHandler {
return &PromptRuleHandler{svc: app.NewPromptRuleService(a.DB, a.AuditLogs)}
}
// --- Groups ---
func (h *PromptRuleHandler) ListGroups(c *gin.Context) {
data, err := h.svc.ListGroups(c.Request.Context())
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *PromptRuleHandler) CreateGroup(c *gin.Context) {
var req app.PromptRuleGroupRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
data, err := h.svc.CreateGroup(c.Request.Context(), req)
if err != nil {
response.Error(c, err)
return
}
response.SuccessWithStatus(c, 201, data)
}
func (h *PromptRuleHandler) UpdateGroup(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("gid"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "group id must be a number"))
return
}
var req app.PromptRuleGroupRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
if err := h.svc.UpdateGroup(c.Request.Context(), id, req); err != nil {
response.Error(c, err)
return
}
response.Success(c, nil)
}
func (h *PromptRuleHandler) DeleteGroup(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("gid"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "group id must be a number"))
return
}
if err := h.svc.DeleteGroup(c.Request.Context(), id); err != nil {
response.Error(c, err)
return
}
response.Success(c, nil)
}
// --- Rules ---
func (h *PromptRuleHandler) List(c *gin.Context) {
params := app.PromptRuleListParams{
Page: 1,
PageSize: 20,
}
if v := c.Query("page"); v != "" {
if p, err := strconv.Atoi(v); err == nil {
params.Page = p
}
}
if v := c.Query("page_size"); v != "" {
if ps, err := strconv.Atoi(v); err == nil {
params.PageSize = ps
}
}
if v := c.Query("group_id"); v != "" {
if gid, err := strconv.ParseInt(v, 10, 64); err == nil {
params.GroupID = &gid
}
}
if v := c.Query("ungrouped"); v == "true" {
params.Ungrouped = true
}
if v := c.Query("status"); v != "" {
params.Status = &v
}
if v := c.Query("keyword"); v != "" {
params.Keyword = &v
}
data, err := h.svc.List(c.Request.Context(), params)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *PromptRuleHandler) Detail(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "rule id must be a number"))
return
}
data, err := h.svc.Detail(c.Request.Context(), id)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *PromptRuleHandler) Create(c *gin.Context) {
var req app.PromptRuleRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
data, err := h.svc.Create(c.Request.Context(), req)
if err != nil {
response.Error(c, err)
return
}
response.SuccessWithStatus(c, 201, data)
}
func (h *PromptRuleHandler) Update(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "rule id must be a number"))
return
}
var req app.PromptRuleRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
if err := h.svc.Update(c.Request.Context(), id, req); err != nil {
response.Error(c, err)
return
}
response.Success(c, nil)
}
func (h *PromptRuleHandler) Delete(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "rule id must be a number"))
return
}
if err := h.svc.Delete(c.Request.Context(), id); err != nil {
response.Error(c, err)
return
}
response.Success(c, nil)
}
func (h *PromptRuleHandler) ToggleStatus(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "rule id must be a number"))
return
}
var req app.PromptRuleStatusRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
if err := h.svc.ToggleStatus(c.Request.Context(), id, req); err != nil {
response.Error(c, err)
return
}
response.Success(c, nil)
}
func (h *PromptRuleHandler) ListSimple(c *gin.Context) {
data, err := h.svc.ListSimple(c.Request.Context())
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
server/internal/tenant/transport/router.go
+35
View File
@@ -31,12 +31,21 @@ func RegisterRoutes(app *bootstrap.App) {
templates.GET("", tplHandler.List)
templates.GET("/:id", tplHandler.Detail)
templates.GET("/:id/schema", tplHandler.Schema)
templates.POST("/:id/drafts", tplHandler.SaveDraft)
templates.POST("/:id/analyze-tasks", tplHandler.CreateAnalyzeTask)
templates.GET("/:id/analyze_task_result", tplHandler.GetAnalyzeTaskResult)
templates.POST("/:id/title-tasks", tplHandler.CreateTitleTask)
templates.GET("/:id/gen_title_task_result", tplHandler.GetTitleTaskResult)
templates.POST("/:id/outline-tasks", tplHandler.CreateOutlineTask)
templates.GET("/:id/gen_outline_task_result", tplHandler.GetOutlineTaskResult)
templates.POST("/:id/generate", tplHandler.Generate)
articles := protected.Group("/tenant/articles")
artHandler := NewArticleHandler(app)
articles.GET("", artHandler.List)
articles.POST("/generate-from-rule", artHandler.GenerateFromRule)
articles.GET("/:id", artHandler.Detail)
articles.PUT("/:id", artHandler.Update)
articles.GET("/:id/stream", artHandler.Stream)
articles.GET("/:id/versions", artHandler.Versions)
articles.DELETE("/:id", artHandler.Delete)
@@ -61,4 +70,30 @@ func RegisterRoutes(app *bootstrap.App) {
brands.POST("/:id/competitors", brandHandler.CreateCompetitor)
brands.PUT("/:id/competitors/:cid", brandHandler.UpdateCompetitor)
brands.DELETE("/:id/competitors/:cid", brandHandler.DeleteCompetitor)
// Prompt Rules
promptRules := protected.Group("/tenant/prompt-rules")
prHandler := NewPromptRuleHandler(app)
promptRules.GET("", prHandler.List)
promptRules.GET("/simple", prHandler.ListSimple)
promptRules.POST("", prHandler.Create)
promptRules.GET("/:id", prHandler.Detail)
promptRules.PUT("/:id", prHandler.Update)
promptRules.DELETE("/:id", prHandler.Delete)
promptRules.PUT("/:id/status", prHandler.ToggleStatus)
// Prompt Rule Groups
promptRules.GET("/groups", prHandler.ListGroups)
promptRules.POST("/groups", prHandler.CreateGroup)
promptRules.PUT("/groups/:gid", prHandler.UpdateGroup)
promptRules.DELETE("/groups/:gid", prHandler.DeleteGroup)
// Schedule Tasks
schedules := protected.Group("/tenant/schedules")
schHandler := NewScheduleTaskHandler(app)
schedules.GET("", schHandler.List)
schedules.POST("", schHandler.Create)
schedules.GET("/:id", schHandler.Detail)
schedules.PUT("/:id", schHandler.Update)
schedules.DELETE("/:id", schHandler.Delete)
schedules.PUT("/:id/status", schHandler.ToggleStatus)
}
server/internal/tenant/transport/schedule_task_handler.go
+128
View File
@@ -0,0 +1,128 @@
package transport
import (
"strconv"
"github.com/gin-gonic/gin"
"github.com/geo-platform/tenant-api/internal/bootstrap"
"github.com/geo-platform/tenant-api/internal/shared/response"
"github.com/geo-platform/tenant-api/internal/tenant/app"
)
type ScheduleTaskHandler struct {
svc *app.ScheduleTaskService
}
func NewScheduleTaskHandler(a *bootstrap.App) *ScheduleTaskHandler {
return &ScheduleTaskHandler{svc: app.NewScheduleTaskService(a.DB, a.AuditLogs)}
}
func (h *ScheduleTaskHandler) List(c *gin.Context) {
params := app.ScheduleTaskListParams{
Page: 1,
PageSize: 20,
}
if v := c.Query("page"); v != "" {
if p, err := strconv.Atoi(v); err == nil {
params.Page = p
}
}
if v := c.Query("page_size"); v != "" {
if ps, err := strconv.Atoi(v); err == nil {
params.PageSize = ps
}
}
if v := c.Query("prompt_rule_id"); v != "" {
if rid, err := strconv.ParseInt(v, 10, 64); err == nil {
params.PromptRuleID = &rid
}
}
if v := c.Query("status"); v != "" {
params.Status = &v
}
data, err := h.svc.List(c.Request.Context(), params)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *ScheduleTaskHandler) Detail(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "schedule task id must be a number"))
return
}
data, err := h.svc.Detail(c.Request.Context(), id)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *ScheduleTaskHandler) Create(c *gin.Context) {
var req app.ScheduleTaskRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
data, err := h.svc.Create(c.Request.Context(), req)
if err != nil {
response.Error(c, err)
return
}
response.SuccessWithStatus(c, 201, data)
}
func (h *ScheduleTaskHandler) Update(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "schedule task id must be a number"))
return
}
var req app.ScheduleTaskRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
if err := h.svc.Update(c.Request.Context(), id, req); err != nil {
response.Error(c, err)
return
}
response.Success(c, nil)
}
func (h *ScheduleTaskHandler) Delete(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "schedule task id must be a number"))
return
}
if err := h.svc.Delete(c.Request.Context(), id); err != nil {
response.Error(c, err)
return
}
response.Success(c, nil)
}
func (h *ScheduleTaskHandler) ToggleStatus(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "schedule task id must be a number"))
return
}
var req app.ScheduleTaskStatusRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
if err := h.svc.ToggleStatus(c.Request.Context(), id, req); err != nil {
response.Error(c, err)
return
}
response.Success(c, nil)
}
server/internal/tenant/transport/template_handler.go
+150 -1
View File
@@ -19,10 +19,14 @@ func NewTemplateHandler(a *bootstrap.App) *TemplateHandler {
return &TemplateHandler{
svc: app.NewTemplateService(
a.DB,
repository.NewTemplateRepository(a.DB),
repository.NewCachedTemplateRepository(
repository.NewTemplateRepository(a.DB),
a.Cache,
),
a.LLM,
a.GenerationStreams,
a.Config.Generation,
a.Config.LLM.MaxOutputTokens,
),
}
}
@@ -82,3 +86,148 @@ func (h *TemplateHandler) Generate(c *gin.Context) {
}
response.Success(c, data)
}
func (h *TemplateHandler) SaveDraft(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "template id must be a number"))
return
}
var req app.SaveDraftRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
data, err := h.svc.SaveDraft(c.Request.Context(), id, req)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *TemplateHandler) CreateAnalyzeTask(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "template id must be a number"))
return
}
var req app.AnalyzeTaskRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
data, err := h.svc.CreateAnalyzeTask(c.Request.Context(), id, req)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *TemplateHandler) GetAnalyzeTaskResult(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "template id must be a number"))
return
}
taskID := c.Query("task_id")
if taskID == "" {
response.Error(c, response.ErrBadRequest(40001, "invalid_task_id", "task id must not be empty"))
return
}
data, err := h.svc.GetAnalyzeTask(c.Request.Context(), id, taskID)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *TemplateHandler) CreateTitleTask(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "template id must be a number"))
return
}
var req app.TitleTaskRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
data, err := h.svc.CreateTitleTask(c.Request.Context(), id, req)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *TemplateHandler) GetTitleTaskResult(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "template id must be a number"))
return
}
taskID := c.Query("task_id")
if taskID == "" {
response.Error(c, response.ErrBadRequest(40001, "invalid_task_id", "task id must not be empty"))
return
}
data, err := h.svc.GetTitleTask(c.Request.Context(), id, taskID)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *TemplateHandler) CreateOutlineTask(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "template id must be a number"))
return
}
var req app.OutlineTaskRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
return
}
data, err := h.svc.CreateOutlineTask(c.Request.Context(), id, req)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
func (h *TemplateHandler) GetOutlineTaskResult(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
response.Error(c, response.ErrBadRequest(40001, "invalid_id", "template id must be a number"))
return
}
taskID := c.Query("task_id")
if taskID == "" {
response.Error(c, response.ErrBadRequest(40001, "invalid_task_id", "task id must not be empty"))
return
}
data, err := h.svc.GetOutlineTask(c.Request.Context(), id, taskID)
if err != nil {
response.Error(c, err)
return
}
response.Success(c, data)
}
server/internal/tenant/transport/workspace_handler.go
+4 -1
View File
@@ -17,7 +17,10 @@ func NewWorkspaceHandler(a *bootstrap.App) *WorkspaceHandler {
return &WorkspaceHandler{
svc: app.NewWorkspaceService(
repository.NewWorkspaceRepository(a.DB),
repository.NewTemplateRepository(a.DB),
repository.NewCachedTemplateRepository(
repository.NewTemplateRepository(a.DB),
a.Cache,
),
),
}
}