Files
yunzerwebsiteallinone/go/services/oa_document.go
T
2026-11-16 17:22:50 +08:00

1771 lines
45 KiB
Go

package services
import (
"errors"
"fmt"
"sort"
"strconv"
"strings"
"time"
"server/models"
"github.com/beego/beego/v2/client/orm"
)
var (
ErrDocCategoryNotFound = errors.New("分类不存在")
ErrDocCategoryHasChild = errors.New("存在子分类,请先删除子分类")
ErrDocCategoryHasDoc = errors.New("分类下仍有文档,请先移动或删除")
ErrDocCategoryNameEmpty = errors.New("请输入分类名称")
ErrDocCategoryCircular = errors.New("不能将分类移动到自己或其子分类下")
ErrDocCategorySystem = errors.New("系统内置分类不可删除")
ErrDocCategoryNameKept = errors.New("该分类名称为系统保留,不可使用")
ErrDocCategorySystemLocked = errors.New("系统内置分类固定为一级分类,不可移动")
ErrDocNotFound = errors.New("文档不存在")
ErrDocTitleEmpty = errors.New("请输入文档标题")
ErrDocCategoryInvalid = errors.New("所属分类不存在")
ErrDocLinkSelf = errors.New("不能关联文档自身")
ErrDocLinkDuplicate = errors.New("该关联关系已存在")
ErrDocLinkTargetNotFound = errors.New("被关联的文档不存在")
ErrDocLinkNotFound = errors.New("关联关系不存在")
ErrDocIDEmpty = errors.New("请选择要操作的文档")
ErrDocNoPermission = errors.New("无权操作该私密文档")
)
type OaDocActor struct {
Tid int
UID uint64
OrgIDs []uint64
IsAdmin bool
}
func NewOaDocActor(tid int, uid uint64) OaDocActor {
models.EnsureOaDocDefaultCategories(tid)
actor := OaDocActor{Tid: tid, UID: uid, OrgIDs: []uint64{}}
var user models.SystemTenantUser
if err := models.Orm.QueryTable(new(models.SystemTenantUser)).
Filter("tid", tid).
Filter("uid", ResolveTenantUID(uint64(tid), uid)).
Filter("delete_time__isnull", true).
One(&user); err != nil {
return actor
}
actor.IsAdmin = user.GroupID == 0
if user.OrgID > 0 {
actor.OrgIDs = oaDocOrgSubTree(tid, user.OrgID)
}
return actor
}
func oaDocOrgSubTree(tid int, rootID uint64) []uint64 {
var orgs []models.BackendOrganization
if _, err := models.Orm.QueryTable(new(models.BackendOrganization)).
Filter("tid", tid).
Filter("delete_time__isnull", true).
All(&orgs); err != nil {
return []uint64{rootID}
}
children := make(map[uint64][]uint64, len(orgs))
for _, o := range orgs {
children[o.ParentID] = append(children[o.ParentID], o.ID)
}
result := []uint64{rootID}
var walk func(id uint64)
walk = func(id uint64) {
for _, cid := range children[id] {
if cid == rootID {
continue
}
result = append(result, cid)
walk(cid)
}
}
walk(rootID)
return result
}
func oaDocSharedDocIDs(a OaDocActor) []uint64 {
if a.UID == 0 && len(a.OrgIDs) == 0 {
return nil
}
orgIDs := a.OrgIDs
if len(orgIDs) == 0 {
orgIDs = []uint64{0}
}
userCond := orm.NewCondition().
And("share_type", models.DocShareTypeUser).
And("target_id", a.UID)
orgCond := orm.NewCondition().
And("share_type", models.DocShareTypeOrg).
And("target_id__in", orgIDs)
cond := orm.NewCondition().
And("tid", a.Tid).
AndCond(orm.NewCondition().OrCond(userCond).OrCond(orgCond))
var rows []models.OaDocShare
if _, err := models.Orm.QueryTable(new(models.OaDocShare)).SetCond(cond).All(&rows); err != nil {
return nil
}
seen := make(map[uint64]bool, len(rows))
ids := make([]uint64, 0, len(rows))
for _, r := range rows {
if !seen[r.DocID] {
seen[r.DocID] = true
ids = append(ids, r.DocID)
}
}
return ids
}
func oaDocVisibleCond(a OaDocActor) *orm.Condition {
if a.IsAdmin {
return nil
}
shared := oaDocSharedDocIDs(a)
if len(shared) == 0 {
shared = []uint64{0}
}
return orm.NewCondition().
Or("visibility", models.DocVisibilityPublic).
Or("creator_id", a.UID).
Or("id__in", shared)
}
func oaDocApplyVisible(qs orm.QuerySeter, a OaDocActor) orm.QuerySeter {
cond := oaDocVisibleCond(a)
if cond == nil {
return qs
}
return qs.SetCond(qs.GetCond().AndCond(cond))
}
func oaDocVisibilityRestrictSQL(a OaDocActor, prefix string) (string, []interface{}) {
if a.IsAdmin {
return "", nil
}
shared := oaDocSharedDocIDs(a)
if len(shared) == 0 {
shared = []uint64{0}
}
placeholders := make([]string, len(shared))
for i := range shared {
placeholders[i] = "?"
}
args := []interface{}{a.UID}
for _, id := range shared {
args = append(args, id)
}
return fmt.Sprintf(
" AND (%svisibility = 0 OR %screator_id = ? OR %sid IN (%s))",
prefix, prefix, prefix, strings.Join(placeholders, ",")), args
}
func oaDocApplyVisibility(qs orm.QuerySeter, v int) orm.QuerySeter {
switch v {
case 0:
return qs.Filter("visibility", models.DocVisibilityPublic)
case 1:
return qs.Filter("visibility", models.DocVisibilityPrivate)
default:
return qs
}
}
func oaDocVisibleIDSet(a OaDocActor, ids []uint64) map[uint64]bool {
out := make(map[uint64]bool, len(ids))
if len(ids) == 0 {
return out
}
var idList orm.ParamsList
qs := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id__in", ids), a)
if _, err := qs.ValuesFlat(&idList, "Id"); err != nil {
return out
}
for _, v := range idList {
if id, err := strconv.ParseUint(fmt.Sprint(v), 10, 64); err == nil {
out[id] = true
}
}
return out
}
func oaDocCanManage(a OaDocActor, doc *models.OaDoc) bool {
if a.IsAdmin || doc.Visibility != models.DocVisibilityPrivate {
return true
}
return doc.CreatorID == a.UID
}
var docRelationLabel = map[string]string{
models.DocRelationReference: "引用",
models.DocRelationRelated: "相关",
models.DocRelationVersion: "版本",
models.DocRelationBelong: "从属",
}
func DocRelationLabel(relation string) string {
if v, ok := docRelationLabel[relation]; ok {
return v
}
return relation
}
type OaDocCategoryItem struct {
models.OaDocCategory
DocCount int64 `json:"doc_count"`
Children []*OaDocCategoryItem `json:"children"`
}
func oaDocScopeOf(scope string) string {
if scope == models.DocScopePersonal {
return models.DocScopePersonal
}
if scope == models.DocScopeAll {
return models.DocScopeAll
}
return models.DocScopeShared
}
func oaDocScopeVisibility(scope string) int8 {
if scope == models.DocScopePersonal {
return models.DocVisibilityPrivate
}
return models.DocVisibilityPublic
}
func oaDocScopeOfVisibility(v int8) string {
if v == models.DocVisibilityPrivate {
return models.DocScopePersonal
}
return models.DocScopeShared
}
func oaDocCategoryUserID(a OaDocActor, scope string) uint64 {
if scope == models.DocScopePersonal {
return a.UID
}
return 0
}
func oaDocCategoryBaseAny(tid int) orm.QuerySeter {
return models.Orm.QueryTable(new(models.OaDocCategory)).
Filter("tid", tid).
Filter("is_deleted", 0)
}
func oaDocCategoryBase(a OaDocActor, scope string) orm.QuerySeter {
s := oaDocScopeOf(scope)
if s == models.DocScopeAll {
return oaDocCategoryBaseAny(a.Tid)
}
qs := oaDocCategoryBaseAny(a.Tid).Filter("scope", s)
if s == models.DocScopePersonal {
qs = qs.Filter("user_id", a.UID)
} else if s == models.DocScopeShared {
qs = qs.Filter("user_id", 0)
}
return qs
}
func oaDocCategoryIDs(a OaDocActor, scope string) ([]uint64, error) {
var list []models.OaDocCategory
qs := oaDocCategoryBaseAny(a.Tid)
if scope != models.DocScopeAll {
s := oaDocScopeOf(scope)
qs = qs.Filter("scope", s)
if s == models.DocScopePersonal {
qs = qs.Filter("user_id", a.UID)
} else if s == models.DocScopeShared {
qs = qs.Filter("user_id", 0)
}
}
if _, err := qs.All(&list); err != nil && err != orm.ErrNoRows {
return nil, err
}
ids := make([]uint64, 0, len(list))
for _, c := range list {
ids = append(ids, c.ID)
}
return ids, nil
}
func oaDocApplyUncategorized(qs orm.QuerySeter, a OaDocActor, scope string) orm.QuerySeter {
ids, err := oaDocCategoryIDs(a, scope)
if err != nil || len(ids) == 0 {
return qs
}
return qs.Exclude("category_id__in", ids)
}
func OaDocCategoryTree(a OaDocActor, scope string) ([]*OaDocCategoryItem, error) {
scope = oaDocScopeOf(scope)
var list []models.OaDocCategory
if _, err := oaDocCategoryBase(a, scope).OrderBy("-is_system", "sort", "id").All(&list); err != nil && err != orm.ErrNoRows {
return nil, err
}
counts, err := OaDocCountByCategory(a, scope, -1)
if err != nil {
return nil, err
}
nodes := make(map[uint64]*OaDocCategoryItem, len(list))
roots := make([]*OaDocCategoryItem, 0, len(list))
for i := range list {
item := &OaDocCategoryItem{
OaDocCategory: list[i],
DocCount: counts[list[i].ID],
Children: []*OaDocCategoryItem{},
}
nodes[item.ID] = item
}
for i := range list {
item := nodes[list[i].ID]
if parent, ok := nodes[list[i].ParentID]; ok && list[i].ParentID != 0 {
parent.Children = append(parent.Children, item)
} else {
roots = append(roots, item)
}
}
var rollup func(item *OaDocCategoryItem) int64
rollup = func(item *OaDocCategoryItem) int64 {
total := item.DocCount
for _, child := range item.Children {
total += rollup(child)
}
item.DocCount = total
return total
}
for _, root := range roots {
rollup(root)
}
return roots, nil
}
func OaDocCountByCategory(a OaDocActor, scope string, visibility int) (map[uint64]int64, error) {
scope = oaDocScopeOf(scope)
sql := "SELECT category_id, COUNT(*) AS cnt FROM yz_backend_oa_doc WHERE tid = ? AND is_deleted = 0"
args := []interface{}{a.Tid}
if scope != models.DocScopeAll {
vis := int8(0)
if visibility >= 0 {
vis = int8(visibility)
} else {
vis = oaDocScopeVisibility(scope)
}
sql += fmt.Sprintf(" AND visibility = %d", vis)
}
extra, extraArgs := oaDocVisibilityRestrictSQL(a, "")
sql += extra
args = append(args, extraArgs...)
sql += " GROUP BY category_id"
var rows []struct {
CategoryID uint64 `orm:"column(category_id)"`
Cnt int64 `orm:"column(cnt)"`
}
if _, err := models.Orm.Raw(sql, args...).QueryRows(&rows); err != nil {
return nil, err
}
result := make(map[uint64]int64, len(rows))
for _, r := range rows {
result[r.CategoryID] = r.Cnt
}
return result, nil
}
func oaDocIsReservedName(name string) bool {
name = strings.TrimSpace(name)
return name == "未分类" || name == models.DocCategoryNameProject
}
func OaDocCategoryCreate(a OaDocActor, scope string, parentID uint64, name, remark string, sort int) (*models.OaDocCategory, error) {
scope = oaDocScopeOf(scope)
name = strings.TrimSpace(name)
if name == "" {
return nil, ErrDocCategoryNameEmpty
}
if oaDocIsReservedName(name) {
return nil, ErrDocCategoryNameKept
}
if parentID != 0 {
ok, err := oaDocCategoryExists(a, scope, parentID)
if err != nil {
return nil, err
}
if !ok {
return nil, ErrDocCategoryNotFound
}
}
item := &models.OaDocCategory{
Tid: a.Tid,
UserID: oaDocCategoryUserID(a, scope),
ParentID: parentID,
Name: name,
Remark: strings.TrimSpace(remark),
Sort: sort,
Scope: scope,
IsDeleted: 0,
}
if _, err := models.Orm.Insert(item); err != nil {
return nil, err
}
return item, nil
}
func OaDocCategoryUpdate(a OaDocActor, id uint64, name, remark string, sort int, parentID int64) (*models.OaDocCategory, error) {
var item models.OaDocCategory
if err := oaDocCategoryBaseAny(a.Tid).Filter("id", id).One(&item); err != nil {
return nil, ErrDocCategoryNotFound
}
if err := oaDocCheckCategoryOwner(a, &item); err != nil {
return nil, err
}
fields := []string{"UpdateTime"}
if name = strings.TrimSpace(name); name != "" && name != item.Name {
if item.IsSystem != models.DocCategorySystem && oaDocIsReservedName(name) {
return nil, ErrDocCategoryNameKept
}
item.Name = name
fields = append(fields, "Name")
}
if remark = strings.TrimSpace(remark); remark != item.Remark {
item.Remark = remark
fields = append(fields, "Remark")
}
if sort >= 0 && sort != item.Sort {
item.Sort = sort
fields = append(fields, "Sort")
}
if parentID >= 0 && uint64(parentID) != item.ParentID {
if item.IsSystem == models.DocCategorySystem {
return nil, ErrDocCategorySystemLocked
}
newParent := uint64(parentID)
if newParent == id {
return nil, ErrDocCategoryCircular
}
if newParent != 0 {
ok, err := oaDocCategoryExists(a, item.Scope, newParent)
if err != nil {
return nil, err
}
if !ok {
return nil, ErrDocCategoryNotFound
}
childIDs, err := OaDocCategoryDescendants(a, newParent)
if err != nil {
return nil, err
}
for _, cid := range childIDs {
if cid == newParent {
return nil, ErrDocCategoryCircular
}
}
}
item.ParentID = newParent
fields = append(fields, "ParentID")
}
if len(fields) == 1 {
return &item, nil
}
now := time.Now()
item.UpdateTime = &now
if _, err := models.Orm.Update(&item, fields...); err != nil {
return nil, err
}
return &item, nil
}
func OaDocCategoryDescendants(a OaDocActor, rootID uint64) ([]uint64, error) {
var list []models.OaDocCategory
if _, err := oaDocCategoryBaseAny(a.Tid).All(&list); err != nil && err != orm.ErrNoRows {
return nil, err
}
children := make(map[uint64][]uint64)
for _, c := range list {
children[c.ParentID] = append(children[c.ParentID], c.ID)
}
result := make([]uint64, 0, len(list))
var walk func(id uint64)
walk = func(id uint64) {
for _, cid := range children[id] {
if cid == rootID {
continue
}
result = append(result, cid)
walk(cid)
}
}
walk(rootID)
return result, nil
}
func oaDocCategoryIDsWithChildren(a OaDocActor, scope string, rootID uint64) ([]uint64, error) {
if rootID == 0 {
return nil, nil
}
children, err := OaDocCategoryDescendants(a, rootID)
if err != nil {
return nil, err
}
return append([]uint64{rootID}, children...), nil
}
func OaDocCategoryDelete(a OaDocActor, id uint64) error {
var item models.OaDocCategory
if err := oaDocCategoryBaseAny(a.Tid).Filter("id", id).One(&item); err != nil {
return ErrDocCategoryNotFound
}
if item.IsSystem == models.DocCategorySystem {
return ErrDocCategorySystem
}
if err := oaDocCheckCategoryOwner(a, &item); err != nil {
return err
}
childCount, err := oaDocCategoryBase(a, item.Scope).Filter("parent_id", id).Count()
if err != nil {
return err
}
if childCount > 0 {
return ErrDocCategoryHasChild
}
docCount, err := oaDocBase(a.Tid).Filter("category_id", id).Count()
if err != nil {
return err
}
if docCount > 0 {
return ErrDocCategoryHasDoc
}
now := time.Now()
_, err = oaDocCategoryBaseAny(a.Tid).Filter("id", id).Update(orm.Params{
"IsDeleted": 1,
"DeleteTime": now,
"UpdateTime": now,
})
return err
}
func oaDocCategoryExists(a OaDocActor, scope string, id uint64) (bool, error) {
n, err := oaDocCategoryBase(a, scope).Filter("id", id).Count()
if err != nil {
return false, err
}
return n > 0, nil
}
func oaDocCheckCategoryOwner(a OaDocActor, item *models.OaDocCategory) error {
if item.UserID == 0 {
return nil
}
if item.UserID == a.UID && a.UID != 0 {
return nil
}
return ErrDocCategoryNotFound
}
func oaDocCategoryUsable(a OaDocActor, scope string, id uint64) (models.OaDocCategory, bool, error) {
var item models.OaDocCategory
if err := oaDocCategoryBase(a, scope).Filter("id", id).One(&item); err != nil {
return item, false, nil
}
return item, true, nil
}
func oaDocBase(tid int) orm.QuerySeter {
return models.Orm.QueryTable(new(models.OaDoc)).
Filter("tid", tid).
Filter("is_deleted", 0)
}
type OaDocListParams struct {
Actor OaDocActor
Scope string
Keyword string
CategoryID uint64
Uncategorized bool
Visibility int
Mine bool
Status int
DocType int
Tag string
Star int
Page int
PageSize int
}
func OaDocList(a OaDocActor, p OaDocListParams) ([]models.OaDoc, int64, error) {
scope := oaDocScopeOf(p.Scope)
qs := oaDocApplyVisible(oaDocBase(a.Tid), a)
if scope != models.DocScopeAll {
qs = qs.Filter("visibility", oaDocScopeVisibility(scope))
}
if p.Mine {
qs = qs.Filter("creator_id", a.UID)
}
if kw := strings.TrimSpace(p.Keyword); kw != "" {
cond := orm.NewCondition()
cond = cond.Or("title__icontains", kw).
Or("file_name__icontains", kw).
Or("tags__icontains", kw).
Or("summary__icontains", kw).
Or("owner_name__icontains", kw)
qs = qs.SetCond(qs.GetCond().AndCond(cond))
}
if p.Uncategorized {
qs = oaDocApplyUncategorized(qs, a, scope)
} else if p.CategoryID > 0 {
ids, err := oaDocCategoryIDsWithChildren(a, scope, p.CategoryID)
if err != nil {
return nil, 0, err
}
if len(ids) > 0 {
qs = qs.Filter("category_id__in", ids)
} else {
qs = qs.Filter("category_id__in", []uint64{})
}
}
if p.Status >= 0 {
qs = qs.Filter("status", int8(p.Status))
}
if p.DocType >= 0 {
qs = qs.Filter("doc_type", int8(p.DocType))
}
if tag := strings.TrimSpace(p.Tag); tag != "" {
qs = qs.Filter("tags__icontains", tag)
}
if p.Star == 1 {
qs = qs.Filter("is_star", 1)
}
total, err := qs.Count()
if err != nil {
return nil, 0, err
}
page, pageSize := p.Page, p.PageSize
if page < 1 {
page = 1
}
if pageSize < 1 {
pageSize = 20
}
var list []models.OaDoc
_, err = qs.OrderBy("-is_star", "-update_time", "-id").
Limit(pageSize).Offset((page - 1) * pageSize).
All(&list)
if err != nil && err != orm.ErrNoRows {
return nil, 0, err
}
if list == nil {
list = []models.OaDoc{}
}
for i := range list {
if strings.TrimSpace(list[i].Content) != "" {
list[i].IsOnline = 1
}
list[i].Content = ""
}
return list, total, nil
}
func OaDocGet(a OaDocActor, id uint64) (*models.OaDoc, error) {
var item models.OaDoc
qs := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id", id), a)
if err := qs.One(&item); err != nil {
return nil, ErrDocNotFound
}
return &item, nil
}
func OaDocView(a OaDocActor, id uint64) (*models.OaDoc, error) {
item, err := OaDocGet(a, id)
if err != nil {
return nil, err
}
_, _ = models.Orm.Raw(
"UPDATE yz_backend_oa_doc SET view_count = view_count + 1 WHERE id = ?", id).Exec()
item.ViewCount++
return item, nil
}
func OaDocDownload(a OaDocActor, id uint64) (*models.OaDoc, error) {
item, err := OaDocGet(a, id)
if err != nil {
return nil, err
}
_, _ = models.Orm.Raw(
"UPDATE yz_backend_oa_doc SET download_count = download_count + 1 WHERE id = ?", id).Exec()
item.DownCount++
return item, nil
}
type OaDocSaveParams struct {
SetCategory bool
CategoryID uint64
SetVisibility bool
Title string
FileID uint64
FileURL string
FileName string
Ext string
Size uint64
Tags string
Summary string
SetContent bool
Content string
Status int8
Version int
OwnerID uint64
OwnerName string
IsStar int8
Visibility int8
}
func OaDocCreate(a OaDocActor, operatorName string, p OaDocSaveParams) (*models.OaDoc, error) {
tid := a.Tid
title := strings.TrimSpace(p.Title)
if title == "" {
title = strings.TrimSpace(strings.TrimSuffix(p.FileName, "."+p.Ext))
}
if title == "" {
return nil, ErrDocTitleEmpty
}
if p.CategoryID > 0 {
scope := oaDocScopeOfVisibility(p.Visibility)
if _, ok, err := oaDocCategoryUsable(a, scope, p.CategoryID); err != nil {
return nil, err
} else if !ok {
return nil, ErrDocCategoryInvalid
}
}
ext := strings.ToLower(strings.TrimPrefix(strings.TrimSpace(p.Ext), "."))
version := p.Version
if version < 1 {
version = 1
}
if p.Status < 0 || p.Status > 2 {
p.Status = models.DocStatusDraft
}
if p.IsStar != 1 {
p.IsStar = 0
}
item := &models.OaDoc{
Tid: tid,
CategoryID: p.CategoryID,
Title: title,
FileID: p.FileID,
FileURL: strings.TrimSpace(p.FileURL),
FileName: strings.TrimSpace(p.FileName),
Ext: ext,
Size: p.Size,
DocType: models.DocTypeByExt(ext),
Tags: strings.TrimSpace(p.Tags),
Summary: strings.TrimSpace(p.Summary),
Content: p.Content,
Status: p.Status,
Version: version,
IsStar: p.IsStar,
OwnerID: p.OwnerID,
OwnerName: strings.TrimSpace(p.OwnerName),
CreatorID: a.UID,
CreatorName: operatorName,
Visibility: visibilityOf(p.Visibility),
IsDeleted: 0,
}
if _, err := models.Orm.Insert(item); err != nil {
return nil, err
}
return item, nil
}
func visibilityOf(v int8) int8 {
if v == 1 {
return 1
}
return 0
}
func OaDocUpdate(a OaDocActor, id uint64, p OaDocSaveParams) (*models.OaDoc, error) {
var item models.OaDoc
if err := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id", id), a).One(&item); err != nil {
return nil, ErrDocNotFound
}
if !oaDocCanManage(a, &item) {
return nil, ErrDocNoPermission
}
fields := []string{"UpdateTime"}
if p.SetCategory && p.CategoryID != item.CategoryID {
if p.CategoryID > 0 {
v := item.Visibility
if p.SetVisibility {
v = p.Visibility
}
scope := oaDocScopeOfVisibility(v)
if _, ok, err := oaDocCategoryUsable(a, scope, p.CategoryID); err != nil {
return nil, err
} else if !ok {
return nil, ErrDocCategoryInvalid
}
}
item.CategoryID = p.CategoryID
fields = append(fields, "CategoryID")
}
if p.SetVisibility {
if v := visibilityOf(p.Visibility); v != item.Visibility {
item.Visibility = v
fields = append(fields, "Visibility")
}
}
if title := strings.TrimSpace(p.Title); title != "" && title != item.Title {
item.Title = title
fields = append(fields, "Title")
}
if url := strings.TrimSpace(p.FileURL); url != "" {
item.FileURL = url
fields = append(fields, "FileURL")
if p.FileID > 0 {
item.FileID = p.FileID
fields = append(fields, "FileID")
}
if name := strings.TrimSpace(p.FileName); name != "" {
item.FileName = name
fields = append(fields, "FileName")
}
if ext := strings.ToLower(strings.TrimPrefix(strings.TrimSpace(p.Ext), ".")); ext != "" {
item.Ext = ext
item.DocType = models.DocTypeByExt(ext)
fields = append(fields, "Ext", "DocType")
}
if p.Size > 0 {
item.Size = p.Size
fields = append(fields, "Size")
}
}
if tags := strings.TrimSpace(p.Tags); tags != item.Tags {
item.Tags = tags
fields = append(fields, "Tags")
}
if summary := strings.TrimSpace(p.Summary); summary != item.Summary {
item.Summary = summary
fields = append(fields, "Summary")
}
if p.Status >= 0 && p.Status <= 2 && p.Status != item.Status {
item.Status = p.Status
fields = append(fields, "Status")
}
if p.Version > 0 && p.Version != item.Version {
item.Version = p.Version
fields = append(fields, "Version")
}
if p.IsStar == 0 || p.IsStar == 1 {
if p.IsStar != item.IsStar {
item.IsStar = p.IsStar
fields = append(fields, "IsStar")
}
}
if p.OwnerID > 0 {
item.OwnerID = p.OwnerID
fields = append(fields, "OwnerID")
}
if owner := strings.TrimSpace(p.OwnerName); owner != "" && owner != item.OwnerName {
item.OwnerName = owner
fields = append(fields, "OwnerName")
}
if p.SetContent && p.Content != item.Content {
item.Content = p.Content
fields = append(fields, "Content")
}
if len(fields) == 1 {
return &item, nil
}
now := time.Now()
item.UpdateTime = &now
if _, err := models.Orm.Update(&item, fields...); err != nil {
return nil, err
}
return &item, nil
}
func OaDocDelete(a OaDocActor, ids []uint64) (int64, error) {
ids = normalizeIDs(ids)
if len(ids) == 0 {
return 0, ErrDocIDEmpty
}
var list []models.OaDoc
if _, err := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id__in", ids), a).All(&list); err != nil && err != orm.ErrNoRows {
return 0, err
}
allowed := make([]uint64, 0, len(list))
for _, d := range list {
if oaDocCanManage(a, &d) {
allowed = append(allowed, d.ID)
}
}
if len(allowed) == 0 {
return 0, ErrDocNoPermission
}
now := time.Now()
n, err := oaDocBase(a.Tid).Filter("id__in", allowed).Update(orm.Params{
"IsDeleted": 1,
"DeleteTime": now,
"UpdateTime": now,
})
if err != nil {
return 0, err
}
// 清理被删文档参与的全部关联关系,避免图谱出现悬挂连线
// 注意:SetCond 会整体替换查询条件,tid 必须写进 cond,否则会误删其它租户的数据
cond := orm.NewCondition().
And("tid", a.Tid).
AndCond(orm.NewCondition().
Or("source_id__in", allowed).
Or("target_id__in", allowed))
_, _ = models.Orm.QueryTable(new(models.OaDocLink)).SetCond(cond).Delete()
return n, nil
}
func OaDocMove(a OaDocActor, ids []uint64, categoryID uint64) (int64, error) {
ids = normalizeIDs(ids)
if len(ids) == 0 {
return 0, ErrDocIDEmpty
}
if categoryID > 0 {
var sample models.OaDoc
if _, err := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id__in", ids), a).OrderBy("id").Limit(1).All(&sample); err == nil {
scope := oaDocScopeOfVisibility(sample.Visibility)
if _, ok, err := oaDocCategoryUsable(a, scope, categoryID); err != nil {
return 0, err
} else if !ok {
return 0, ErrDocCategoryInvalid
}
}
}
var list []models.OaDoc
if _, err := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id__in", ids), a).All(&list); err != nil && err != orm.ErrNoRows {
return 0, err
}
allowed := make([]uint64, 0, len(list))
for _, d := range list {
if oaDocCanManage(a, &d) {
allowed = append(allowed, d.ID)
}
}
if len(allowed) == 0 {
return 0, ErrDocNoPermission
}
now := time.Now()
params := orm.Params{
"CategoryID": categoryID,
"UpdateTime": now,
}
return oaDocBase(a.Tid).Filter("id__in", allowed).Update(params)
}
func OaDocToggleStar(a OaDocActor, id uint64) (int8, error) {
var item models.OaDoc
if err := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id", id), a).One(&item); err != nil {
return 0, ErrDocNotFound
}
if item.IsStar == 1 {
item.IsStar = 0
} else {
item.IsStar = 1
}
if _, err := models.Orm.Update(&item, "IsStar"); err != nil {
return 0, err
}
return item.IsStar, nil
}
type OaDocStatsResult struct {
Total int64 `json:"total"`
Published int64 `json:"published"`
Draft int64 `json:"draft"`
Archived int64 `json:"archived"`
Starred int64 `json:"starred"`
Uncategorized int64 `json:"uncategorized"`
LinkCount int64 `json:"link_count"`
PublicCount int64 `json:"public_count"`
PrivateCount int64 `json:"private_count"`
MineCount int64 `json:"mine_count"`
TypeCounts []OaDocTypeCount `json:"type_counts"`
RecentDocs []models.OaDoc `json:"recent_docs"`
HotDocs []models.OaDoc `json:"hot_docs"`
}
type OaDocTypeCount struct {
DocType int8 `json:"doc_type"`
Count int64 `json:"count"`
}
func OaDocStats(a OaDocActor, scope string) (*OaDocStatsResult, error) {
scope = oaDocScopeOf(scope)
vis := int8(-1)
if scope != models.DocScopeAll {
vis = oaDocScopeVisibility(scope)
}
allVisible := oaDocApplyVisible(oaDocBase(a.Tid), a)
if vis >= 0 {
allVisible = allVisible.Filter("visibility", vis)
}
mineCount, _ := allVisible.Filter("creator_id", a.UID).Count()
base := allVisible
total, _ := base.Count()
published, _ := base.Filter("status", models.DocStatusPublish).Count()
draft, _ := base.Filter("status", models.DocStatusDraft).Count()
archived, _ := base.Filter("status", models.DocStatusArchive).Count()
starred, _ := base.Filter("is_star", 1).Count()
uncategorized, _ := oaDocApplyUncategorized(base, a, scope).Count()
linkCount := int64(0)
linkExtra, linkExtraArgs := oaDocVisibilityRestrictSQL(a, "d.")
linkArgs := []interface{}{a.Tid}
if vis >= 0 {
linkArgs = append(linkArgs, vis)
}
linkArgs = append(linkArgs, linkExtraArgs...)
var linkRows []struct {
Cnt int64 `orm:"column(cnt)"`
}
visClause := ""
if vis >= 0 {
visClause = " AND d.visibility = ?"
}
_, _ = models.Orm.Raw(
`SELECT COUNT(*) AS cnt FROM yz_backend_oa_doc_link l
WHERE l.tid = ?`+visClause+` AND EXISTS (
SELECT 1 FROM yz_backend_oa_doc d
WHERE d.id = l.source_id AND d.is_deleted = 0`+linkExtra+")",
linkArgs...).QueryRows(&linkRows)
if len(linkRows) > 0 {
linkCount = linkRows[0].Cnt
}
var rows []struct {
DocType int8 `orm:"column(doc_type)"`
Cnt int64 `orm:"column(cnt)"`
}
typeExtra, typeExtraArgs := oaDocVisibilityRestrictSQL(a, "")
typeArgs := []interface{}{a.Tid}
if vis >= 0 {
typeArgs = append(typeArgs, vis)
}
typeArgs = append(typeArgs, typeExtraArgs...)
_, _ = models.Orm.Raw(
"SELECT doc_type, COUNT(*) AS cnt FROM yz_backend_oa_doc WHERE tid = ? AND is_deleted = 0"+
visClause+typeExtra+" GROUP BY doc_type ORDER BY cnt DESC",
typeArgs...).QueryRows(&rows)
typeCounts := make([]OaDocTypeCount, 0, len(rows))
for _, r := range rows {
typeCounts = append(typeCounts, OaDocTypeCount{DocType: r.DocType, Count: r.Cnt})
}
var recent []models.OaDoc
_, _ = base.OrderBy("-update_time", "-id").Limit(8).All(&recent)
if recent == nil {
recent = []models.OaDoc{}
}
var hot []models.OaDoc
_, _ = base.OrderBy("-view_count", "-id").Limit(8).All(&hot)
if hot == nil {
hot = []models.OaDoc{}
}
publicCount, privateCount := int64(0), int64(0)
switch scope {
case models.DocScopeShared:
publicCount = total
case models.DocScopePersonal:
privateCount = total
case models.DocScopeAll:
publicCount, _ = oaDocApplyVisible(oaDocBase(a.Tid), a).Filter("visibility", models.DocVisibilityPublic).Count()
privateCount, _ = oaDocApplyVisible(oaDocBase(a.Tid), a).Filter("visibility", models.DocVisibilityPrivate).Count()
}
return &OaDocStatsResult{
Total: total,
Published: published,
Draft: draft,
Archived: archived,
Starred: starred,
Uncategorized: uncategorized,
LinkCount: linkCount,
PublicCount: publicCount,
PrivateCount: privateCount,
MineCount: mineCount,
TypeCounts: typeCounts,
RecentDocs: recent,
HotDocs: hot,
}, nil
}
type OaDocLinkItem struct {
ID uint64 `json:"id"`
Tid int `json:"tid"`
SourceID uint64 `json:"source_id"`
TargetID uint64 `json:"target_id"`
Relation string `json:"relation"`
RelationCN string `json:"relation_cn"`
Remark string `json:"remark"`
CreateTime time.Time `json:"create_time"`
SourceTitle string `json:"source_title"`
TargetTitle string `json:"target_title"`
}
func OaDocLinkCreate(a OaDocActor, creatorID, sourceID, targetID uint64, relation, remark string) (*models.OaDocLink, error) {
tid := a.Tid
if sourceID == 0 || targetID == 0 {
return nil, ErrDocNotFound
}
if sourceID == targetID {
return nil, ErrDocLinkSelf
}
relation = strings.TrimSpace(relation)
if relation == "" {
relation = models.DocRelationRelated
}
for _, id := range []uint64{sourceID, targetID} {
if _, err := OaDocGet(a, id); err != nil {
return nil, ErrDocLinkTargetNotFound
}
}
qs := models.Orm.QueryTable(new(models.OaDocLink)).
Filter("tid", tid).
Filter("source_id", sourceID).
Filter("target_id", targetID).
Filter("relation", relation)
if qs.Exist() {
return nil, ErrDocLinkDuplicate
}
item := &models.OaDocLink{
Tid: tid,
SourceID: sourceID,
TargetID: targetID,
Relation: relation,
Remark: strings.TrimSpace(remark),
CreatorID: creatorID,
}
if _, err := models.Orm.Insert(item); err != nil {
return nil, err
}
reverse := *item
reverse.ID = 0
reverse.SourceID, reverse.TargetID = targetID, sourceID
if _, err := models.Orm.Insert(&reverse); err != nil {
_ = err
}
return item, nil
}
func OaDocLinkDelete(a OaDocActor, id uint64) error {
tid := a.Tid
var item models.OaDocLink
if err := models.Orm.QueryTable(new(models.OaDocLink)).
Filter("tid", tid).Filter("id", id).One(&item); err != nil {
return ErrDocLinkNotFound
}
if _, err := OaDocGet(a, item.SourceID); err != nil {
return ErrDocNoPermission
}
if _, err := OaDocGet(a, item.TargetID); err != nil {
return ErrDocNoPermission
}
forward := orm.NewCondition().
And("source_id", item.SourceID).
And("target_id", item.TargetID).
And("relation", item.Relation)
backward := orm.NewCondition().
And("source_id", item.TargetID).
And("target_id", item.SourceID).
And("relation", item.Relation)
cond := orm.NewCondition().
And("tid", tid).
AndCond(orm.NewCondition().OrCond(forward).OrCond(backward))
_, err := models.Orm.QueryTable(new(models.OaDocLink)).SetCond(cond).Delete()
return err
}
func OaDocLinkList(a OaDocActor, docID uint64, all bool) ([]OaDocLinkItem, error) {
sql := `
SELECT l.id, l.tid, l.source_id, l.target_id, l.relation, l.remark, l.create_time,
IFNULL(s.title, '') AS source_title, IFNULL(t.title, '') AS target_title
FROM yz_backend_oa_doc_link l
LEFT JOIN yz_backend_oa_doc s ON s.id = l.source_id AND s.is_deleted = 0
LEFT JOIN yz_backend_oa_doc t ON t.id = l.target_id AND t.is_deleted = 0
`
args := []interface{}{}
if all {
sql += "WHERE l.tid = ? ORDER BY l.id DESC LIMIT 500"
args = append(args, a.Tid)
} else {
sql += "WHERE l.tid = ? AND (l.source_id = ? OR l.target_id = ?) ORDER BY l.id DESC LIMIT 200"
args = append(args, a.Tid, docID, docID)
}
var rows []OaDocLinkItem
if _, err := models.Orm.Raw(sql, args...).QueryRows(&rows); err != nil {
return nil, err
}
endpointIDs := make([]uint64, 0, len(rows)*2)
seen := make(map[uint64]bool, len(rows)*2)
for _, r := range rows {
if !seen[r.SourceID] {
seen[r.SourceID] = true
endpointIDs = append(endpointIDs, r.SourceID)
}
if !seen[r.TargetID] {
seen[r.TargetID] = true
endpointIDs = append(endpointIDs, r.TargetID)
}
}
visible := oaDocVisibleIDSet(a, endpointIDs)
out := make([]OaDocLinkItem, 0, len(rows))
for _, r := range rows {
if !visible[r.SourceID] || !visible[r.TargetID] {
continue
}
r.RelationCN = DocRelationLabel(r.Relation)
out = append(out, r)
}
if out == nil {
out = []OaDocLinkItem{}
}
return out, nil
}
type OaDocShareItem struct {
ShareType int8 `json:"share_type"`
TargetID uint64 `json:"target_id"`
}
type OaDocShareView struct {
ID uint64 `json:"id"`
DocID uint64 `json:"doc_id"`
ShareType int8 `json:"share_type"`
TargetID uint64 `json:"target_id"`
TargetName string `json:"target_name"`
}
func OaDocShareList(a OaDocActor, docID uint64) ([]OaDocShareView, error) {
if _, err := OaDocGet(a, docID); err != nil {
return nil, err
}
var rows []models.OaDocShare
if _, err := models.Orm.QueryTable(new(models.OaDocShare)).
Filter("tid", a.Tid).Filter("doc_id", docID).OrderBy("id").All(&rows); err != nil && err != orm.ErrNoRows {
return nil, err
}
views := make([]OaDocShareView, 0, len(rows))
for _, r := range rows {
views = append(views, OaDocShareView{
ID: r.ID,
DocID: r.DocID,
ShareType: r.ShareType,
TargetID: r.TargetID,
TargetName: oaDocShareTargetName(a.Tid, r.ShareType, r.TargetID),
})
}
if views == nil {
views = []OaDocShareView{}
}
return views, nil
}
func oaDocShareTargetName(tid int, shareType int8, targetID uint64) string {
if targetID == 0 {
return ""
}
if shareType == models.DocShareTypeOrg {
var org models.BackendOrganization
if err := models.Orm.QueryTable(new(models.BackendOrganization)).
Filter("tid", tid).Filter("id", targetID).One(&org); err == nil {
return org.OrgName
}
return ""
}
var u models.SystemTenantUser
if err := models.Orm.QueryTable(new(models.SystemTenantUser)).
Filter("tid", tid).Filter("uid", ResolveTenantUID(uint64(tid), targetID)).Filter("delete_time__isnull", true).One(&u); err == nil {
if u.Name != nil {
return *u.Name
}
}
return ""
}
func OaDocShareSet(a OaDocActor, docID uint64, items []OaDocShareItem) ([]OaDocShareView, error) {
doc, err := OaDocGet(a, docID)
if err != nil {
return nil, err
}
if !oaDocCanManage(a, doc) {
return nil, ErrDocNoPermission
}
seen := make(map[string]bool, len(items))
clean := make([]OaDocShareItem, 0, len(items))
for _, it := range items {
if it.TargetID == 0 {
continue
}
st := it.ShareType
if st != models.DocShareTypeUser && st != models.DocShareTypeOrg {
st = models.DocShareTypeUser
}
key := fmt.Sprintf("%d_%d", st, it.TargetID)
if seen[key] {
continue
}
seen[key] = true
clean = append(clean, OaDocShareItem{ShareType: st, TargetID: it.TargetID})
}
if _, err := models.Orm.QueryTable(new(models.OaDocShare)).
Filter("tid", a.Tid).Filter("doc_id", docID).Delete(); err != nil {
return nil, err
}
for _, it := range clean {
rec := models.OaDocShare{
Tid: a.Tid,
DocID: docID,
ShareType: it.ShareType,
TargetID: it.TargetID,
CreatorID: a.UID,
}
if _, err := models.Orm.Insert(&rec); err != nil {
return nil, err
}
}
return OaDocShareList(a, docID)
}
func OaDocShareRemove(a OaDocActor, id uint64) error {
var item models.OaDocShare
if err := models.Orm.QueryTable(new(models.OaDocShare)).
Filter("tid", a.Tid).Filter("id", id).One(&item); err != nil {
return ErrDocLinkNotFound
}
doc, err := OaDocGet(a, item.DocID)
if err != nil {
return err
}
if !oaDocCanManage(a, doc) {
return ErrDocNoPermission
}
_, err = models.Orm.QueryTable(new(models.OaDocShare)).
Filter("tid", a.Tid).Filter("id", id).Delete()
return err
}
type OaDocMemberItem struct {
UID uint64 `json:"uid"`
Name string `json:"name"`
Account string `json:"account"`
OrgID uint64 `json:"org_id"`
OrgName string `json:"org_name"`
}
func OaDocMembers(tid int, keyword string, limit int) ([]OaDocMemberItem, error) {
if limit < 1 || limit > 200 {
limit = 100
}
qs := models.Orm.QueryTable(new(models.SystemTenantUser)).
Filter("tid", tid).
Filter("status", 1).
Filter("delete_time__isnull", true)
if kw := strings.TrimSpace(keyword); kw != "" {
cond := orm.NewCondition().
Or("name__icontains", kw).
Or("account__icontains", kw)
qs = qs.SetCond(qs.GetCond().AndCond(cond))
}
var users []models.SystemTenantUser
if _, err := qs.OrderBy("-id").Limit(limit).All(&users); err != nil && err != orm.ErrNoRows {
return nil, err
}
orgIDs := make([]uint64, 0, len(users))
for _, u := range users {
if u.OrgID > 0 {
orgIDs = append(orgIDs, u.OrgID)
}
}
orgName := make(map[uint64]string, len(orgIDs))
if len(orgIDs) > 0 {
var orgs []models.BackendOrganization
if _, err := models.Orm.QueryTable(new(models.BackendOrganization)).
Filter("tid", tid).Filter("id__in", orgIDs).All(&orgs); err == nil {
for _, o := range orgs {
orgName[o.ID] = o.OrgName
}
}
}
out := make([]OaDocMemberItem, 0, len(users))
for _, u := range users {
name := ""
if u.Name != nil {
name = *u.Name
}
account := ""
if u.Account != nil {
account = *u.Account
}
out = append(out, OaDocMemberItem{
UID: u.Uid,
Name: name,
Account: account,
OrgID: u.OrgID,
OrgName: orgName[u.OrgID],
})
}
if out == nil {
out = []OaDocMemberItem{}
}
return out, nil
}
type OaDocGraphParams struct {
Keyword string
CategoryID uint64
Relation string
IncludeCategory bool
OnlyLinked bool
Limit int
}
type OaDocGraphNode struct {
ID string `json:"id"`
Name string `json:"name"`
Category int `json:"category"`
DocID uint64 `json:"doc_id"`
CategoryID uint64 `json:"category_id"`
Ext string `json:"ext"`
DocType int8 `json:"doc_type"`
Status int8 `json:"status"`
Tags string `json:"tags"`
OwnerName string `json:"owner_name"`
ViewCount int `json:"view_count"`
Degree int `json:"degree"`
Value int `json:"value"`
}
type OaDocGraphLink struct {
Source string `json:"source"`
Target string `json:"target"`
Relation string `json:"relation"`
Remark string `json:"remark"`
Label string `json:"label"`
Kind string `json:"kind"`
}
type OaDocRelationCount struct {
Relation string `json:"relation"`
Label string `json:"label"`
Count int64 `json:"count"`
}
type OaDocGraphStats struct {
DocCount int64 `json:"doc_count"`
LinkCount int64 `json:"link_count"`
CategoryCount int64 `json:"category_count"`
IsolatedCount int64 `json:"isolated_count"`
AvgDegree float64 `json:"avg_degree"`
RelationCounts []OaDocRelationCount `json:"relation_counts"`
TopNodes []OaDocGraphNode `json:"top_nodes"`
}
type OaDocGraphResult struct {
Nodes []OaDocGraphNode `json:"nodes"`
Links []OaDocGraphLink `json:"links"`
Categories []string `json:"categories"`
Stats OaDocGraphStats `json:"stats"`
}
func OaDocGraph(a OaDocActor, p OaDocGraphParams) (*OaDocGraphResult, error) {
limit := p.Limit
if limit < 1 || limit > 1000 {
limit = 300
}
docs, _, err := OaDocList(a, OaDocListParams{
Actor: a,
Scope: models.DocScopeAll,
Keyword: p.Keyword,
CategoryID: p.CategoryID,
Status: -1,
DocType: -1,
Star: -1,
Page: 1,
PageSize: limit,
})
if err != nil {
return nil, err
}
docIDs := make([]uint64, 0, len(docs))
for _, d := range docs {
docIDs = append(docIDs, d.ID)
}
nodes := make([]OaDocGraphNode, 0, len(docs)+8)
links := make([]OaDocGraphLink, 0, len(docs)*2)
degree := make(map[string]int)
for _, d := range docs {
nodes = append(nodes, OaDocGraphNode{
ID: fmt.Sprintf("d%d", d.ID),
Name: d.Title,
Category: 0,
DocID: d.ID,
CategoryID: d.CategoryID,
Ext: d.Ext,
DocType: d.DocType,
Status: d.Status,
Tags: d.Tags,
OwnerName: d.OwnerName,
ViewCount: d.ViewCount,
})
}
if len(docIDs) > 0 {
cond := orm.NewCondition().
And("tid", a.Tid).
And("source_id__in", docIDs).
And("target_id__in", docIDs)
qs := models.Orm.QueryTable(new(models.OaDocLink)).SetCond(cond)
if rel := strings.TrimSpace(p.Relation); rel != "" {
qs = qs.Filter("relation", rel)
}
var linkList []models.OaDocLink
if _, err := qs.OrderBy("id").All(&linkList); err != nil && err != orm.ErrNoRows {
return nil, err
}
for _, l := range linkList {
if l.SourceID > l.TargetID {
continue
}
links = append(links, OaDocGraphLink{
Source: fmt.Sprintf("d%d", l.SourceID),
Target: fmt.Sprintf("d%d", l.TargetID),
Relation: l.Relation,
Remark: l.Remark,
Label: DocRelationLabel(l.Relation),
Kind: "doc",
})
degree[fmt.Sprintf("d%d", l.SourceID)]++
degree[fmt.Sprintf("d%d", l.TargetID)]++
}
}
categoryCount := int64(0)
if p.IncludeCategory {
catCond := orm.NewCondition().
And("tid", a.Tid).
And("is_deleted", 0).
AndCond(orm.NewCondition().Or("user_id", 0).Or("user_id", a.UID))
var cats []models.OaDocCategory
if _, err := models.Orm.QueryTable(new(models.OaDocCategory)).SetCond(catCond).OrderBy("sort", "id").All(&cats); err != nil && err != orm.ErrNoRows {
return nil, err
}
categoryCount = int64(len(cats))
catByID := make(map[uint64]models.OaDocCategory, len(cats))
for _, c := range cats {
catByID[c.ID] = c
}
for _, d := range docs {
if d.CategoryID == 0 {
continue
}
if _, ok := catByID[d.CategoryID]; !ok {
continue
}
links = append(links, OaDocGraphLink{
Source: fmt.Sprintf("d%d", d.ID),
Target: fmt.Sprintf("c%d", d.CategoryID),
Relation: models.DocRelationBelong,
Label: DocRelationLabel(models.DocRelationBelong),
Kind: "belong",
})
degree[fmt.Sprintf("d%d", d.ID)]++
degree[fmt.Sprintf("c%d", d.CategoryID)]++
}
for _, c := range cats {
if c.ParentID == 0 {
continue
}
if _, ok := catByID[c.ParentID]; !ok {
continue
}
links = append(links, OaDocGraphLink{
Source: fmt.Sprintf("c%d", c.ID),
Target: fmt.Sprintf("c%d", c.ParentID),
Relation: models.DocRelationBelong,
Label: "子分类",
Kind: "cate",
})
degree[fmt.Sprintf("c%d", c.ID)]++
degree[fmt.Sprintf("c%d", c.ParentID)]++
}
for _, c := range cats {
catKind := 1
if c.UserID != 0 {
catKind = 2
}
nodes = append(nodes, OaDocGraphNode{
ID: fmt.Sprintf("c%d", c.ID),
Name: c.Name,
Category: catKind,
CategoryID: c.ID,
})
}
}
if p.OnlyLinked {
kept := make([]OaDocGraphNode, 0, len(nodes))
for _, n := range nodes {
if degree[n.ID] > 0 {
kept = append(kept, n)
}
}
nodes = kept
}
for i := range nodes {
nodes[i].Degree = degree[nodes[i].ID]
nodes[i].Value = degree[nodes[i].ID] + 1
}
stats := OaDocGraphStats{
DocCount: int64(len(docs)),
CategoryCount: categoryCount,
}
isolated := int64(0)
for _, n := range nodes {
if n.Category == 0 && n.Degree == 0 {
isolated++
}
}
stats.IsolatedCount = isolated
docLinkCount := int64(0)
for _, l := range links {
if l.Kind == "doc" {
docLinkCount++
}
}
stats.LinkCount = docLinkCount
if len(docs) > 0 {
stats.AvgDegree = float64(docLinkCount*2) / float64(len(docs))
}
relCountMap := make(map[string]int64, 4)
for _, l := range links {
if l.Kind != "doc" {
continue
}
relCountMap[l.Relation]++
}
stats.RelationCounts = make([]OaDocRelationCount, 0, len(relCountMap))
for rel, cnt := range relCountMap {
stats.RelationCounts = append(stats.RelationCounts, OaDocRelationCount{
Relation: rel,
Label: DocRelationLabel(rel),
Count: cnt,
})
}
sort.Slice(stats.RelationCounts, func(i, j int) bool {
return stats.RelationCounts[i].Count > stats.RelationCounts[j].Count
})
sorted := make([]OaDocGraphNode, 0, len(nodes))
for _, n := range nodes {
if n.Category == 0 {
sorted = append(sorted, n)
}
}
for i := 0; i < len(sorted); i++ {
for j := i + 1; j < len(sorted); j++ {
if sorted[j].Degree > sorted[i].Degree {
sorted[i], sorted[j] = sorted[j], sorted[i]
}
}
}
if len(sorted) > 8 {
sorted = sorted[:8]
}
stats.TopNodes = sorted
return &OaDocGraphResult{
Nodes: nodes,
Links: links,
Categories: []string{"文档", "分类"},
Stats: stats,
}, nil
}
func normalizeIDs(ids []uint64) []uint64 {
seen := make(map[uint64]bool, len(ids))
result := make([]uint64, 0, len(ids))
for _, id := range ids {
if id > 0 && !seen[id] {
seen[id] = true
result = append(result, id)
}
}
return result
}