mirror of
https://github.com/hanzoai/team.git
synced 2026-09-30 01:57:35 +00:00
zeekay
8feb24ea1f
The server module named github.com/hanzoai/team/server/v8 — a path that resolves to the retired workspace's repository, not this one — while server/public still published github.com/mattermost/mattermost/server/public. Both are github.com/hanzoteam/server/... now, which is where this code actually lives. That second half is what made the binary unbootable. Upstream's public path stayed claimed by upstream, mattermost-plugin-ai imported it, and the build linked public/model twice; public/plugin's gob.Register then ran twice under one name and panicked at init, before main. Reverting the rename traded the brand for a working binary. Rebranding the plugin alongside it needs no such trade: the agents fork is github.com/hanzoteam/agents/v2 against our public module, so no module named mattermost/mattermost is in the graph at all. Measured: `go list -deps ./cmd/mattermost` names exactly one public/model, and it is ours.
333 lines
9.1 KiB
Go
333 lines
9.1 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package api4
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
|
|
"github.com/hanzoteam/server/server/public/model"
|
|
"github.com/hanzoteam/server/server/public/shared/mlog"
|
|
"github.com/hanzoteam/server/server/v8/channels/app"
|
|
)
|
|
|
|
func (api *API) InitRecap() {
|
|
api.BaseRoutes.Recaps.Handle("", api.APISessionRequired(createRecap)).Methods(http.MethodPost)
|
|
api.BaseRoutes.Recaps.Handle("", api.APISessionRequired(getRecaps)).Methods(http.MethodGet)
|
|
api.BaseRoutes.Recaps.Handle("/limit_status", api.APISessionRequired(getRecapLimitStatus)).Methods(http.MethodGet)
|
|
api.BaseRoutes.Recaps.Handle("/mark_viewed", api.APISessionRequired(markRecapsAsViewed)).Methods(http.MethodPost)
|
|
api.BaseRoutes.Recaps.Handle("/{recap_id:[A-Za-z0-9]+}", api.APISessionRequired(getRecap)).Methods(http.MethodGet)
|
|
api.BaseRoutes.Recaps.Handle("/{recap_id:[A-Za-z0-9]+}/read", api.APISessionRequired(markRecapAsRead)).Methods(http.MethodPost)
|
|
api.BaseRoutes.Recaps.Handle("/{recap_id:[A-Za-z0-9]+}/regenerate", api.APISessionRequired(regenerateRecap)).Methods(http.MethodPost)
|
|
api.BaseRoutes.Recaps.Handle("/{recap_id:[A-Za-z0-9]+}", api.APISessionRequired(deleteRecap)).Methods(http.MethodDelete)
|
|
}
|
|
|
|
func requireRecapsEnabled(c *Context) {
|
|
if !c.App.AIRecapsEnabled() {
|
|
c.Err = model.NewAppError("requireRecapsEnabled", "api.recap.disabled.app_error", nil, "", http.StatusNotImplemented)
|
|
return
|
|
}
|
|
}
|
|
|
|
// addRecapChannelIDsToAuditRec extracts channel IDs from a recap and adds them to the audit record.
|
|
// This logs which channels' content was accessed through the recap operation.
|
|
func addRecapChannelIDsToAuditRec(auditRec *model.AuditRecord, recap *model.Recap) {
|
|
if len(recap.Channels) == 0 {
|
|
return
|
|
}
|
|
channelIDs := make([]string, 0, len(recap.Channels))
|
|
for _, channel := range recap.Channels {
|
|
channelIDs = append(channelIDs, channel.ChannelId)
|
|
}
|
|
model.AddEventParameterToAuditRec(auditRec, "channel_ids", channelIDs)
|
|
}
|
|
|
|
func getRecapLimitStatus(c *Context, w http.ResponseWriter, r *http.Request) {
|
|
requireRecapsEnabled(c)
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
userID := c.AppContext.Session().UserId
|
|
|
|
status, appErr := c.App.GetRecapLimitStatus(userID)
|
|
if appErr != nil {
|
|
c.Err = appErr
|
|
return
|
|
}
|
|
|
|
if err := json.NewEncoder(w).Encode(status); err != nil {
|
|
c.Logger.Warn("Error writing response", mlog.Err(err))
|
|
}
|
|
}
|
|
|
|
func createRecap(c *Context, w http.ResponseWriter, r *http.Request) {
|
|
requireRecapsEnabled(c)
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
var req model.CreateRecapRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
c.SetInvalidParamWithErr("body", err)
|
|
return
|
|
}
|
|
|
|
if len(req.ChannelIds) == 0 {
|
|
c.SetInvalidParam("channel_ids")
|
|
return
|
|
}
|
|
|
|
if req.Title == "" {
|
|
c.SetInvalidParam("title")
|
|
return
|
|
}
|
|
|
|
if req.AgentID == "" {
|
|
c.SetInvalidParam("agent_id")
|
|
return
|
|
}
|
|
|
|
auditRec := c.MakeAuditRecord(model.AuditEventCreateRecap, model.AuditStatusFail)
|
|
defer c.LogAuditRecWithLevel(auditRec, app.LevelContent)
|
|
auditRec.AddEventObjectType("recap")
|
|
model.AddEventParameterToAuditRec(auditRec, "channel_ids", req.ChannelIds)
|
|
model.AddEventParameterToAuditRec(auditRec, "title", req.Title)
|
|
model.AddEventParameterToAuditRec(auditRec, "agent_id", req.AgentID)
|
|
|
|
recap, err := c.App.CreateRecap(c.AppContext, req.Title, req.ChannelIds, req.AgentID)
|
|
if err != nil {
|
|
c.Err = err
|
|
return
|
|
}
|
|
|
|
auditRec.Success()
|
|
auditRec.AddEventResultState(recap)
|
|
|
|
w.WriteHeader(http.StatusCreated)
|
|
if err := json.NewEncoder(w).Encode(recap); err != nil {
|
|
c.Logger.Warn("Error encoding response", mlog.Err(err))
|
|
}
|
|
}
|
|
|
|
func getRecap(c *Context, w http.ResponseWriter, r *http.Request) {
|
|
requireRecapsEnabled(c)
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
c.RequireRecapId()
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
auditRec := c.MakeAuditRecord(model.AuditEventGetRecap, model.AuditStatusFail)
|
|
defer c.LogAuditRecWithLevel(auditRec, app.LevelContent)
|
|
auditRec.AddEventObjectType("recap")
|
|
model.AddEventParameterToAuditRec(auditRec, "recap_id", c.Params.RecapId)
|
|
|
|
recap, err := c.App.GetRecap(c.AppContext, c.Params.RecapId)
|
|
if err != nil {
|
|
c.Err = err
|
|
return
|
|
}
|
|
|
|
if recap.UserId != c.AppContext.Session().UserId {
|
|
c.Err = model.NewAppError("getRecap", "api.recap.permission_denied", nil, "", http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
// Log channel IDs accessed through viewing this recap summary
|
|
addRecapChannelIDsToAuditRec(auditRec, recap)
|
|
|
|
auditRec.Success()
|
|
auditRec.AddEventResultState(recap)
|
|
|
|
if err := json.NewEncoder(w).Encode(recap); err != nil {
|
|
c.Logger.Warn("Error encoding response", mlog.Err(err))
|
|
}
|
|
}
|
|
|
|
func getRecaps(c *Context, w http.ResponseWriter, r *http.Request) {
|
|
requireRecapsEnabled(c)
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
auditRec := c.MakeAuditRecord(model.AuditEventGetRecaps, model.AuditStatusFail)
|
|
defer c.LogAuditRecWithLevel(auditRec, app.LevelAPI)
|
|
model.AddEventParameterToAuditRec(auditRec, "page", c.Params.Page)
|
|
model.AddEventParameterToAuditRec(auditRec, "per_page", c.Params.PerPage)
|
|
|
|
recaps, err := c.App.GetRecapsForUser(c.AppContext, c.Params.Page, c.Params.PerPage)
|
|
if err != nil {
|
|
c.Err = err
|
|
return
|
|
}
|
|
|
|
auditRec.Success()
|
|
if len(recaps) > 0 {
|
|
auditRec.AddMeta("recap_count", len(recaps))
|
|
}
|
|
|
|
if err := json.NewEncoder(w).Encode(recaps); err != nil {
|
|
c.Logger.Warn("Error encoding response", mlog.Err(err))
|
|
}
|
|
}
|
|
|
|
func markRecapAsRead(c *Context, w http.ResponseWriter, r *http.Request) {
|
|
requireRecapsEnabled(c)
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
c.RequireRecapId()
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
auditRec := c.MakeAuditRecord(model.AuditEventMarkRecapAsRead, model.AuditStatusFail)
|
|
defer c.LogAuditRecWithLevel(auditRec, app.LevelContent)
|
|
auditRec.AddEventObjectType("recap")
|
|
model.AddEventParameterToAuditRec(auditRec, "recap_id", c.Params.RecapId)
|
|
|
|
// Check permissions
|
|
recap, err := c.App.GetRecap(c.AppContext, c.Params.RecapId)
|
|
if err != nil {
|
|
c.Err = err
|
|
return
|
|
}
|
|
|
|
if recap.UserId != c.AppContext.Session().UserId {
|
|
c.Err = model.NewAppError("markRecapAsRead", "api.recap.permission_denied", nil, "", http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
auditRec.AddEventPriorState(recap)
|
|
|
|
updatedRecap, err := c.App.MarkRecapAsRead(c.AppContext, recap)
|
|
if err != nil {
|
|
c.Err = err
|
|
return
|
|
}
|
|
|
|
auditRec.Success()
|
|
auditRec.AddEventResultState(updatedRecap)
|
|
|
|
if err := json.NewEncoder(w).Encode(updatedRecap); err != nil {
|
|
c.Logger.Warn("Error encoding response", mlog.Err(err))
|
|
}
|
|
}
|
|
|
|
func markRecapsAsViewed(c *Context, w http.ResponseWriter, r *http.Request) {
|
|
requireRecapsEnabled(c)
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
auditRec := c.MakeAuditRecord(model.AuditEventMarkRecapsAsViewed, model.AuditStatusFail)
|
|
defer c.LogAuditRecWithLevel(auditRec, app.LevelContent)
|
|
auditRec.AddEventObjectType("recap")
|
|
|
|
ids, err := c.App.MarkRecapsAsViewed(c.AppContext)
|
|
if err != nil {
|
|
c.Err = err
|
|
return
|
|
}
|
|
|
|
auditRec.Success()
|
|
auditRec.AddMeta("recap_count", len(ids))
|
|
auditRec.AddMeta("recap_ids", ids)
|
|
|
|
if err := json.NewEncoder(w).Encode(map[string]any{"recap_ids": ids}); err != nil {
|
|
c.Logger.Warn("Error encoding response", mlog.Err(err))
|
|
}
|
|
}
|
|
|
|
func regenerateRecap(c *Context, w http.ResponseWriter, r *http.Request) {
|
|
requireRecapsEnabled(c)
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
c.RequireRecapId()
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
auditRec := c.MakeAuditRecord(model.AuditEventRegenerateRecap, model.AuditStatusFail)
|
|
defer c.LogAuditRecWithLevel(auditRec, app.LevelContent)
|
|
auditRec.AddEventObjectType("recap")
|
|
model.AddEventParameterToAuditRec(auditRec, "recap_id", c.Params.RecapId)
|
|
|
|
// Check permissions
|
|
recap, err := c.App.GetRecap(c.AppContext, c.Params.RecapId)
|
|
if err != nil {
|
|
c.Err = err
|
|
return
|
|
}
|
|
|
|
if recap.UserId != c.AppContext.Session().UserId {
|
|
c.Err = model.NewAppError("regenerateRecap", "api.recap.permission_denied", nil, "", http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
// Log channel IDs that will be re-summarized
|
|
addRecapChannelIDsToAuditRec(auditRec, recap)
|
|
|
|
auditRec.AddEventPriorState(recap)
|
|
|
|
updatedRecap, err := c.App.RegenerateRecap(c.AppContext, c.AppContext.Session().UserId, recap)
|
|
if err != nil {
|
|
c.Err = err
|
|
return
|
|
}
|
|
|
|
auditRec.Success()
|
|
auditRec.AddEventResultState(updatedRecap)
|
|
|
|
if err := json.NewEncoder(w).Encode(updatedRecap); err != nil {
|
|
c.Logger.Warn("Error encoding response", mlog.Err(err))
|
|
}
|
|
}
|
|
|
|
func deleteRecap(c *Context, w http.ResponseWriter, r *http.Request) {
|
|
requireRecapsEnabled(c)
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
c.RequireRecapId()
|
|
if c.Err != nil {
|
|
return
|
|
}
|
|
|
|
auditRec := c.MakeAuditRecord(model.AuditEventDeleteRecap, model.AuditStatusFail)
|
|
defer c.LogAuditRecWithLevel(auditRec, app.LevelContent)
|
|
auditRec.AddEventObjectType("recap")
|
|
model.AddEventParameterToAuditRec(auditRec, "recap_id", c.Params.RecapId)
|
|
|
|
// Check permissions
|
|
recap, err := c.App.GetRecap(c.AppContext, c.Params.RecapId)
|
|
if err != nil {
|
|
c.Err = err
|
|
return
|
|
}
|
|
|
|
if recap.UserId != c.AppContext.Session().UserId {
|
|
c.Err = model.NewAppError("deleteRecap", "api.recap.permission_denied", nil, "", http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
auditRec.AddEventPriorState(recap)
|
|
|
|
if err := c.App.DeleteRecap(c.AppContext, c.Params.RecapId); err != nil {
|
|
c.Err = err
|
|
return
|
|
}
|
|
|
|
auditRec.Success()
|
|
ReturnStatusOK(w)
|
|
}
|