An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later
package model
import (
"errors"
"fmt"
"io/fs"
"math"
"net/http"
"os"
"path"
"path/filepath"
"slices"
"strings"
"sync"
"time"
"github.com/88250/gulu"
"github.com/88250/lute/ast"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/filelock"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/av"
"github.com/siyuan-note/siyuan/kernel/sql"
"github.com/siyuan-note/siyuan/kernel/treenode"
"github.com/siyuan-note/siyuan/kernel/util"
)
type PublishAccessItem struct {
ID string `json:"id"`
Visible bool `json:"visible"` // 是否发布可见
Password string `json:"password"` // 密码,为空字符串时表示无密码
Disable bool `json:"disable"` // 是否禁止发布
}
type PublishAccess []*PublishAccessItem
type PublishAccessStatus int
const (
PublishAccessAllowed PublishAccessStatus = iota
PublishAccessPasswordRequired
PublishAccessDenied
)
var (
publishAccessLastModified int64
publishAccess PublishAccess
publishAccessLock = sync.Mutex{}
)
const publishAccessDenyAllID = "\x00"
const encryptedPublishAccessCacheTTL = 5 * time.Second
var encryptedPublishAccessCache = struct {
sync.Mutex
dataDir string
updatedAt time.Time
boxIDs map[string]struct{}
denyAll bool
}{}
func GetPublishAccess() (ret PublishAccess) {
ret = PublishAccess{}
now := time.Now().UnixMilli()
if now-publishAccessLastModified < 30*1000 {
return publishAccess
}
publishAccessLock.Lock()
defer publishAccessLock.Unlock()
publishAccessLastModified = now
publishAccessPath := filepath.Join(util.DataDir, ".siyuan", "publishAccess.json")
err := os.MkdirAll(filepath.Dir(publishAccessPath), 0755)
if err != nil {
return
}
if !filelock.IsExist(publishAccessPath) {
if err = filelock.WriteFile(publishAccessPath, []byte("[]")); err != nil {
logging.LogErrorf("create publishAccess.json [%s] failed: %s", publishAccessPath, err)
return
}
}
data, err := os.ReadFile(publishAccessPath)
if err != nil {
logging.LogErrorf("read publishAccess.json [%s] failed: %s", publishAccessPath, err)
return
}
if err = gulu.JSON.UnmarshalJSON(data, &publishAccess); err != nil {
logging.LogWarnf("unmarshal publishAccess.json failed: %s", err)
return
}
ret = publishAccess
return
}
func SetPublishAccess(inputPublishAccess PublishAccess) (err error) {
now := time.Now().UnixMilli()
publishAccessLock.Lock()
defer publishAccessLock.Unlock()
publishAccessLastModified = now
publishAccess = inputPublishAccess
publishAccessPath := filepath.Join(util.DataDir, ".siyuan", "publishAccess.json")
err = os.MkdirAll(filepath.Dir(publishAccessPath), 0755)
if err != nil {
msg := fmt.Sprintf("create dir for publishAccess.json [%s] failed: %s", publishAccessPath, err)
logging.LogError(msg)
err = errors.New(msg)
return
}
data, err := gulu.JSON.MarshalJSON(inputPublishAccess)
if err != nil {
logging.LogErrorf("marshal publishAccess.json [%s] failed: %s", publishAccessPath, err)
return
}
err = filelock.WriteFile(publishAccessPath, data)
if err != nil {
msg := fmt.Sprintf("write publishAccess.json [%s] failed: %s", publishAccessPath, err)
logging.LogError(msg)
err = errors.New(msg)
return
}
IncSyncIfNeeded(publishAccessPath)
return
}
func GetInvisiblePublishAccess(inputPublishAccess PublishAccess) (outputPublishAccess PublishAccess) {
outputPublishAccess = filterInvisiblePublishAccess(inputPublishAccess)
outputPublishAccess = appendEncryptedBoxesToPublishAccess(outputPublishAccess)
return
}
func filterInvisiblePublishAccess(inputPublishAccess PublishAccess) (outputPublishAccess PublishAccess) {
outputPublishAccess = PublishAccess{}
for _, item := range inputPublishAccess {
if !item.Visible {
outputPublishAccess = append(outputPublishAccess, item)
}
}
return
}
func GetDisablePublishAccess(inputPublishAccess PublishAccess) (outputPublishAccess PublishAccess) {
outputPublishAccess = filterDisablePublishAccess(inputPublishAccess)
outputPublishAccess = appendEncryptedBoxesToPublishAccess(outputPublishAccess)
return
}
func filterDisablePublishAccess(inputPublishAccess PublishAccess) (outputPublishAccess PublishAccess) {
outputPublishAccess = PublishAccess{}
for _, item := range inputPublishAccess {
if item.Disable {
outputPublishAccess = append(outputPublishAccess, item)
}
}
return
}
// appendEncryptedBoxesToPublishAccess 将加密笔记本加入发布拒绝列表,使发布访问规则独立于持久化配置和锁定状态。
func appendEncryptedBoxesToPublishAccess(inputPublishAccess PublishAccess) PublishAccess {
ret := append(PublishAccess{}, inputPublishAccess...)
existing := map[string]struct{}{}
for _, item := range ret {
existing[item.ID] = struct{}{}
}
boxIDs, denyAll := encryptedBoxIDsForPublishAccess()
if denyAll {
return append(ret, &PublishAccessItem{ID: publishAccessDenyAllID, Disable: true})
}
for boxID := range boxIDs {
if _, ok := existing[boxID]; ok {
continue
}
ret = append(ret, &PublishAccessItem{ID: boxID, Disable: true})
}
return ret
}
// encryptedBoxIDsForPublishAccess 返回发布门禁使用的加密笔记本快照,避免在块和属性视图过滤热路径中重复读取配置。
func encryptedBoxIDsForPublishAccess() (map[string]struct{}, bool) {
encryptedPublishAccessCache.Lock()
defer encryptedPublishAccessCache.Unlock()
now := time.Now()
if encryptedPublishAccessCache.boxIDs != nil &&
encryptedPublishAccessCache.dataDir == util.DataDir &&
now.Sub(encryptedPublishAccessCache.updatedAt) < encryptedPublishAccessCacheTTL {
return encryptedPublishAccessCache.boxIDs, encryptedPublishAccessCache.denyAll
}
boxIDs, err := listEncryptedBoxIDsForPublishAccess()
snapshot := map[string]struct{}{}
for _, boxID := range boxIDs {
snapshot[boxID] = struct{}{}
}
encryptedPublishAccessCache.dataDir = util.DataDir
encryptedPublishAccessCache.updatedAt = now
encryptedPublishAccessCache.boxIDs = snapshot
encryptedPublishAccessCache.denyAll = err != nil
if err != nil {
logging.LogErrorf("list encrypted notebooks for publish access failed: %s", err)
}
return snapshot, err != nil
}
func invalidateEncryptedPublishAccessCache() {
encryptedPublishAccessCache.Lock()
encryptedPublishAccessCache.updatedAt = time.Time{}
encryptedPublishAccessCache.boxIDs = nil
encryptedPublishAccessCache.Unlock()
}
// IsEncryptedBoxDeniedByPublishAccess 判断笔记本是否应被发布门禁拒绝。
func IsEncryptedBoxDeniedByPublishAccess(boxID string) bool {
boxIDs, denyAll := encryptedBoxIDsForPublishAccess()
if denyAll {
return true
}
_, encrypted := boxIDs[boxID]
return encrypted
}
func listEncryptedBoxIDsForPublishAccess() ([]string, error) {
if util.DataDir == "" {
return []string{}, nil
}
dirs, err := os.ReadDir(util.DataDir)
if err != nil {
return nil, err
}
ret := []string{}
for _, dir := range dirs {
if dir.IsDir() && ast.IsNodeIDPattern(dir.Name()) && IsEncryptedBox(dir.Name()) {
ret = append(ret, dir.Name())
}
}
return ret, nil
}
func PurgePublishAccess() {
publishAccess := GetPublishAccess()
IDs := []string{}
for _, item := range publishAccess {
IDs = append(IDs, item.ID)
}
boxes, err := ListNotebooks()
if err != nil {
return
}
// 必须在所有笔记本都打开的情况下才能执行清除工作,否则会把关闭的笔记本里文档的发布访问控制状态清除
for _, box := range boxes {
if box.Closed {
return
}
}
checkResult := treenode.ExistBlockTrees(IDs)
tempPublishAccess := PublishAccess{}
for i, ID := range IDs {
if exists, ok := checkResult[ID]; ok && exists {
tempPublishAccess = append(tempPublishAccess, publishAccess[i])
} else {
for _, box := range boxes {
if box.ID == ID {
tempPublishAccess = append(tempPublishAccess, publishAccess[i])
break
}
}
}
}
SetPublishAccess(tempPublishAccess)
}
func CheckPathAccessableByPublishIgnore(box string, path string, publishIgnore PublishAccess) bool {
for _, item := range publishIgnore {
if item.ID == publishAccessDenyAllID || item.ID == box || strings.Contains(path, item.ID) {
return false
}
}
return true
}
// PublishVisibleDocPathFilter 返回发布读者可见文档路径的判定函数,口径与读者可见的发布视图一致:
// 隐藏、禁止发布以及加密笔记本中的文档都不计入读者统计。
func PublishVisibleDocPathFilter(boxID string, publishAccess PublishAccess) func(docPath string) bool {
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
return func(docPath string) bool {
return CheckPathAccessableByPublishIgnore(boxID, docPath, publishInvisible) &&
CheckPathAccessableByPublishIgnore(boxID, docPath, publishDisable)
}
}
// IsEncryptedPublishRuntimeTarget 判断发布读取目标是否属于当前可解析的加密笔记本。
func IsEncryptedPublishRuntimeTarget(id string) bool {
boxIDs, denyAll := encryptedBoxIDsForPublishAccess()
if denyAll {
return true
}
if _, ok := boxIDs[id]; ok {
return true
}
for boxID := range boxIDs {
if nil != treenode.GetBlockTreeInBox(id, boxID) {
return true
}
}
return false
}
// IsEncryptedPublishAccessTarget 判断发布访问配置目标是否属于加密笔记本,包括锁定笔记本中的文档。
func IsEncryptedPublishAccessTarget(id string) bool {
if IsEncryptedPublishRuntimeTarget(id) {
return true
}
boxIDs, denyAll := encryptedBoxIDsForPublishAccess()
if denyAll {
return true
}
targetName := id + ".sy"
for boxID := range boxIDs {
found := false
err := filepath.WalkDir(filepath.Join(util.DataDir, boxID), func(_ string, entry os.DirEntry, walkErr error) error {
if walkErr != nil {
return walkErr
}
if entry.IsDir() && (entry.Name() == ".siyuan" || entry.Name() == "assets") {
return fs.SkipDir
}
if !entry.IsDir() && entry.Name() == targetName {
found = true
return fs.SkipAll
}
return nil
})
if err != nil {
return true
}
if found {
return true
}
}
return false
}
func GetPathPasswordByPublishAccess(box string, blockPath string, publishAccess PublishAccess) (passwordID string, password string) {
currentPath := blockPath
password = ""
passwordID = ""
for currentPath != "/" && password == "" {
currentID := strings.TrimSuffix(path.Base(currentPath), ".sy")
for _, accessItem := range publishAccess {
if accessItem.ID == currentID {
password = accessItem.Password
passwordID = accessItem.ID
break
}
}
currentPath = path.Dir(currentPath)
}
if password == "" {
for _, accessItem := range publishAccess {
if accessItem.ID == box {
password = accessItem.Password
passwordID = accessItem.ID
break
}
}
}
return
}
func CheckBlockIdAccessableByPublishAccess(c *gin.Context, publishAccess PublishAccess, blockID string) bool {
return CheckBlockIdAccessableByPublishAccessInBox(c, publishAccess, blockID, "")
}
func CheckBlockIdAccessableByPublishAccessInBox(c *gin.Context, publishAccess PublishAccess, blockID, boxID string) bool {
bt := treenode.GetBlockTreeInBox(blockID, boxID)
return checkBlockTreeAccessableByPublishAccess(c, publishAccess, bt)
}
func CheckBlockIdMetadataAccessableByPublishAccess(c *gin.Context, publishAccess PublishAccess, blockID string) bool {
return CheckBlockIdMetadataAccessableByPublishAccessInBox(c, publishAccess, blockID, "")
}
func CheckBlockIdMetadataAccessableByPublishAccessInBox(c *gin.Context, publishAccess PublishAccess, blockID, boxID string) bool {
bt := treenode.GetBlockTreeInBox(blockID, boxID)
return CheckBlockTreeMetadataAccessableByPublishAccess(c, publishAccess, bt)
}
func CheckBlockTreeMetadataAccessableByPublishAccess(c *gin.Context, publishAccess PublishAccess, bt *treenode.BlockTree) bool {
if bt == nil || IsEncryptedBoxDeniedByPublishAccess(bt.BoxID) {
return false
}
publishDisable := filterDisablePublishAccess(publishAccess)
if !CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishDisable) {
return false
}
publishInvisible := filterInvisiblePublishAccess(publishAccess)
if CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishInvisible) {
return true
}
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
return password == "" || CheckPublishAuthCookie(c, passwordID, password)
}
func CheckBlockTreeDiscoverableByPublishAccess(publishAccess PublishAccess, bt *treenode.BlockTree) bool {
if bt == nil || IsEncryptedBoxDeniedByPublishAccess(bt.BoxID) {
return false
}
publishInvisible := filterInvisiblePublishAccess(publishAccess)
publishDisable := filterDisablePublishAccess(publishAccess)
return CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishInvisible) &&
CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishDisable)
}
func GetBlockTreePublishAccessStatus(c *gin.Context, publishAccess PublishAccess, bt *treenode.BlockTree) PublishAccessStatus {
return getBlockTreePublishAccessStatus(c, publishAccess, filterDisablePublishAccess(publishAccess), bt)
}
func getBlockTreePublishAccessStatus(c *gin.Context, publishAccess, publishDisable PublishAccess, bt *treenode.BlockTree) PublishAccessStatus {
if bt == nil || IsEncryptedBoxDeniedByPublishAccess(bt.BoxID) {
return PublishAccessDenied
}
if !CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishDisable) {
return PublishAccessDenied
}
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if password != "" && !CheckPublishAuthCookie(c, passwordID, password) {
return PublishAccessPasswordRequired
}
return PublishAccessAllowed
}
func checkBlockTreeAccessableByPublishAccess(c *gin.Context, publishAccess PublishAccess, bt *treenode.BlockTree) bool {
return GetBlockTreePublishAccessStatus(c, publishAccess, bt) == PublishAccessAllowed
}
func SetPublishAuthCookie(c *gin.Context, ID string, password string) {
authCookie := util.SHA256Hash([]byte(ID + password))
http.SetCookie(c.Writer, &http.Cookie{
Name: "publish-auth-" + ID,
Value: authCookie,
MaxAge: 24 * 60 * 60,
Path: "/",
// 只有客户端连接确实使用 TLS 时才标记 Secure,与发布会话 Cookie 保持一致
// https://github.com/siyuan-note/siyuan/security/advisories/GHSA-hpj5-f7cj-vvwr
Secure: util.SSL || util.IsTLSRequest(c.Request),
HttpOnly: true,
})
}
func CheckPublishAuthCookie(c *gin.Context, ID string, password string) bool {
authCookie, err := c.Request.Cookie("publish-auth-" + ID)
return err == nil && authCookie.Value == util.SHA256Hash([]byte(ID+password))
}
// AssetPathFromDataRelativePath 从 data 相对路径提取文档中使用的资源路径和笔记本 ID。
func AssetPathFromDataRelativePath(relPath string) (assetPath, boxID string, ok bool) {
pathParts := strings.Split(relPath, "/")
if 1 < len(pathParts) && pathParts[0] == "assets" {
return strings.Join(pathParts, "/"), "", true
}
if 2 >= len(pathParts) || !ast.IsNodeIDPattern(pathParts[0]) {
return
}
for i := 1; i < len(pathParts)-1; i++ {
if pathParts[i] == "assets" {
return strings.Join(pathParts[i:], "/"), pathParts[0], true
}
}
return
}
func CheckAbsPathAccessableByPublishAccess(c *gin.Context, absPath string, publishAccess PublishAccess) bool {
absPath = filepath.Clean(absPath)
if gulu.File.IsSubPath(util.HistoryDir, absPath) {
return false
}
if gulu.File.IsSubPath(util.DataDir, absPath) {
relPath, err := filepath.Rel(util.DataDir, absPath)
if err != nil {
return false
}
relPath = strings.ReplaceAll(relPath, "\\", "/")
pathParts := strings.Split(relPath, "/")
if len(pathParts) <= 1 {
return false
}
if assetPath, box, ok := AssetPathFromDataRelativePath(relPath); ok {
return checkAssetPathAccessableByPublishAccess(c, publishAccess, assetPath, box)
}
if ast.IsNodeIDPattern(pathParts[0]) {
box := pathParts[0]
blockPath := "/" + strings.Join(pathParts[1:], "/")
passwordID, password := GetPathPasswordByPublishAccess(box, blockPath, publishAccess)
publishIgnore := GetDisablePublishAccess(publishAccess)
return CheckPathAccessableByPublishIgnore(box, blockPath, publishIgnore) && (password == "" || CheckPublishAuthCookie(c, passwordID, password))
}
}
return false
}
func checkAssetPathAccessableByPublishAccess(c *gin.Context, publishAccess PublishAccess, assetPath, boxID string) bool {
publishIgnore := GetDisablePublishAccess(publishAccess)
itemAccessCache := map[*av.AttributeView]map[string]bool{}
itemFilter := func(attrView *av.AttributeView, itemID string) bool {
itemAccess := itemAccessCache[attrView]
if nil == itemAccess {
itemAccess = map[string]bool{}
itemAccessCache[attrView] = itemAccess
}
if accessable, ok := itemAccess[itemID]; ok {
return accessable
}
accessable := checkAttributeViewItemIDAccessableByPublishAccess(c, publishAccess, attrView, itemID)
itemAccess[itemID] = accessable
return accessable
}
for _, bt := range treenode.GetBlockTreesByType("d") {
if "" != boxID && bt.BoxID != boxID {
continue
}
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if !CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishIgnore) ||
("" != password && !CheckPublishAuthCookie(c, passwordID, password)) {
continue
}
assets, _ := docAssets(bt.ID, false, itemFilter)
if slices.Contains(assets, assetPath) {
return true
}
}
return false
}
func FilterViewByPublishAccess(c *gin.Context, publishAccess PublishAccess, viewable av.Viewable) (ret av.Viewable) {
ret = viewable
switch ret.GetType() {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
table := av.TableFromViewable(ret)
filteredRows := []*av.TableRow{}
for _, row := range table.Rows {
if checkAttributeViewItemAccessableByPublishAccess(c, publishAccess, row) {
filteredRows = append(filteredRows, row)
}
}
table.Rows = filteredRows
if ret.GetType() == av.LayoutTypeCalendar {
table.RowCount = len(filteredRows)
table.CalendarTargetDate = nil
}
if table.Groups != nil {
for i, viewable := range table.Groups {
table.Groups[i] = FilterViewByPublishAccess(c, publishAccess, viewable)
}
}
case av.LayoutTypeGallery:
gallery := ret.(*av.Gallery)
filteredCards := []*av.GalleryCard{}
for _, card := range gallery.Cards {
if checkAttributeViewItemAccessableByPublishAccess(c, publishAccess, card) {
filteredCards = append(filteredCards, card)
}
}
gallery.Cards = filteredCards
if gallery.Groups != nil {
for i, viewable := range gallery.Groups {
gallery.Groups[i] = FilterViewByPublishAccess(c, publishAccess, viewable)
}
}
case av.LayoutTypeKanban:
kanban := ret.(*av.Kanban)
filteredCards := []*av.KanbanCard{}
for _, card := range kanban.Cards {
if checkAttributeViewItemAccessableByPublishAccess(c, publishAccess, card) {
filteredCards = append(filteredCards, card)
}
}
kanban.Cards = filteredCards
kanban.CardCount = len(kanban.Cards)
if kanban.Groups != nil {
for i, viewable := range kanban.Groups {
kanban.Groups[i] = FilterViewByPublishAccess(c, publishAccess, viewable)
}
}
}
return
}
func CheckAttributeViewAccessableByPublishAccess(c *gin.Context, publishAccess PublishAccess, avID string) bool {
return CheckAttributeViewBlockAccessableByPublishAccess(c, publishAccess, avID, "")
}
func CheckAttributeViewBlockAccessableByPublishAccess(c *gin.Context, publishAccess PublishAccess, avID, blockID string) bool {
if !ast.IsNodeIDPattern(avID) {
return false
}
blockIDs := treenode.GetMirrorAttrViewBlockIDs(avID)
if "" != blockID {
if !slices.Contains(blockIDs, blockID) {
node, _, _ := getNodeByBlockID(nil, blockID)
if nil == node || ast.NodeAttributeView != node.Type || avID != node.AttributeViewID {
return false
}
}
blockTree := treenode.GetBlockTree(blockID)
if nil == blockTree {
for _, encryptedBoxID := range treenode.GetOpenedEncryptedBoxIDs() {
if encryptedBlockTree := treenode.GetBlockTreeInBox(blockID, encryptedBoxID); nil != encryptedBlockTree {
blockTree = encryptedBlockTree
break
}
}
}
return checkBlockTreeAccessableByPublishAccess(c, publishAccess, blockTree)
}
return checkAttributeViewBlockTreesAccessableByPublishAccess(c, publishAccess, treenode.GetBlockTrees(blockIDs))
}
func checkAttributeViewBlockTreesAccessableByPublishAccess(c *gin.Context, publishAccess PublishAccess, blockTrees map[string]*treenode.BlockTree) bool {
for _, blockTree := range blockTrees {
if checkBlockTreeAccessableByPublishAccess(c, publishAccess, blockTree) {
return true
}
}
return false
}
func FilterAttributeViewByPublishAccess(c *gin.Context, publishAccess PublishAccess, avID, blockID string, viewable av.Viewable) av.Viewable {
viewable = FilterViewByPublishAccess(c, publishAccess, viewable)
attrView, boxID := parseAttributeViewForPublishAccess(avID, blockID)
filter := &attributeViewPublishAccessFilter{
c: c,
publishAccess: publishAccess,
boxID: boxID,
attributeViews: map[string]*av.AttributeView{},
attributeAccess: map[string]bool{},
itemAccess: map[string]map[string]bool{},
}
if nil != attrView {
filter.attributeViews[attrView.ID] = attrView
}
filter.filterViewable(attrView, viewable)
return viewable
}
// AVExportPublishFilter 为导出路径提供发布访问过滤,nil 表示调用方已确认无需过滤(管理员导出)。
type AVExportPublishFilter func(view av.Viewable, avID, blockID string) av.Viewable
// NewAVExportPublishFilter 为发布读者构造导出用的属性视图过滤器,非读者角色返回 nil。
func NewAVExportPublishFilter(c *gin.Context) AVExportPublishFilter {
if !IsReadOnlyRoleContext(c) {
return nil
}
publishAccess := GetPublishAccess()
return func(view av.Viewable, avID, blockID string) av.Viewable {
return FilterAttributeViewByPublishAccess(c, publishAccess, avID, blockID, view)
}
}
func parseAttributeViewForPublishAccess(avID, blockID string) (attrView *av.AttributeView, boxID string) {
if "" != blockID {
blockTree := treenode.GetBlockTree(blockID)
if nil == blockTree {
for _, encryptedBoxID := range treenode.GetOpenedEncryptedBoxIDs() {
if encryptedBlockTree := treenode.GetBlockTreeInBox(blockID, encryptedBoxID); nil != encryptedBlockTree {
blockTree = encryptedBlockTree
break
}
}
}
if nil != blockTree && IsEncryptedBox(blockTree.BoxID) {
boxID = blockTree.BoxID
}
}
if "" != boxID {
attrView, _ = av.ParseAttributeViewInBox(avID, boxID)
} else {
attrView, _ = av.ParseAttributeView(avID)
}
return
}
type attributeViewPublishAccessFilter struct {
c *gin.Context
publishAccess PublishAccess
boxID string
attributeViews map[string]*av.AttributeView
attributeAccess map[string]bool
itemAccess map[string]map[string]bool
}
func (filter *attributeViewPublishAccessFilter) filterViewable(attrView *av.AttributeView, viewable av.Viewable) {
if nil == viewable {
return
}
switch viewable.GetType() {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
table := av.TableFromViewable(viewable)
filter.filterGroupValue(attrView, table.BaseInstance)
for _, row := range table.Rows {
if nil == row {
continue
}
for _, cell := range row.Cells {
if nil == cell {
continue
}
filter.filterBaseValue(attrView, row.ID, cell.BaseValue)
}
}
for _, group := range table.Groups {
filter.filterViewable(attrView, group)
}
case av.LayoutTypeGallery:
gallery := viewable.(*av.Gallery)
filter.filterGroupValue(attrView, gallery.BaseInstance)
for _, card := range gallery.Cards {
if nil == card {
continue
}
for _, value := range card.Values {
if nil == value {
continue
}
filter.filterBaseValue(attrView, card.ID, value.BaseValue)
}
}
for _, group := range gallery.Groups {
filter.filterViewable(attrView, group)
}
case av.LayoutTypeKanban:
kanban := viewable.(*av.Kanban)
filter.filterGroupValue(attrView, kanban.BaseInstance)
for _, card := range kanban.Cards {
if nil == card {
continue
}
for _, value := range card.Values {
if nil == value {
continue
}
filter.filterBaseValue(attrView, card.ID, value.BaseValue)
}
}
for _, group := range kanban.Groups {
filter.filterViewable(attrView, group)
}
}
}
func (filter *attributeViewPublishAccessFilter) filterGroupValue(attrView *av.AttributeView, instance *av.BaseInstance) {
if nil == instance || nil == instance.GroupValue {
return
}
value, changed := filter.filterValue(attrView, instance.GroupKey, instance.GroupValue, instance.GroupValue.BlockID)
if changed {
instance.GroupValue = value
}
}
func (filter *attributeViewPublishAccessFilter) filterBaseValue(attrView *av.AttributeView, itemID string, baseValue *av.BaseValue) {
if nil == baseValue || nil == baseValue.Value {
return
}
var key *av.Key
if nil != attrView {
key, _ = attrView.GetKey(baseValue.Value.KeyID)
}
value, changed := filter.filterValue(attrView, key, baseValue.Value, itemID)
if "" != value.RenderedContent && !filter.checkRenderTemplateDependencies(attrView, key, itemID) {
if !changed {
value = cloneAttributeViewSensitiveValue(value)
changed = true
}
value.RenderedContent = ""
}
if changed {
baseValue.Value = value
}
}
func (filter *attributeViewPublishAccessFilter) checkRenderTemplateDependencies(attrView *av.AttributeView,
key *av.Key, itemID string) bool {
if nil == attrView || nil == key || "" == strings.TrimSpace(key.RenderTemplate) {
return false
}
dependencies := sql.GetTemplateKeyRelevantKeys(attrView, key)
if 1 > len(dependencies) {
return false
}
for _, dependency := range dependencies {
if !filter.checkKeyDependencies(attrView, dependency, itemID, map[string]bool{}) {
return false
}
}
return true
}
func (filter *attributeViewPublishAccessFilter) filterValue(attrView *av.AttributeView, key *av.Key, value *av.Value, itemID string) (*av.Value, bool) {
if nil == value {
return value, false
}
switch value.Type {
case av.KeyTypeRelation:
return filter.filterRelationValue(key, value)
case av.KeyTypeRollup:
return filter.filterRollupValue(attrView, key, value, itemID)
default:
return value, false
}
}
func (filter *attributeViewPublishAccessFilter) filterRelationValue(key *av.Key, value *av.Value) (*av.Value, bool) {
if nil == value.Relation {
return value, false
}
if 1 > len(value.Relation.BlockIDs) && 1 > len(value.Relation.Contents) {
return value, false
}
if nil == key || nil == key.Relation || "" == key.Relation.AvID {
return clearAttributeViewSensitiveValue(value), true
}
targetAttrView := filter.getAttributeView(key.Relation.AvID)
if nil == targetAttrView || !filter.isAttributeViewAccessable(targetAttrView.ID) {
return clearAttributeViewSensitiveValue(value), true
}
allowedItemIDs := map[string]bool{}
changed := false
for _, itemID := range value.Relation.BlockIDs {
if filter.isItemAccessable(targetAttrView, itemID) {
allowedItemIDs[itemID] = true
} else {
changed = true
}
}
for _, content := range value.Relation.Contents {
if nil == content || "" == content.BlockID || !allowedItemIDs[content.BlockID] {
changed = true
}
}
if !changed {
return value, false
}
ret := cloneAttributeViewSensitiveValue(value)
ret.Relation.BlockIDs = ret.Relation.BlockIDs[:0]
for _, itemID := range value.Relation.BlockIDs {
if allowedItemIDs[itemID] {
ret.Relation.BlockIDs = append(ret.Relation.BlockIDs, itemID)
}
}
ret.Relation.Contents = ret.Relation.Contents[:0]
for _, content := range value.Relation.Contents {
if nil != content && allowedItemIDs[content.BlockID] {
ret.Relation.Contents = append(ret.Relation.Contents, content.Clone())
}
}
return ret, true
}
func (filter *attributeViewPublishAccessFilter) filterRollupValue(attrView *av.AttributeView, key *av.Key, value *av.Value, itemID string) (*av.Value, bool) {
if nil == value.Rollup || 1 > len(value.Rollup.Contents) {
return value, false
}
targetAttrView, targetKey, targetItemIDs, ok := filter.getRollupTarget(attrView, key, itemID)
if !ok {
return clearAttributeViewSensitiveValue(value), true
}
for _, targetItemID := range targetItemIDs {
if !filter.isItemAccessable(targetAttrView, targetItemID) ||
!filter.checkKeyDependencies(targetAttrView, targetKey, targetItemID, map[string]bool{}) {
return clearAttributeViewSensitiveValue(value), true
}
}
var ret *av.Value
for i, content := range value.Rollup.Contents {
if nil == content {
return clearAttributeViewSensitiveValue(value), true
}
filteredContent, changed := filter.filterValue(targetAttrView, targetKey, content, content.BlockID)
if !changed {
continue
}
if nil == ret {
ret = cloneAttributeViewSensitiveValue(value)
}
ret.Rollup.Contents[i] = filteredContent
}
if nil == ret {
return value, false
}
return ret, true
}
func (filter *attributeViewPublishAccessFilter) getRollupTarget(attrView *av.AttributeView, key *av.Key, itemID string) (targetAttrView *av.AttributeView, targetKey *av.Key, targetItemIDs []string, ok bool) {
if nil == attrView || nil == key || nil == key.Rollup || "" == itemID {
return
}
relationKey, _ := attrView.GetKey(key.Rollup.RelationKeyID)
if nil == relationKey || nil == relationKey.Relation || "" == relationKey.Relation.AvID {
return
}
relationValue := attrView.GetValue(relationKey.ID, itemID)
if nil == relationValue || nil == relationValue.Relation {
return
}
targetAttrView = filter.getAttributeView(relationKey.Relation.AvID)
if nil == targetAttrView || !filter.isAttributeViewAccessable(targetAttrView.ID) {
return nil, nil, nil, false
}
targetKey, _ = targetAttrView.GetKey(key.Rollup.KeyID)
if nil == targetKey {
return nil, nil, nil, false
}
targetItemIDs = relationValue.Relation.BlockIDs
ok = true
return
}
func (filter *attributeViewPublishAccessFilter) checkKeyDependencies(attrView *av.AttributeView, key *av.Key, itemID string, visited map[string]bool) bool {
if nil == attrView || nil == key || "" == itemID {
return false
}
visitKey := attrView.ID + "\x00" + key.ID + "\x00" + itemID
if visited[visitKey] {
return true
}
visited[visitKey] = true
switch key.Type {
case av.KeyTypeRelation:
if nil == key.Relation || "" == key.Relation.AvID {
return false
}
value := attrView.GetValue(key.ID, itemID)
if nil == value || nil == value.Relation || 1 > len(value.Relation.BlockIDs) {
return true
}
targetAttrView := filter.getAttributeView(key.Relation.AvID)
if nil == targetAttrView || !filter.isAttributeViewAccessable(targetAttrView.ID) {
return false
}
for _, targetItemID := range value.Relation.BlockIDs {
if !filter.isItemAccessable(targetAttrView, targetItemID) {
return false
}
}
case av.KeyTypeRollup:
targetAttrView, targetKey, targetItemIDs, ok := filter.getRollupTarget(attrView, key, itemID)
if !ok {
value := attrView.GetValue(key.ID, itemID)
return nil == value || nil == value.Rollup || 1 > len(value.Rollup.Contents)
}
for _, targetItemID := range targetItemIDs {
if !filter.isItemAccessable(targetAttrView, targetItemID) ||
!filter.checkKeyDependencies(targetAttrView, targetKey, targetItemID, visited) {
return false
}
}
case av.KeyTypeTemplate:
for _, dependency := range sql.GetTemplateKeyRelevantKeys(attrView, key) {
if dependency.ID == key.ID {
continue
}
if !filter.checkKeyDependencies(attrView, dependency, itemID, visited) {
return false
}
}
}
return true
}
func (filter *attributeViewPublishAccessFilter) getAttributeView(avID string) *av.AttributeView {
if attrView, ok := filter.attributeViews[avID]; ok {
return attrView
}
var attrView *av.AttributeView
if "" != filter.boxID {
attrView, _ = av.ParseAttributeViewInBox(avID, filter.boxID)
} else {
attrView, _ = av.ParseAttributeView(avID)
}
filter.attributeViews[avID] = attrView
return attrView
}
func (filter *attributeViewPublishAccessFilter) isAttributeViewAccessable(avID string) bool {
if accessable, ok := filter.attributeAccess[avID]; ok {
return accessable
}
accessable := CheckAttributeViewAccessableByPublishAccess(filter.c, filter.publishAccess, avID)
filter.attributeAccess[avID] = accessable
return accessable
}
func (filter *attributeViewPublishAccessFilter) isItemAccessable(attrView *av.AttributeView, itemID string) bool {
if nil == attrView || "" == itemID {
return false
}
access := filter.itemAccess[attrView.ID]
if nil == access {
access = map[string]bool{}
filter.itemAccess[attrView.ID] = access
}
if accessable, ok := access[itemID]; ok {
return accessable
}
accessable := checkAttributeViewItemIDAccessableByPublishAccess(filter.c, filter.publishAccess, attrView, itemID)
access[itemID] = accessable
return accessable
}
func cloneAttributeViewSensitiveValue(value *av.Value) *av.Value {
ret := value.Clone()
if nil != ret {
return ret
}
return &av.Value{
ID: value.ID,
KeyID: value.KeyID,
BlockID: value.BlockID,
Type: value.Type,
IsDetached: value.IsDetached,
CreatedAt: value.CreatedAt,
UpdatedAt: value.UpdatedAt,
}
}
func clearAttributeViewSensitiveValue(value *av.Value) *av.Value {
ret := cloneAttributeViewSensitiveValue(value)
switch value.Type {
case av.KeyTypeRelation:
ret.Relation = &av.ValueRelation{}
case av.KeyTypeRollup:
ret.Rollup = &av.ValueRollup{}
}
return ret
}
func checkAttributeViewItemAccessableByPublishAccess(c *gin.Context, publishAccess PublishAccess, item av.Item) bool {
if nil == item {
return false
}
blockValue := item.GetBlockValue()
if nil == blockValue {
return false
}
if blockValue.IsDetached {
return true
}
if nil == blockValue.Block || "" == blockValue.Block.ID {
return false
}
return CheckBlockIdAccessableByPublishAccess(c, publishAccess, blockValue.Block.ID)
}
func checkAttributeViewItemIDAccessableByPublishAccess(
c *gin.Context,
publishAccess PublishAccess,
attrView *av.AttributeView,
itemID string,
) bool {
if nil == attrView || "" == itemID {
return false
}
blockValue := attrView.GetBlockValue(itemID)
if nil == blockValue {
return false
}
if blockValue.IsDetached {
return true
}
if nil == blockValue.Block || "" == blockValue.Block.ID {
return false
}
return CheckBlockIdAccessableByPublishAccess(c, publishAccess, blockValue.Block.ID)
}
func FilterBlockAttributeViewKeysByPublishAccess(c *gin.Context, publishAccess PublishAccess, blockAttributeViewKeys []*BlockAttributeViewKeys) (ret []*BlockAttributeViewKeys) {
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
ret = []*BlockAttributeViewKeys{}
for _, blockAttributeViewKey := range blockAttributeViewKeys {
accessable := false
bts := treenode.GetBlockTrees(blockAttributeViewKey.BlockIDs)
for _, bt := range bts {
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if (password == "" || CheckPublishAuthCookie(c, passwordID, password)) &&
CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishInvisible) &&
CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishDisable) {
accessable = true
break
}
}
if !accessable {
continue
}
// 仅返回绑定文档可发布访问的行值,避免通过键值接口泄漏绑定在禁止访问文档中的数据库内容
var attrView *av.AttributeView
filter := &attributeViewPublishAccessFilter{
c: c,
publishAccess: publishAccess,
attributeViews: map[string]*av.AttributeView{},
attributeAccess: map[string]bool{},
itemAccess: map[string]map[string]bool{},
}
blockID := ""
if 0 < len(blockAttributeViewKey.BlockIDs) {
blockID = blockAttributeViewKey.BlockIDs[0]
}
attrView, filter.boxID = parseAttributeViewForPublishAccess(blockAttributeViewKey.AvID, blockID)
if nil != attrView {
filter.attributeViews[attrView.ID] = attrView
}
keyValues := []*av.KeyValues{}
for _, sourceKeyValues := range blockAttributeViewKey.KeyValues {
itemKeyValues := &av.KeyValues{Key: sourceKeyValues.Key}
for _, value := range sourceKeyValues.Values {
if !filter.isItemAccessable(attrView, value.BlockID) {
// 行绑定的文档对发布读者不可访问,丢弃该行值
continue
}
filteredValue, _ := filter.filterValue(attrView, sourceKeyValues.Key, value, value.BlockID)
itemKeyValues.Values = append(itemKeyValues.Values, filteredValue)
}
if 0 < len(itemKeyValues.Values) {
keyValues = append(keyValues, itemKeyValues)
}
}
if 1 > len(keyValues) {
// 所有行均不可访问时不返回该数据库键值,避免暴露行是否存在
continue
}
ret = append(ret, &BlockAttributeViewKeys{
AvID: blockAttributeViewKey.AvID,
AvName: blockAttributeViewKey.AvName,
CustomColors: blockAttributeViewKey.CustomColors,
BlockIDs: blockAttributeViewKey.BlockIDs,
KeyValues: keyValues,
})
}
return
}
func FilterAttributeViewBacklinksByPublishAccess(c *gin.Context, publishAccess PublishAccess, backlinks *AttributeViewBacklinks) (ret *AttributeViewBacklinks) {
ret = &AttributeViewBacklinks{Items: []*AttributeViewBacklink{}}
if nil == backlinks {
return
}
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
accessibleTargetAvIDs := map[string]bool{}
checkedTargetAvIDs := map[string]bool{}
cachedBlockTrees := map[string]map[string]*treenode.BlockTree{}
for _, backlink := range backlinks.Items {
var relations []*AttributeViewBacklinkRelation
for _, relation := range backlink.Relations {
if !checkedTargetAvIDs[relation.TargetAvID] {
checkedTargetAvIDs[relation.TargetAvID] = true
for _, bt := range treenode.GetBlockTrees(treenode.GetMirrorAttrViewBlockIDs(relation.TargetAvID)) {
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if ("" == password || CheckPublishAuthCookie(c, passwordID, password)) &&
CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishInvisible) &&
CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishDisable) {
accessibleTargetAvIDs[relation.TargetAvID] = true
break
}
}
}
if accessibleTargetAvIDs[relation.TargetAvID] {
relations = append(relations, relation)
}
}
if 1 > len(relations) {
continue
}
backlink.Relations = relations
databaseAccessible := false
blockTrees := cachedBlockTrees[backlink.AvID]
if nil == blockTrees {
blockTrees = treenode.GetBlockTrees(backlink.BlockIDs)
cachedBlockTrees[backlink.AvID] = blockTrees
}
for _, blockID := range backlink.BlockIDs {
bt := blockTrees[blockID]
if nil == bt {
continue
}
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if ("" == password || CheckPublishAuthCookie(c, passwordID, password)) &&
CheckBlockTreeDiscoverableByPublishAccess(publishAccess, bt) {
databaseAccessible = true
backlink.DatabaseBlockID = bt.ID
backlink.BoxID = bt.BoxID
backlink.DatabasePath = bt.HPath
break
}
}
if !databaseAccessible {
continue
}
if "" != backlink.BoundBlockID && !backlink.IsDetached {
bt := treenode.GetBlockTree(backlink.BoundBlockID)
if nil == bt {
continue
}
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if ("" != password && !CheckPublishAuthCookie(c, passwordID, password)) ||
!CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishInvisible) ||
!CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishDisable) {
continue
}
}
ret.Items = append(ret.Items, backlink)
}
ret.Total = len(ret.Items)
return
}
func FilterBlockInfoByPublishAccess(c *gin.Context, publishAccess PublishAccess, info *BlockInfo) (ret *BlockInfo) {
ret = info
if info == nil {
return
}
// 反链块 ID 逐个按发布访问过滤,避免读者据此获知禁止发布、密码保护文档中的引用块
ret.RefIDs = FilterRefIDsByPublishAccess(c, publishAccess, ret.RefIDs)
ret.RefCount = len(ret.RefIDs)
publishIgnore := GetDisablePublishAccess(publishAccess)
filteredAttrViews := []*AttrView{}
avIDs := []string{}
for _, attrView := range info.AttrViews {
avBlocksAccessable := false
if attrView.ID != "" {
avBlockIDs := treenode.GetMirrorAttrViewBlockIDs(attrView.ID)
avBlocks := treenode.GetBlockTrees(avBlockIDs)
for _, avBlock := range avBlocks {
passwordID, password := GetPathPasswordByPublishAccess(avBlock.BoxID, avBlock.Path, publishAccess)
if (password == "" || CheckPublishAuthCookie(c, passwordID, password)) && CheckPathAccessableByPublishIgnore(avBlock.BoxID, avBlock.Path, publishIgnore) {
avBlocksAccessable = true
break
}
}
}
if avBlocksAccessable {
filteredAttrViews = append(filteredAttrViews, attrView)
avIDs = append(avIDs, attrView.ID)
}
}
ret.AttrViews = filteredAttrViews
ret.IAL[av.NodeAttrNameAvs] = strings.Join(avIDs, ",")
bt := treenode.GetBlockTree(info.RootID)
if nil == bt {
// 无法定位文档路径时不给出下级文档数,避免泄漏发布排除文档的数量
ret.SubFileCount = 0
return
}
// 下级文档数只统计发布可见的文档,与读者可见的文档树口径一致
if 0 < ret.SubFileCount {
if IsBoxDoc(bt.BoxID, bt.ID) {
ret.SubFileCount = BoxDocSubFileCountForPublish(bt.BoxID, publishAccess)
} else {
ret.SubFileCount = BoxDocSubFileCountForPublishAt(bt.BoxID, bt.Path, publishAccess)
}
}
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if (password != "" && !CheckPublishAuthCookie(c, passwordID, password)) || !CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishIgnore) {
ret.IAL["name"] = ""
ret.IAL["alias"] = ""
ret.IAL["memo"] = ""
ret.IAL["bookmark"] = ""
ret.IAL["tags"] = ""
ret.RefCount = 0
ret.RefIDs = []string{}
}
return
}
func FilterContentByPublishAccess(c *gin.Context, publishAccess PublishAccess, box string, docPath string, content string, onlyIcon bool) string {
ret, _ := FilterContentByPublishAccessWithStatus(c, publishAccess, box, docPath, content, onlyIcon)
return ret
}
func FilterContentByPublishAccessWithStatus(c *gin.Context, publishAccess PublishAccess, box string, docPath string, content string, onlyIcon bool) (ret string, status PublishAccessStatus) {
ret = content
status = PublishAccessAllowed
// 密码访问
passwordID, password := GetPathPasswordByPublishAccess(box, docPath, publishAccess)
if password != "" {
if !CheckPublishAuthCookie(c, passwordID, password) {
status = PublishAccessPasswordRequired
if onlyIcon {
passwordHTML := `<div class="protyle-password protyle-password--alert" data-node-id="%s">
<span class="protyle-password__logo">🔒</span>
</div>`
ret = fmt.Sprintf(passwordHTML, passwordID)
} else {
passwordHTML := `<div class="protyle-password" data-node-id="%s">
<span class="protyle-password__logo">🔒</span>
<label class="b3-form__icon protyle-password__content">
<svg class="b3-form__icon-icon"><use xlink:href="#iconKey"></use></svg>
<input type="text" class="b3-form__icon-input b3-text-field b3-form__icona-input" placeholder="%s"/>
<svg class="protyle-password__button b3-form__icona-icon"><use xlink:href="#iconForward"></use></svg>
</label>
</div>`
ret = fmt.Sprintf(passwordHTML, passwordID, Conf.Language(283))
}
}
}
// 禁止访问
ID := box
if docPath != "/" {
ID = strings.TrimSuffix(path.Base(docPath), ".sy")
}
publishIgnore := GetDisablePublishAccess(publishAccess)
if !CheckPathAccessableByPublishIgnore(box, docPath, publishIgnore) {
status = PublishAccessDenied
if onlyIcon {
forbiddenHTML := `<div class="protyle-password protyle-password--alert" data-node-id="%s">
<span class="protyle-password__logo">🚫</span>
</div>`
ret = fmt.Sprintf(forbiddenHTML, ID)
} else {
forbiddenHTML := `<div class="protyle-password protyle-password--forbidden" data-node-id="%s">
<span class="protyle-password__logo">🚫</span>
<div class="protyle-password__tip">%s</div>
</div>`
ret = fmt.Sprintf(forbiddenHTML, ID, Conf.Language(284))
}
}
return
}
func FilterEmbedBlocksByPublishAccess(c *gin.Context, publishAccess PublishAccess, embedBlocks []*EmbedBlock) (ret []*EmbedBlock) {
ret = []*EmbedBlock{}
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
for _, embedBlock := range embedBlocks {
if nil == embedBlock || nil == embedBlock.Block {
continue
}
block := embedBlock.Block
passwordID, password := GetPathPasswordByPublishAccess(block.Box, block.Path, publishAccess)
accessible := CheckPathAccessableByPublishIgnore(block.Box, block.Path, publishInvisible) &&
CheckPathAccessableByPublishIgnore(block.Box, block.Path, publishDisable) &&
(password == "" || CheckPublishAuthCookie(c, passwordID, password))
if !accessible {
// 不返回不可访问的查询结果,避免泄漏结果数量、顺序和访问控制边界。
continue
}
ret = append(ret, &EmbedBlock{
Block: &Block{
ID: block.ID,
Content: block.Content,
},
BlockPaths: embedBlock.BlockPaths,
AllowChildOperation: embedBlock.AllowChildOperation,
})
}
return
}
func FilterPathsByPublishAccess(c *gin.Context, publishAccess PublishAccess, paths []*Path) (ret []*Path) {
ret = []*Path{}
IDs := []string{}
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
for _, path := range paths {
IDs = append(IDs, path.ID)
}
bts := treenode.GetBlockTrees(IDs)
for _, path := range paths {
bt := bts[path.ID]
if bt == nil {
continue
}
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishInvisible) &&
CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishDisable) &&
(password == "" || CheckPublishAuthCookie(c, passwordID, password)) {
ret = append(ret, path)
}
}
return
}
func FilterBlocksByPublishAccess(c *gin.Context, publishAccess PublishAccess, blocks []*Block) (ret []*Block) {
ret = []*Block{}
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
for _, block := range blocks {
passwordID, password := GetPathPasswordByPublishAccess(block.Box, block.Path, publishAccess)
if CheckPathAccessableByPublishIgnore(block.Box, block.Path, publishInvisible) &&
CheckPathAccessableByPublishIgnore(block.Box, block.Path, publishDisable) &&
(c == nil || password == "" || CheckPublishAuthCookie(c, passwordID, password)) {
ret = append(ret, block)
}
}
return
}
// GetPublishAccessSearchExclusion 返回当前读者在全库搜索中不可见的笔记本 ID 和文档 ID 排除集合。
// 排除来源包括隐藏、禁止发布以及未通过密码验证的发布访问条目,保证搜索计数和分页不泄露这些条目。
// denyAll 为 true 时当前读者不可见任何内容,调用方应直接返回空结果。
func GetPublishAccessSearchExclusion(c *gin.Context) (denyAll bool, boxIDs, docIDs []string) {
publishAccess := GetPublishAccess()
denied := PublishAccess{}
denied = append(denied, GetInvisiblePublishAccess(publishAccess)...)
denied = append(denied, GetDisablePublishAccess(publishAccess)...)
for _, item := range publishAccess {
if "" != item.Password && !CheckPublishAuthCookie(c, item.ID, item.Password) {
denied = append(denied, item)
}
}
boxIDSet := map[string]bool{}
docIDSet := map[string]bool{}
for _, item := range denied {
if publishAccessDenyAllID == item.ID {
return true, nil, nil
}
if !ast.IsNodeIDPattern(item.ID) {
continue
}
if filelock.IsExist(filepath.Join(util.DataDir, item.ID)) {
boxIDSet[item.ID] = true
} else {
docIDSet[item.ID] = true
}
}
for boxID := range boxIDSet {
boxIDs = append(boxIDs, boxID)
}
for docID := range docIDSet {
docIDs = append(docIDs, docID)
}
return
}
func FilterSearchDocsByPublishAccess(c *gin.Context, publishAccess PublishAccess, docs []map[string]string) (ret []map[string]string) {
ret = []map[string]string{}
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
for _, doc := range docs {
box, docPath := doc["box"], doc["path"]
if !ast.IsNodeIDPattern(box) || (docPath != "/" && !strings.HasPrefix(docPath, "/")) {
continue
}
passwordID, password := GetPathPasswordByPublishAccess(box, docPath, publishAccess)
if CheckPathAccessableByPublishIgnore(box, docPath, publishInvisible) &&
CheckPathAccessableByPublishIgnore(box, docPath, publishDisable) &&
(password == "" || CheckPublishAuthCookie(c, passwordID, password)) {
ret = append(ret, doc)
}
}
return
}
func filterBlockTreesByPublishAccess(c *gin.Context, publishAccess PublishAccess, bts map[string]*treenode.BlockTree) (ret map[string]*treenode.BlockTree) {
ret = map[string]*treenode.BlockTree{}
for id, bt := range bts {
if !CheckBlockTreeDiscoverableByPublishAccess(publishAccess, bt) {
continue
}
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if password != "" && !CheckPublishAuthCookie(c, passwordID, password) {
continue
}
ret[id] = bt
}
return
}
func FilterRefDefsByPublishAccess(c *gin.Context, publishAccess PublishAccess, refDefs []*RefDefs) (retRefDefs []*RefDefs, originalRefBlockIDs map[string]string) {
retRefDefs = []*RefDefs{}
IDs := []string{}
for _, refDef := range refDefs {
IDs = append(IDs, refDef.RefID)
IDs = append(IDs, refDef.DefIDs...)
}
IDs = gulu.Str.RemoveDuplicatedElem(IDs)
bts := treenode.GetBlockTrees(IDs)
bts = filterBlockTreesByPublishAccess(c, publishAccess, bts)
visibles := make(map[string]bool)
for _, ID := range IDs {
visibles[ID] = false
}
for _, bt := range bts {
visibles[bt.ID] = true
}
for _, refDef := range refDefs {
if !visibles[refDef.RefID] {
continue
}
newDefIDs := []string{}
for i, defID := range refDef.DefIDs {
if visibles[defID] {
newDefIDs = append(newDefIDs, refDef.DefIDs[i])
}
}
refDef.DefIDs = newDefIDs
if len(refDef.DefIDs) > 0 {
retRefDefs = append(retRefDefs, refDef)
}
}
retRefDefs, originalRefBlockIDs = buildBacklinkListItemRefs(retRefDefs)
return
}
func FilterRefIDsByPublishAccess(c *gin.Context, publishAccess PublishAccess, refIDs []string) (ret []string) {
ret = []string{}
bts := treenode.GetBlockTrees(refIDs)
bts = filterBlockTreesByPublishAccess(c, publishAccess, bts)
for _, refID := range refIDs {
if nil != bts[refID] {
ret = append(ret, refID)
}
}
return
}
func FilterGraphByPublishAccess(c *gin.Context, publishAccess PublishAccess, nodes []*GraphNode, links []*GraphLink) (retNodes []*GraphNode, retLinks []*GraphLink) {
retNodes = []*GraphNode{}
retLinks = []*GraphLink{}
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
nodeByID := make(map[string]*GraphNode, len(nodes))
virtualNodeIDs := map[string]bool{}
nodeBaseSizes := make(map[string]float64, len(nodes))
for _, node := range nodes {
if node.Box == "" && node.Path == "" {
nodeByID[node.ID] = node
virtualNodeIDs[node.ID] = true
} else {
if node.Box == "" || node.Path == "" || !CheckPathAccessableByPublishIgnore(node.Box, node.Path, publishInvisible) ||
!CheckPathAccessableByPublishIgnore(node.Box, node.Path, publishDisable) {
continue
}
passwordID, password := GetPathPasswordByPublishAccess(node.Box, node.Path, publishAccess)
if password != "" && !CheckPublishAuthCookie(c, passwordID, password) {
continue
}
nodeByID[node.ID] = node
}
baseSize := node.Size
if 0 < node.Defs {
baseSize /= math.Log2(float64(node.Defs)) + 1
}
nodeBaseSizes[node.ID] = baseSize
}
filteredLinks := make([]*GraphLink, 0, len(links))
for _, link := range links {
if link.From == link.To || nodeByID[link.From] == nil || nodeByID[link.To] == nil {
continue
}
filteredLinks = append(filteredLinks, link)
}
reachableNodeIDs := make(map[string]bool, len(nodeByID))
for nodeID := range nodeByID {
if !virtualNodeIDs[nodeID] {
reachableNodeIDs[nodeID] = true
}
}
for _, link := range filteredLinks {
if virtualNodeIDs[link.From] && !virtualNodeIDs[link.To] {
reachableNodeIDs[link.From] = true
}
if virtualNodeIDs[link.To] && !virtualNodeIDs[link.From] {
reachableNodeIDs[link.To] = true
}
}
for _, node := range nodes {
if nodeByID[node.ID] != nil && reachableNodeIDs[node.ID] {
node.Refs = 0
node.Defs = 0
node.Size = nodeBaseSizes[node.ID]
retNodes = append(retNodes, node)
}
}
for _, link := range filteredLinks {
from, fromOK := nodeByID[link.From]
to, toOK := nodeByID[link.To]
if !fromOK || !toOK || !reachableNodeIDs[link.From] || !reachableNodeIDs[link.To] {
continue
}
from.Refs++
if link.Ref {
to.Defs++
to.Size = (math.Log2(float64(to.Defs)) + 1) * nodeBaseSizes[to.ID]
}
retLinks = append(retLinks, link)
}
return
}
func FilterTagsByPublishAccess(c *gin.Context, publishAccess PublishAccess, tags *Tags) (ret *Tags) {
return filterTagsByPublishAccess(c, publishAccess, tags, sql.QueryTagSpans(""))
}
func filterTagsByPublishAccess(c *gin.Context, publishAccess PublishAccess, tags *Tags, spans []*sql.Span) (ret *Tags) {
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
labelCounts := make(map[string]int)
for _, span := range spans {
if !CheckPathAccessableByPublishIgnore(span.Box, span.Path, publishInvisible) ||
!CheckPathAccessableByPublishIgnore(span.Box, span.Path, publishDisable) {
continue
}
passwordID, password := GetPathPasswordByPublishAccess(span.Box, span.Path, publishAccess)
if password != "" && !CheckPublishAuthCookie(c, passwordID, password) {
continue
}
label := util.UnescapeHTML(span.Content)
labelCounts[label] += 1
}
ret = &Tags{}
for _, tag := range *tags {
tag := reassignTagCounts(tag, labelCounts)
if tag != nil {
*ret = append(*ret, tag)
}
}
return
}
func reassignTagCounts(tag *Tag, counts map[string]int) (ret *Tag) {
var newChildren Tags
for _, child := range tag.Children {
child = reassignTagCounts(child, counts)
if child != nil {
newChildren = append(newChildren, child)
}
}
tag.Children = newChildren
tag.Count = counts[tag.Label]
if tag.Children == nil && tag.Count == 0 {
return nil
}
return tag
}
// 发布模式下默认不返回管理员的本地工作状态,新增键只有在确认不含敏感信息后才能加入白名单。
var publishLocalStorageAllowedKeys = []string{}
func FilterLocalStorageByPublishAccess(localStorage map[string]any) (ret map[string]any) {
ret = map[string]any{}
for _, key := range publishLocalStorageAllowedKeys {
if value, ok := localStorage[key]; ok {
ret[key] = value
}
}
return
}
func FilterAssetContentByPublishAccess(c *gin.Context, publishAccess PublishAccess, assetContent []*AssetContent) (ret []*AssetContent) {
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
validAssets := []string{}
bts := treenode.GetBlockTreesByType("d")
for _, bt := range bts {
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishInvisible) &&
CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishDisable) &&
(password == "" || CheckPublishAuthCookie(c, passwordID, password)) {
assets, err := DocAssets(bt.ID, false)
if err == nil {
validAssets = append(validAssets, assets...)
}
}
}
ret = []*AssetContent{}
for _, asset := range assetContent {
if asset == nil {
continue
}
for _, validAsset := range validAssets {
if validAsset == asset.Path {
ret = append(ret, asset)
}
}
}
return
}
func FilterRecentDocsByPublishAccess(c *gin.Context, publishAccess PublishAccess, recentDocs []*RecentDoc) (ret []*RecentDoc) {
ret = []*RecentDoc{}
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
for _, recentDoc := range recentDocs {
bt := treenode.GetBlockTree(recentDoc.RootID)
if bt != nil {
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishInvisible) &&
CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishDisable) &&
(passwordID == "" || CheckPublishAuthCookie(c, passwordID, password)) {
ret = append(ret, recentDoc)
}
}
}
return
}
func FilterCriteriaByPublishAccess(c *gin.Context, publishAccess PublishAccess, criteria []*Criterion) (ret []*Criterion) {
ret = []*Criterion{}
publishInvisible := GetInvisiblePublishAccess(publishAccess)
publishDisable := GetDisablePublishAccess(publishAccess)
// IDPath 元素可能是笔记本 ID、文档 ID,或 "笔记本ID/文档ID[.sy]" 路径串,这里统一解析出文档 ID
blockIDs := map[string]struct{}{}
for _, criterion := range criteria {
for _, p := range criterion.IDPath {
p = strings.TrimSpace(p)
if p == "" {
continue
}
// 路径形式取末段并去掉 .sy 后缀
id := strings.TrimSuffix(path.Base(p), ".sy")
if id != "" && id != "." && id != "/" {
blockIDs[id] = struct{}{}
}
}
}
blockIDsSlice := make([]string, 0, len(blockIDs))
for id := range blockIDs {
blockIDsSlice = append(blockIDsSlice, id)
}
blockTrees := treenode.GetBlockTrees(blockIDsSlice)
for _, criterion := range criteria {
accessible := false
for _, p := range criterion.IDPath {
p = strings.TrimSpace(p)
if p == "" {
continue
}
id := strings.TrimSuffix(path.Base(p), ".sy")
if id == "" || id == "." || id == "/" {
continue
}
bt := blockTrees[id]
if bt == nil {
// 关联的文档不存在,视为不可访问
accessible = false
break
}
passwordID, password := GetPathPasswordByPublishAccess(bt.BoxID, bt.Path, publishAccess)
if !CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishInvisible) ||
!CheckPathAccessableByPublishIgnore(bt.BoxID, bt.Path, publishDisable) ||
(passwordID != "" && !CheckPublishAuthCookie(c, passwordID, password)) {
accessible = false
break
}
accessible = true
}
if !accessible {
// 若 IDPath 全部不可访问(或引用了不可见文档),整条丢弃,避免泄露 HPath
continue
}
// 复制一份后再清空搜索/替换关键字,避免污染缓存
cloned := *criterion
cloned.K = ""
cloned.R = ""
ret = append(ret, &cloned)
}
return
}