feat: 提供养成服务内部 IM 能力
This commit is contained in:
richjohnrambo
@@ -0,0 +1,275 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/tinode/chat/server/moderation"
|
||||
"github.com/tinode/chat/server/push"
|
||||
"github.com/tinode/chat/server/store"
|
||||
"github.com/tinode/chat/server/store/types"
|
||||
)
|
||||
|
||||
type cultivateUsersRequest struct {
|
||||
UserIDs []int64 `json:"user_ids"`
|
||||
}
|
||||
|
||||
type cultivateRelationsRequest struct {
|
||||
ViewerID int64 `json:"viewer_id"`
|
||||
PeerIDs []int64 `json:"peer_ids"`
|
||||
}
|
||||
|
||||
type cultivateFilesRequest struct {
|
||||
UserID int64 `json:"user_id"`
|
||||
FileIDs []string `json:"file_ids"`
|
||||
}
|
||||
|
||||
type cultivateReviewRequest struct {
|
||||
ObjectType string `json:"object_type"`
|
||||
ObjectID int64 `json:"object_id"`
|
||||
ActorID int64 `json:"actor_id"`
|
||||
Text string `json:"text"`
|
||||
TraceID string `json:"trace_id"`
|
||||
}
|
||||
|
||||
type cultivateEventRequest struct {
|
||||
EventID string `json:"event_id"`
|
||||
EventType string `json:"event_type"`
|
||||
ActorID int64 `json:"actor_id"`
|
||||
TargetUserID int64 `json:"target_user_id"`
|
||||
Title string `json:"title"`
|
||||
Summary string `json:"summary"`
|
||||
Action map[string]any `json:"action"`
|
||||
Payload map[string]any `json:"payload"`
|
||||
}
|
||||
|
||||
func serveInternalCultivate(w http.ResponseWriter, r *http.Request, prefix string) {
|
||||
if r.Method != http.MethodPost {
|
||||
writeIMError(w, r, http.StatusMethodNotAllowed, 30002, imReasonMethodNotAllowed, "method not allowed", nil)
|
||||
return
|
||||
}
|
||||
if !authorizeInternalAPI(w, r, internalCapabilityCultivate) {
|
||||
return
|
||||
}
|
||||
parts := splitInternalPath(strings.Trim(strings.TrimPrefix(r.URL.Path, prefix), "/"))
|
||||
if len(parts) != 4 || parts[0] != "tenants" {
|
||||
writeIMError(w, r, http.StatusNotFound, 30004, imReasonMalformedRequest, "resource not found", nil)
|
||||
return
|
||||
}
|
||||
tenant, ok := resolveCultivateTenant(w, r, parts[1])
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
switch parts[2] + "/" + parts[3] {
|
||||
case "users/batch":
|
||||
serveCultivateUsers(w, r, tenant.ID)
|
||||
case "relations/check":
|
||||
serveCultivateRelations(w, r, tenant.ID)
|
||||
case "files/validate":
|
||||
serveCultivateFiles(w, r, tenant.ID)
|
||||
case "moderation/review":
|
||||
serveCultivateReview(w, r, tenant)
|
||||
case "events/publish":
|
||||
serveCultivateEvent(w, r, tenant.ID)
|
||||
default:
|
||||
writeIMError(w, r, http.StatusNotFound, 30004, imReasonMalformedRequest, "resource not found", nil)
|
||||
}
|
||||
}
|
||||
|
||||
func resolveCultivateTenant(w http.ResponseWriter, r *http.Request, value string) (*types.Tenant, bool) {
|
||||
if id, err := strconv.ParseInt(value, 10, 64); err == nil && id > 0 && store.Tenants != nil {
|
||||
tenant, lookupErr := store.Tenants.GetByID(types.TenantID(id))
|
||||
if lookupErr == nil && tenant != nil && tenant.IsActive() {
|
||||
return tenant, true
|
||||
}
|
||||
writeIMError(w, r, http.StatusNotFound, 30010, imReasonTenantUnavailable, "tenant unavailable", nil)
|
||||
return nil, false
|
||||
}
|
||||
return resolveInternalTenant(w, r, value)
|
||||
}
|
||||
|
||||
func serveCultivateUsers(w http.ResponseWriter, r *http.Request, tenantID types.TenantID) {
|
||||
var body cultivateUsersRequest
|
||||
if !decodeIMJSONBody(w, r, &body) {
|
||||
return
|
||||
}
|
||||
if len(body.UserIDs) == 0 || len(body.UserIDs) > 200 {
|
||||
writeIMError(w, r, http.StatusBadRequest, 30000, imReasonMalformedRequest, "malformed request", nil)
|
||||
return
|
||||
}
|
||||
items := make([]map[string]any, 0, len(body.UserIDs))
|
||||
for _, rawID := range body.UserIDs {
|
||||
if rawID <= 0 {
|
||||
continue
|
||||
}
|
||||
uid := store.EncodeUid(rawID)
|
||||
user, err := store.Users.Get(tenantID, uid)
|
||||
if err != nil || user == nil {
|
||||
continue
|
||||
}
|
||||
item := map[string]any{"user_id": rawID, "state": user.State.String(), "nickname": "", "avatar_file_id": "", "youth_mode": false}
|
||||
if profile, err := store.Profiles.Get(tenantID, uid); err == nil && profile != nil {
|
||||
item["nickname"], item["avatar_file_id"] = profile.Nickname, profile.AvatarFileID
|
||||
}
|
||||
if settings, err := store.Security.GetYouthMode(tenantID, uid); err == nil && settings != nil {
|
||||
item["youth_mode"] = settings.Enabled
|
||||
}
|
||||
items = append(items, item)
|
||||
}
|
||||
writeIMSuccess(w, r, map[string]any{"items": items})
|
||||
}
|
||||
|
||||
func serveCultivateRelations(w http.ResponseWriter, r *http.Request, tenantID types.TenantID) {
|
||||
var body cultivateRelationsRequest
|
||||
if !decodeIMJSONBody(w, r, &body) {
|
||||
return
|
||||
}
|
||||
if body.ViewerID <= 0 || len(body.PeerIDs) > 500 {
|
||||
writeIMError(w, r, http.StatusBadRequest, 30000, imReasonMalformedRequest, "malformed request", nil)
|
||||
return
|
||||
}
|
||||
viewer := store.EncodeUid(body.ViewerID)
|
||||
items := make([]map[string]any, 0, len(body.PeerIDs))
|
||||
for _, rawID := range body.PeerIDs {
|
||||
if rawID <= 0 || rawID == body.ViewerID {
|
||||
continue
|
||||
}
|
||||
peer := store.EncodeUid(rawID)
|
||||
ctx, err := store.Relations.GetRelationshipContext(tenantID, viewer, peer, viewer.P2PName(peer))
|
||||
if err != nil || ctx == nil {
|
||||
continue
|
||||
}
|
||||
items = append(items, map[string]any{"peer_id": rawID, "relationship": ctx.Relationship, "can_send": ctx.CanSend})
|
||||
}
|
||||
youth := false
|
||||
if settings, err := store.Security.GetYouthMode(tenantID, viewer); err == nil && settings != nil {
|
||||
youth = settings.Enabled
|
||||
}
|
||||
writeIMSuccess(w, r, map[string]any{"items": items, "viewer_youth_mode": youth})
|
||||
}
|
||||
|
||||
func serveCultivateFiles(w http.ResponseWriter, r *http.Request, tenantID types.TenantID) {
|
||||
var body cultivateFilesRequest
|
||||
if !decodeIMJSONBody(w, r, &body) {
|
||||
return
|
||||
}
|
||||
if body.UserID <= 0 || len(body.FileIDs) == 0 || len(body.FileIDs) > 20 {
|
||||
writeIMError(w, r, http.StatusBadRequest, 30000, imReasonMalformedRequest, "malformed request", nil)
|
||||
return
|
||||
}
|
||||
uid := store.EncodeUid(body.UserID)
|
||||
items := make([]map[string]any, 0, len(body.FileIDs))
|
||||
for _, supplied := range body.FileIDs {
|
||||
fileID := normalizeIMUploadedFileID(supplied)
|
||||
file, err := store.Files.Get(tenantID, fileID)
|
||||
owner := types.ParseUid(fileOwner(file))
|
||||
if owner.IsZero() {
|
||||
owner = types.ParseUserId(fileOwner(file))
|
||||
}
|
||||
if err != nil || file == nil || file.Status != types.UploadCompleted || owner != uid {
|
||||
writeIMError(w, r, http.StatusUnprocessableEntity, 30000, imReasonMalformedRequest, "invalid file", map[string]any{"file_id": supplied})
|
||||
return
|
||||
}
|
||||
items = append(items, map[string]any{"file_id": fileID, "mime_type": file.MimeType, "size": file.Size, "review_status": cultivateFileReviewStatus(tenantID, fileID)})
|
||||
}
|
||||
writeIMSuccess(w, r, map[string]any{"items": items})
|
||||
}
|
||||
|
||||
func fileOwner(file *types.FileDef) string {
|
||||
if file == nil {
|
||||
return ""
|
||||
}
|
||||
return file.User
|
||||
}
|
||||
|
||||
func cultivateFileReviewStatus(tenantID types.TenantID, fileID string) string {
|
||||
uid := types.ParseUid(fileID)
|
||||
if uid.IsZero() {
|
||||
return "unconfigured"
|
||||
}
|
||||
row, err := store.InternalAdminQueries.QueryOne(tenantID, `SELECT COUNT(*) AS total,
|
||||
SUM(status='risky') AS risky_count,
|
||||
SUM(status IN ('pending','running','failed')) AS pending_count
|
||||
FROM im_file_review_tasks WHERE file_id=?`, []any{store.DecodeUid(uid)})
|
||||
if err != nil {
|
||||
return "unconfigured"
|
||||
}
|
||||
total, _ := numericID(row["total"])
|
||||
risky, _ := numericID(row["risky_count"])
|
||||
pending, _ := numericID(row["pending_count"])
|
||||
if risky > 0 {
|
||||
return "risky"
|
||||
}
|
||||
if pending > 0 {
|
||||
return "pending"
|
||||
}
|
||||
if total > 0 {
|
||||
return "clean"
|
||||
}
|
||||
return "unconfigured"
|
||||
}
|
||||
|
||||
func serveCultivateReview(w http.ResponseWriter, r *http.Request, tenant *types.Tenant) {
|
||||
var body cultivateReviewRequest
|
||||
if !decodeIMJSONBody(w, r, &body) {
|
||||
return
|
||||
}
|
||||
if body.ActorID <= 0 || body.ObjectID <= 0 {
|
||||
writeIMError(w, r, http.StatusBadRequest, 30000, imReasonMalformedRequest, "malformed request", nil)
|
||||
return
|
||||
}
|
||||
scene := moderation.SceneFeedPost
|
||||
if body.ObjectType == "comment" {
|
||||
scene = moderation.SceneFeedComment
|
||||
} else if body.ObjectType != "post" {
|
||||
writeIMError(w, r, http.StatusBadRequest, 30000, imReasonMalformedRequest, "malformed request", map[string]any{"field": "object_type"})
|
||||
return
|
||||
}
|
||||
result, err := moderation.Review(r.Context(), moderation.Request{TenantID: tenant.ID, TenantCode: tenant.Code, Scene: scene, ActorID: store.EncodeUid(body.ActorID), Text: body.Text, TraceID: body.TraceID})
|
||||
if result == nil {
|
||||
result = &moderation.Result{Action: moderation.ActionAuditOnly}
|
||||
}
|
||||
data := map[string]any{"request_id": result.RequestID, "action": result.Action, "risk_level": result.RiskLevel, "risk_labels": result.RiskLabels, "provider": result.Provider, "provider_request_id": result.ProviderRequestID}
|
||||
if errors.Is(err, moderation.ErrUnavailable) {
|
||||
writeIMError(w, r, http.StatusServiceUnavailable, 50001, imReasonInternal, "content review unavailable", data)
|
||||
return
|
||||
}
|
||||
// A moderation rejection is a valid review decision, not a transport error.
|
||||
writeIMSuccess(w, r, data)
|
||||
}
|
||||
|
||||
func serveCultivateEvent(w http.ResponseWriter, r *http.Request, tenantID types.TenantID) {
|
||||
var body cultivateEventRequest
|
||||
if !decodeIMJSONBody(w, r, &body) {
|
||||
return
|
||||
}
|
||||
if body.EventID == "" || body.EventType == "" || body.TargetUserID <= 0 {
|
||||
writeIMError(w, r, http.StatusBadRequest, 30000, imReasonMalformedRequest, "malformed request", nil)
|
||||
return
|
||||
}
|
||||
target, actor := store.EncodeUid(body.TargetUserID), store.EncodeUid(body.ActorID)
|
||||
if body.Title != "" {
|
||||
if err := createIMSystemNotification(tenantID, target, stableIMEventID(body.EventID, "notification"), body.EventType, body.Title, body.Summary, types.KVMap(body.Action)); err != nil {
|
||||
if errors.Is(err, types.ErrDuplicate) {
|
||||
writeIMSuccess(w, r, map[string]any{"event_id": body.EventID, "duplicate": true})
|
||||
return
|
||||
}
|
||||
writeIMError(w, r, http.StatusInternalServerError, 90000, imReasonInternal, "internal error", nil)
|
||||
return
|
||||
}
|
||||
}
|
||||
if err := enqueueIMBusinessEvent(tenantID, body.EventID, "user", target.UserId(), actor, body.EventType, body.Payload); err != nil {
|
||||
writeIMError(w, r, http.StatusInternalServerError, 90000, imReasonInternal, "internal error", nil)
|
||||
return
|
||||
}
|
||||
if body.Title != "" {
|
||||
sendPush(&push.Receipt{TenantID: tenantID, To: map[types.Uid]push.Recipient{target: {}}, Payload: push.Payload{
|
||||
What: push.ActMsg, Topic: "sys", Timestamp: time.Now().UTC(), ContentType: "application/json",
|
||||
Content: map[string]any{"event_id": body.EventID, "event_type": body.EventType, "title": body.Title, "summary": body.Summary, "action": body.Action},
|
||||
}})
|
||||
}
|
||||
writeIMSuccess(w, r, map[string]any{"event_id": body.EventID})
|
||||
}
|
||||
Reference in New Issue
Block a user