im_manager/server/internal/logic/sys/cultivate_content.go

package sys

import (
	"context"
	"net/url"
	"strings"

	"hotgo/internal/library/cultivateadmin"
	"hotgo/internal/model/input/sysin"
	"hotgo/internal/service"
)

type sSysCultivateContent struct{}

func NewSysCultivateContent() *sSysCultivateContent { return &sSysCultivateContent{} }
func init()                                         { service.RegisterSysCultivateContent(NewSysCultivateContent()) }

func (s *sSysCultivateContent) Dashboard(ctx context.Context, in *sysin.CultivateDashboardInp) (*sysin.CultivateDashboardModel, error) {
	if err := in.Filter(ctx); err != nil {
		return nil, err
	}
	scope, err := cultivateAdminScope(ctx)
	if err != nil {
		return nil, err
	}
	result := new(sysin.CultivateDashboardModel)
	if err = cultivateadmin.DefaultClient(ctx).Get(ctx, scope, "/dashboard", nil, result); err != nil {
		return nil, err
	}
	return result, nil
}

func (s *sSysCultivateContent) List(ctx context.Context, in *sysin.CultivateContentListInp) (list []*sysin.CultivateContentListModel, totalCount int, err error) {
	if err = in.Filter(ctx); err != nil {
		return nil, 0, err
	}
	scope, err := cultivateAdminScope(ctx)
	if err != nil {
		return nil, 0, err
	}
	normalizeCultivatePage(&in.PageReq)
	values := cultivatePageValues(in.Page, in.PerPage)
	cultivateSetQuery(values, "object_type", in.ObjectType)
	cultivateSetQuery(values, "author_id", in.AuthorId)
	cultivateSetQuery(values, "status", in.Status)
	cultivateSetQuery(values, "keyword", in.Keyword)
	setTimeRange(values, in.CreatedAt)
	var page cultivateadmin.Page[*sysin.CultivateContentListModel]
	if err = cultivateadmin.DefaultClient(ctx).Get(ctx, scope, "/content-reviews", values, &page); err != nil {
		return nil, 0, err
	}
	if page.Items == nil {
		page.Items = []*sysin.CultivateContentListModel{}
	}
	return page.Items, page.Total, nil
}

func (s *sSysCultivateContent) View(ctx context.Context, in *sysin.CultivateContentViewInp) (*sysin.CultivateContentViewModel, error) {
	if err := in.Filter(ctx); err != nil {
		return nil, err
	}
	scope, err := cultivateAdminScope(ctx)
	if err != nil {
		return nil, err
	}
	result := new(sysin.CultivateContentViewModel)
	path := "/content-reviews/" + url.PathEscape(in.ObjectType) + "/" + url.PathEscape(in.Id)
	if err = cultivateadmin.DefaultClient(ctx).Get(ctx, scope, path, nil, result); err != nil {
		return nil, err
	}
	return result, nil
}

func (s *sSysCultivateContent) Review(ctx context.Context, in *sysin.CultivateContentReviewInp) error {
	if err := in.Filter(ctx); err != nil {
		return err
	}
	scope, err := cultivateAdminScope(ctx)
	if err != nil {
		return err
	}
	path := "/content-reviews/" + url.PathEscape(in.ObjectType) + "/" + url.PathEscape(in.Id) + "/actions"
	return cultivateadmin.DefaultClient(ctx).Post(ctx, scope, path, map[string]any{"action": in.Action, "reason": strings.TrimSpace(in.Reason)}, nil)
}

func (s *sSysCultivateContent) BatchReview(ctx context.Context, in *sysin.CultivateContentBatchReviewInp) (*sysin.CultivateContentBatchReviewModel, error) {
	if err := in.Filter(ctx); err != nil {
		return nil, err
	}
	scope, err := cultivateAdminScope(ctx)
	if err != nil {
		return nil, err
	}
	result := new(sysin.CultivateContentBatchReviewModel)
	err = cultivateadmin.DefaultClient(ctx).Post(ctx, scope, "/content-reviews/batch-actions", map[string]any{
		"object_type": in.ObjectType, "ids": in.Ids, "action": in.Action, "reason": strings.TrimSpace(in.Reason),
	}, result)
	if err != nil {
		return nil, err
	}
	return result, nil
}

func (s *sSysCultivateContent) ReportList(ctx context.Context, in *sysin.CultivateReportListInp) (list []*sysin.CultivateReportListModel, totalCount int, err error) {
	if err = in.Filter(ctx); err != nil {
		return nil, 0, err
	}
	scope, err := cultivateAdminScope(ctx)
	if err != nil {
		return nil, 0, err
	}
	normalizeCultivatePage(&in.PageReq)
	values := cultivatePageValues(in.Page, in.PerPage)
	cultivateSetQuery(values, "object_type", in.ObjectType)
	cultivateSetQuery(values, "status", in.Status)
	cultivateSetQuery(values, "reporter_id", in.ReporterId)
	setTimeRange(values, in.CreatedAt)
	var page cultivateadmin.Page[*sysin.CultivateReportListModel]
	if err = cultivateadmin.DefaultClient(ctx).Get(ctx, scope, "/reports", values, &page); err != nil {
		return nil, 0, err
	}
	if page.Items == nil {
		page.Items = []*sysin.CultivateReportListModel{}
	}
	return page.Items, page.Total, nil
}

func (s *sSysCultivateContent) ReportView(ctx context.Context, in *sysin.CultivateReportViewInp) (*sysin.CultivateReportViewModel, error) {
	if err := in.Filter(ctx); err != nil {
		return nil, err
	}
	scope, err := cultivateAdminScope(ctx)
	if err != nil {
		return nil, err
	}
	result := new(sysin.CultivateReportViewModel)
	if err = cultivateadmin.DefaultClient(ctx).Get(ctx, scope, "/reports/"+url.PathEscape(in.Id), nil, result); err != nil {
		return nil, err
	}
	return result, nil
}

func (s *sSysCultivateContent) ReportHandle(ctx context.Context, in *sysin.CultivateReportHandleInp) error {
	if err := in.Filter(ctx); err != nil {
		return err
	}
	scope, err := cultivateAdminScope(ctx)
	if err != nil {
		return err
	}
	return cultivateadmin.DefaultClient(ctx).Post(ctx, scope, "/reports/"+url.PathEscape(in.Id)+"/actions", map[string]any{
		"action": in.Action, "handle_result": in.HandleResult, "content_action": in.ContentAction,
		"user_action": in.UserAction, "reason": in.Reason,
	}, nil)
}

func (s *sSysCultivateContent) LogList(ctx context.Context, in *sysin.CultivateOperationLogListInp) (list []*sysin.CultivateOperationLogListModel, totalCount int, err error) {
	if err = in.Filter(ctx); err != nil {
		return nil, 0, err
	}
	scope, err := cultivateAdminScope(ctx)
	if err != nil {
		return nil, 0, err
	}
	normalizeCultivatePage(&in.PageReq)
	values := cultivatePageValues(in.Page, in.PerPage)
	cultivateSetQuery(values, "operator_id", in.OperatorId)
	cultivateSetQuery(values, "operation_type", in.OperationType)
	cultivateSetQuery(values, "target_type", in.TargetType)
	cultivateSetQuery(values, "target_id", in.TargetId)
	cultivateSetQuery(values, "request_id", in.RequestId)
	setTimeRange(values, in.CreatedAt)
	var page cultivateadmin.Page[*sysin.CultivateOperationLogListModel]
	if err = cultivateadmin.DefaultClient(ctx).Get(ctx, scope, "/operation-logs", values, &page); err != nil {
		return nil, 0, err
	}
	if page.Items == nil {
		page.Items = []*sysin.CultivateOperationLogListModel{}
	}
	return page.Items, page.Total, nil
}