Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

:recycle: Read business errors from errors

Jeffrey Chen33086e2cf17d
diff --git a/kernel/api/account.go b/kernel/api/account.go
index 5c9a407b0e..b199db5043 100644
--- a/kernel/api/account.go
+++ b/kernel/api/account.go
@@ -17,9 +17,6 @@
package api
import (
- "encoding/json"
-
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/apicontract"
"github.com/siyuan-note/siyuan/kernel/model"
@@ -48,18 +45,6 @@ var deactivateUser = contractHandler(apicontract.DeactivateUser, func(c *gin.Con
return apicontract.Success(apicontract.Null{})
})
var login = contractHandler(apicontract.AccountLogin, func(c *gin.Context, request apicontract.AccountLoginRequest) apicontract.Response[*apicontract.AccountLoginData] {
- result := model.Login(request.UserName, request.UserPassword, request.Captcha, int(request.CloudRegion))
- return accountLoginResponse(result)
+ data, code, msg := model.Login(request.UserName, request.UserPassword, request.Captcha, int(request.CloudRegion))
+ return apicontract.AccountLogin.FailureWithData(code, msg, data)
})
-
-func accountLoginResponse(result *gulu.Result) apicontract.Response[*apicontract.AccountLoginData] {
- raw, err := json.Marshal(result.Data)
- if err != nil {
- return apicontract.Failure[*apicontract.AccountLoginData](-1, err.Error())
- }
- var data *apicontract.AccountLoginData
- if err = json.Unmarshal(raw, &data); err != nil {
- return apicontract.Failure[*apicontract.AccountLoginData](-1, err.Error())
- }
- return apicontract.AccountLogin.FailureWithData(result.Code, result.Msg, data)
-}
diff --git a/kernel/api/agent.go b/kernel/api/agent.go
index 0fe15b2ac2..2e1cce9390 100644
--- a/kernel/api/agent.go
+++ b/kernel/api/agent.go
@@ -78,10 +78,7 @@ func agentChatContract(c *gin.Context, request apicontract.AIAgentChatRequest) a
selectedProvider, selectedModel = confAISnapshot.GetAgentModel()
}
if nil == selectedProvider || nil == selectedModel {
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = model.Conf.Language(193)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(193))
}
client := model.NewAIProviderClient(selectedProvider, selectedModel.Name)
@@ -105,10 +102,7 @@ func agentChatContract(c *gin.Context, request apicontract.AIAgentChatRequest) a
sessionsMu.Lock()
if _, ok := runningSessions[req.SessionID]; ok {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = "session is busy in another instance"
- return apicontract.AIAgentChat.WithHTTPStatus(contractFailure[apicontract.Null](ret), http.StatusConflict)
+ return apicontract.AIAgentChat.WithHTTPStatus(apicontract.Failure[apicontract.Null](-1, "session is busy in another instance"), http.StatusConflict)
}
ctx, cancel := context.WithCancel(c.Request.Context())
ctx = util.ContextWithOpenAIResponsesBaseURL(ctx, selectedProvider.BaseURL)
@@ -250,19 +244,14 @@ func finishRunningSession(sessionID string, running *runningSession) {
var agentChatConfirm = contractHandler(apicontract.AIAgentConfirm, agentChatConfirmContract)
func agentChatConfirmContract(c *gin.Context, req apicontract.AIConfirmRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
accepted, err := agent.ConfirmSession(req.ConfirmID, req.Approved, req.Always)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if !accepted {
- ret.Code = -1
- ret.Msg = "agent confirmation expired"
- return apicontract.AIAgentConfirm.WithHTTPStatus(contractFailure[apicontract.Null](ret), http.StatusConflict)
+ return apicontract.AIAgentConfirm.WithHTTPStatus(apicontract.Failure[apicontract.Null](-1, "agent confirmation expired"), http.StatusConflict)
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var setAgentSessionPermission = contractHandler(apicontract.AIAgentSetPermission, setAgentSessionPermissionContract)
@@ -280,11 +269,8 @@ func setAgentSessionPinnedContract(c *gin.Context, req apicontract.AISessionPinn
}
func setAgentSessionPermissionContract(c *gin.Context, req apicontract.AIPermissionRequest) apicontract.Response[apicontract.AIPermissionData] {
- ret := gulu.Ret.NewResult()
if err := agent.SetSessionPermissionMode(req.SessionID, req.PermissionMode); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.AIPermissionData](ret)
+ return apicontract.Failure[apicontract.AIPermissionData](-1, err.Error())
}
return apicontract.WithAfterWrite(apicontract.Success(apicontract.AIPermissionData{PermissionMode: req.PermissionMode}), func() {
broadcastAgentSessionChanged(c.GetHeader("X-SiYuan-App-ID"), req.SessionID, "permission")
@@ -294,25 +280,19 @@ func setAgentSessionPermissionContract(c *gin.Context, req apicontract.AIPermiss
var agentChatQuestion = contractHandler(apicontract.AIAgentQuestion, agentChatQuestionContract)
func agentChatQuestionContract(c *gin.Context, req apicontract.AIQuestionRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
if !agent.AnswerQuestion(req.QuestionID, req.Answers) {
- ret.Code = -1
- ret.Msg = "agent question expired"
- return apicontract.AIAgentQuestion.WithHTTPStatus(contractFailure[apicontract.Null](ret), http.StatusConflict)
+ return apicontract.AIAgentQuestion.WithHTTPStatus(apicontract.Failure[apicontract.Null](-1, "agent question expired"), http.StatusConflict)
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var agentChatBrowserCapabilityResult = contractHandler(apicontract.AIAgentBrowserCapabilityResult, agentChatBrowserCapabilityResultContract)
func agentChatBrowserCapabilityResultContract(c *gin.Context, req apicontract.AIBrowserCapabilityResultRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
if !agent.BrowserCapabilityResult(req.CallID, req.Result, req.StructuredContent, req.StructuredContentSet, req.IsError) {
- ret.Code = -1
- ret.Msg = "agent browser capability call expired"
- return apicontract.AIAgentBrowserCapabilityResult.WithHTTPStatus(contractFailure[apicontract.Null](ret), http.StatusConflict)
+ return apicontract.AIAgentBrowserCapabilityResult.WithHTTPStatus(apicontract.Failure[apicontract.Null](-1, "agent browser capability call expired"), http.StatusConflict)
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var lsCapabilities = contractHandler(apicontract.AIListCapabilities, lsCapabilitiesContract)
@@ -335,10 +315,7 @@ func agentChatTitleContract(c *gin.Context, req apicontract.AITitleRequest) apic
selectedProvider, selectedModel = confAISnapshot.GetAgentModel()
}
if nil == selectedProvider || nil == selectedModel {
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = "no AI provider configured"
- return contractFailure[string](ret)
+ return apicontract.Failure[string](-1, "no AI provider configured")
}
client := model.NewAIProviderClient(selectedProvider, selectedModel.Name)
@@ -369,10 +346,7 @@ func getSessionContract(c *gin.Context, req apicontract.AISessionIDRequest) apic
if !running {
if err := agent.FinalizeOrphanedTurn(req.ID); err != nil {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.AIGetSession.WithHTTPStatus(contractFailure[*apicontract.AISession](ret), http.StatusInternalServerError)
+ return apicontract.AIGetSession.WithHTTPStatus(apicontract.Failure[*apicontract.AISession](-1, err.Error()), http.StatusInternalServerError)
}
}
session, err := agent.GetSessionState(req.ID, !running)
@@ -381,10 +355,7 @@ func getSessionContract(c *gin.Context, req apicontract.AISessionIDRequest) apic
}
sessionsMu.Unlock()
if err != nil {
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[*apicontract.AISession](ret)
+ return apicontract.Failure[*apicontract.AISession](-1, err.Error())
}
payload, err := aiSessionContract(session)
@@ -402,23 +373,16 @@ func removeSessionContract(c *gin.Context, req apicontract.AISessionIDRequest) a
_, running := runningSessions[req.ID]
if running {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = "session is running"
- return apicontract.AIRemoveSession.WithHTTPStatus(contractFailure[apicontract.Null](ret), http.StatusConflict)
+ return apicontract.AIRemoveSession.WithHTTPStatus(apicontract.Failure[apicontract.Null](-1, "session is running"), http.StatusConflict)
}
err := agent.DeleteSession(req.ID)
sessionsMu.Unlock()
if err != nil {
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.AIRemoveSession.WithHTTPStatus(contractFailure[apicontract.Null](ret), http.StatusInternalServerError)
+ return apicontract.AIRemoveSession.WithHTTPStatus(apicontract.Failure[apicontract.Null](-1, err.Error()), http.StatusInternalServerError)
}
// 通知其他实例:会话已删除,刷新列表;若为当前会话则清空视图。
broadcastAgentSessionChanged(c.GetHeader("X-SiYuan-App-ID"), req.ID, "delete")
- ret := gulu.Ret.NewResult()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var saveSession = contractHandler(apicontract.AISaveSession, saveSessionContract)
@@ -428,19 +392,13 @@ func saveSessionContract(c *gin.Context, req apicontract.AISession) apicontract.
var err error
var meta sessionMeta
if gulu.JSON.UnmarshalJSON(body, &meta) != nil || meta.ID == "" {
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = "invalid session data"
- return apicontract.AISaveSession.WithHTTPStatus(contractFailure[apicontract.AISessionSaveData](ret), http.StatusBadRequest)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.Failure[apicontract.AISessionSaveData](-1, "invalid session data"), http.StatusBadRequest)
}
sessionsMu.Lock()
running := runningSessions[meta.ID]
if running != nil && running.app != c.GetHeader("X-SiYuan-App-ID") {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = "session is running in another instance"
- return apicontract.AISaveSession.WithHTTPStatus(contractFailure[apicontract.AISessionSaveData](ret), http.StatusConflict)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.Failure[apicontract.AISessionSaveData](-1, "session is running in another instance"), http.StatusConflict)
}
commitTurnID := meta.CommitTurnID
if commitTurnID == "" {
@@ -450,57 +408,39 @@ func saveSessionContract(c *gin.Context, req apicontract.AISession) apicontract.
var payload map[string]any
if err := gulu.JSON.UnmarshalJSON(body, &payload); err != nil {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.AISaveSession.WithHTTPStatus(contractFailure[apicontract.AISessionSaveData](ret), http.StatusBadRequest)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.Failure[apicontract.AISessionSaveData](-1, err.Error()), http.StatusBadRequest)
}
payload["commitTurnID"] = running.turnID
body, err = gulu.JSON.MarshalJSON(payload)
if err != nil {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.AISaveSession.WithHTTPStatus(contractFailure[apicontract.AISessionSaveData](ret), http.StatusInternalServerError)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.Failure[apicontract.AISessionSaveData](-1, err.Error()), http.StatusInternalServerError)
}
commitTurnID = running.turnID
}
if running == nil {
if runtimeErr := agent.FinalizeOrphanedTurn(meta.ID); runtimeErr != nil {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = runtimeErr.Error()
- return apicontract.AISaveSession.WithHTTPStatus(contractFailure[apicontract.AISessionSaveData](ret), http.StatusInternalServerError)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.Failure[apicontract.AISessionSaveData](-1, runtimeErr.Error()), http.StatusInternalServerError)
}
// 未携带 commitTurnID 的前端在流结束后从终止检查点补出提交标识。
if commitTurnID == "" && c.GetHeader("X-SiYuan-Agent-Checkpoint") != "2" {
recoverableTurnID, runtimeErr := agent.RecoverableTurnID(meta.ID)
if runtimeErr != nil {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = runtimeErr.Error()
- return apicontract.AISaveSession.WithHTTPStatus(contractFailure[apicontract.AISessionSaveData](ret), http.StatusInternalServerError)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.Failure[apicontract.AISessionSaveData](-1, runtimeErr.Error()), http.StatusInternalServerError)
}
if recoverableTurnID != "" {
var payload map[string]any
if err := gulu.JSON.UnmarshalJSON(body, &payload); err != nil {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.AISaveSession.WithHTTPStatus(contractFailure[apicontract.AISessionSaveData](ret), http.StatusBadRequest)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.Failure[apicontract.AISessionSaveData](-1, err.Error()), http.StatusBadRequest)
}
payload["commitTurnID"] = recoverableTurnID
body, err = gulu.JSON.MarshalJSON(payload)
if err != nil {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.AISaveSession.WithHTTPStatus(contractFailure[apicontract.AISessionSaveData](ret), http.StatusInternalServerError)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.Failure[apicontract.AISessionSaveData](-1, err.Error()), http.StatusInternalServerError)
}
commitTurnID = recoverableTurnID
}
@@ -512,17 +452,11 @@ func saveSessionContract(c *gin.Context, req apicontract.AISession) apicontract.
uncommitted, runtimeErr := agent.HasUncommittedTurn(meta.ID)
if runtimeErr != nil {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = runtimeErr.Error()
- return apicontract.AISaveSession.WithHTTPStatus(contractFailure[apicontract.AISessionSaveData](ret), http.StatusInternalServerError)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.Failure[apicontract.AISessionSaveData](-1, runtimeErr.Error()), http.StatusInternalServerError)
}
if uncommitted {
sessionsMu.Unlock()
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = "session has an uncommitted turn"
- return apicontract.AISaveSession.WithHTTPStatus(contractFailure[apicontract.AISessionSaveData](ret), http.StatusConflict)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.Failure[apicontract.AISessionSaveData](-1, "session has an uncommitted turn"), http.StatusConflict)
}
}
@@ -537,13 +471,10 @@ func saveSessionContract(c *gin.Context, req apicontract.AISession) apicontract.
}
sessionsMu.Unlock()
if err != nil {
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = err.Error()
if errors.Is(err, agent.ErrSessionConflict) || errors.Is(err, agent.ErrRuntimeNotFinalized) {
- return apicontract.AISaveSession.WithHTTPStatus(apicontract.AISaveSession.FailureWithData(-1, ret.Msg, apicontract.AISessionSaveData{Revision: revision}), http.StatusConflict)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.AISaveSession.FailureWithData(-1, err.Error(), apicontract.AISessionSaveData{Revision: revision}), http.StatusConflict)
}
- return apicontract.AISaveSession.WithHTTPStatus(contractFailure[apicontract.AISessionSaveData](ret), http.StatusInternalServerError)
+ return apicontract.AISaveSession.WithHTTPStatus(apicontract.Failure[apicontract.AISessionSaveData](-1, err.Error()), http.StatusInternalServerError)
}
// 从 body 解出 sessionID 用于广播。update 仅触发其他实例刷新会话列表元数据,
// 不触发当前视图重绘(重绘由 streamEnd 负责),回避流式中途半截数据的时序问题。
@@ -703,17 +634,13 @@ func lsUserSkillsContract(c *gin.Context, req apicontract.EmptyRequest) apicontr
var getSkill = contractHandler(apicontract.AIGetSkill, getSkillContract)
func getSkillContract(c *gin.Context, req apicontract.AISkillNameRequest) apicontract.Response[apicontract.AISkillData] {
- ret := gulu.Ret.NewResult()
if req.Source != "" {
- ret.Code, ret.Msg = -1, "official skill content requires a confirmed agent workflow"
- return contractFailure[apicontract.AISkillData](ret)
+ return apicontract.Failure[apicontract.AISkillData](-1, "official skill content requires a confirmed agent workflow")
}
content, err := util.ReadSkill(req.Name, model.EnabledUserSkills())
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.AISkillData](ret)
+ return apicontract.Failure[apicontract.AISkillData](-1, err.Error())
}
return apicontract.Success(apicontract.AISkillData{Name: req.Name, Content: content})
@@ -722,50 +649,38 @@ func getSkillContract(c *gin.Context, req apicontract.AISkillNameRequest) apicon
var saveSkill = contractHandler(apicontract.AISaveSkill, saveSkillContract)
func saveSkillContract(c *gin.Context, req apicontract.AISkillSaveRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
if req.Source != "" {
- ret.Code, ret.Msg = -1, "only workspace skills can be modified"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "only workspace skills can be modified")
}
if err := util.SaveSkill(req.Name, req.Content); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var removeSkill = contractHandler(apicontract.AIRemoveSkill, removeSkillContract)
func removeSkillContract(c *gin.Context, req apicontract.AISkillNameRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
if req.Source != "" {
- ret.Code, ret.Msg = -1, "only workspace skills can be modified"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "only workspace skills can be modified")
}
if err := util.RemoveSkill(req.Name); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var renameSkill = contractHandler(apicontract.AIRenameSkill, renameSkillContract)
func renameSkillContract(c *gin.Context, req apicontract.AISkillRenameRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
if req.Source != "" {
- ret.Code, ret.Msg = -1, "only workspace skills can be modified"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "only workspace skills can be modified")
}
if err := util.RenameSkill(req.OldName, req.NewName); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
diff --git a/kernel/api/ai.go b/kernel/api/ai.go
index fb13768991..05f8622342 100644
--- a/kernel/api/ai.go
+++ b/kernel/api/ai.go
@@ -111,10 +111,7 @@ func aiEditorChatContract(c *gin.Context, request apicontract.AIEditorChatReques
req := aiEditorRequest(request)
stream, err := model.NewAIEditorChatStream(c.Request.Context(), req.IDs, req.Input, req.Action, req.History)
if nil != err {
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.StreamSSE[apicontract.Null](func(_ http.ResponseWriter, _ *http.Request) {
defer stream.Close()
@@ -181,13 +178,10 @@ func aiEditorChatContract(c *gin.Context, request apicontract.AIEditorChatReques
var lsAIEditorActions = contractHandler(apicontract.AIListEditorActions, lsAIEditorActionsContract)
func lsAIEditorActionsContract(c *gin.Context, req apicontract.EmptyRequest) apicontract.Response[[]*apicontract.AIEditorAction] {
- ret := gulu.Ret.NewResult()
actions, err := model.GetAIEditorActions()
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.AIEditorAction](ret)
+ return apicontract.Failure[[]*apicontract.AIEditorAction](-1, err.Error())
}
return apicontract.Success(aiEditorActionsContract(actions))
}
@@ -195,7 +189,6 @@ func lsAIEditorActionsContract(c *gin.Context, req apicontract.EmptyRequest) api
var saveAIEditorAction = contractHandler(apicontract.AISaveEditorAction, saveAIEditorActionContract)
func saveAIEditorActionContract(c *gin.Context, req apicontract.AIEditorActionSaveRequest) apicontract.Response[*apicontract.AIEditorAction] {
- ret := gulu.Ret.NewResult()
saved, err := model.SaveAIEditorAction(&model.AIEditorAction{
ID: req.ID,
@@ -203,9 +196,7 @@ func saveAIEditorActionContract(c *gin.Context, req apicontract.AIEditorActionSa
Action: req.Action,
})
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[*apicontract.AIEditorAction](ret)
+ return apicontract.Failure[*apicontract.AIEditorAction](-1, err.Error())
}
return apicontract.Success((*apicontract.AIEditorAction)(saved))
}
@@ -213,13 +204,10 @@ func saveAIEditorActionContract(c *gin.Context, req apicontract.AIEditorActionSa
var removeAIEditorAction = contractHandler(apicontract.AIRemoveEditorAction, removeAIEditorActionContract)
func removeAIEditorActionContract(c *gin.Context, req apicontract.AIEditorActionIDRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
if err := model.RemoveAIEditorAction(req.ID); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Success(apicontract.Null{})
}
// testModel 测试 AI 模型可用性。使用已保存的 Provider 或详情页草稿中的 baseURL/APIKey/超时,
@@ -227,14 +215,11 @@ func removeAIEditorActionContract(c *gin.Context, req apicontract.AIEditorAction
var testModel = contractHandler(apicontract.AITestModel, testModelContract)
func testModelContract(c *gin.Context, req apicontract.AIModelRequest) apicontract.Response[apicontract.AIModelTestData] {
- ret := gulu.Ret.NewResult()
// 支持已保存的 Provider ID 和详情页尚未保存的草稿配置。
provider, err := resolveAIProvider(req.AIProviderRequest)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.AIModelTestData](ret)
+ return apicontract.Failure[apicontract.AIModelTestData](-1, err.Error())
}
var available []string
@@ -325,13 +310,10 @@ func testRerankModelContract(c *gin.Context, req apicontract.EmptyRequest) apico
var listModels = contractHandler(apicontract.AIListModels, listModelsContract)
func listModelsContract(c *gin.Context, req apicontract.AIProviderRequest) apicontract.Response[apicontract.AIModelsData] {
- ret := gulu.Ret.NewResult()
provider, err := resolveAIProvider(req)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.AIModelsData](ret)
+ return apicontract.Failure[apicontract.AIModelsData](-1, err.Error())
}
var metadata []util.AvailableModel
@@ -393,23 +375,17 @@ var mcpOAuthAuthorize = contractHandler(apicontract.AIMCPOAuthAuthorize, mcpOAut
func mcpOAuthAuthorizeContract(c *gin.Context, req apicontract.AIMCPIDRequest) apicontract.Response[apicontract.Null] {
confAISnapshot := model.Conf.LoadAI()
- ret := gulu.Ret.NewResult()
-
serverID := req.ID
if confAISnapshot == nil || confAISnapshot.MCP == nil {
- ret.Code = -1
- ret.Msg = "MCP server not found"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "MCP server not found")
}
for _, server := range confAISnapshot.MCP.Servers {
if server.ID == serverID && server.Enabled && server.Type == "http" {
mcpclient.ReconnectMCPAsync(confAISnapshot.MCP.Servers, []string{serverID}, []string{serverID})
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
}
- ret.Code = -1
- ret.Msg = "MCP server not found"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "MCP server not found")
}
var mcpOAuthDisconnect = contractHandler(apicontract.AIMCPOAuthDisconnect, mcpOAuthDisconnectContract)
@@ -417,17 +393,16 @@ var mcpOAuthDisconnect = contractHandler(apicontract.AIMCPOAuthDisconnect, mcpOA
func mcpOAuthDisconnectContract(c *gin.Context, req apicontract.AIMCPIDRequest) apicontract.Response[apicontract.Null] {
confAISnapshot := model.Conf.LoadAI()
- ret := gulu.Ret.NewResult()
-
serverID := req.ID
- if err := mcpclient.DisconnectMCPOAuth(serverID); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- }
+ // 断开失败不阻止重连,但要在重连后把错误报给调用方。
+ disconnectErr := mcpclient.DisconnectMCPOAuth(serverID)
if confAISnapshot != nil && confAISnapshot.MCP != nil {
mcpclient.ReconnectMCPAsync(confAISnapshot.MCP.Servers, []string{serverID}, nil)
}
- return contractFailure[apicontract.Null](ret)
+ if disconnectErr != nil {
+ return apicontract.Failure[apicontract.Null](-1, disconnectErr.Error())
+ }
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var mcpOAuthCallback = contractHandler(apicontract.AIMCPOAuthCallback, mcpOAuthCallbackContract)
@@ -456,16 +431,14 @@ func mcpOAuthCallbackContract(c *gin.Context, request apicontract.EmptyRequest)
var reindexEmbedding = contractHandler(apicontract.AIReindexEmbedding, reindexEmbeddingContract)
func reindexEmbeddingContract(c *gin.Context, req apicontract.EmptyRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
model.ReindexEmbedding()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
// retryFailedEmbedding 删除失败块的行,使其立即回到主循环重嵌,已成功向量不动,异步执行。
var retryFailedEmbedding = contractHandler(apicontract.AIRetryFailedEmbedding, retryFailedEmbeddingContract)
func retryFailedEmbeddingContract(c *gin.Context, req apicontract.EmptyRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
model.RetryFailedEmbedding()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
diff --git a/kernel/api/archive.go b/kernel/api/archive.go
index 310b6a1b78..24b1eec3d1 100644
--- a/kernel/api/archive.go
+++ b/kernel/api/archive.go
@@ -87,38 +87,27 @@ func resolveArchivePath(path string) (string, error) {
}
var zip = contractHandler(apicontract.Zip, func(c *gin.Context, request apicontract.ZipRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
entryPath, zipFilePath := request.Path, request.ZipPath
entryAbsPath, err := util.GetAbsPathInWorkspace(entryPath)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if err = rejectEncryptedArchivePath(entryAbsPath); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
zipAbsFilePath, err := util.GetAbsPathInWorkspace(zipFilePath)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if err = rejectEncryptedArchivePath(zipAbsFilePath); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
// 在创建归档前检查全部源条目,避免通过父目录打包加密笔记本。
resolvedEntryPath, err := resolveArchivePath(entryAbsPath)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if err = filepath.WalkDir(resolvedEntryPath, func(path string, _ fs.DirEntry, walkErr error) error {
if walkErr != nil {
@@ -126,24 +115,18 @@ var zip = contractHandler(apicontract.Zip, func(c *gin.Context, request apicontr
}
return rejectEncryptedArchivePath(path)
}); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
resolvedZipPath, err := resolveArchivePath(zipAbsFilePath)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if util.IsPluginDevelopmentRawWriteForbidden(resolvedZipPath) {
return apicontract.Failure[apicontract.Null](-1, "managed plugin development files require their dedicated tools")
}
if err = rejectEncryptedArchivePath(resolvedZipPath); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if err = model.CheckDocumentAddressingFileWrite(resolvedZipPath, nil, false); err != nil {
return apicontract.Failure[apicontract.Null](-1, err.Error())
@@ -151,9 +134,7 @@ var zip = contractHandler(apicontract.Zip, func(c *gin.Context, request apicontr
zipFile, err := gulu.Zip.Create(resolvedZipPath)
if err != nil {
logging.LogErrorf("create zip [%s] failed: %s", zipAbsFilePath, err)
- ret.Code = -1
- ret.Msg = "create zip file failed" + errMsgSeeKernelLog
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "create zip file failed"+errMsgSeeKernelLog)
}
base := filepath.Base(entryAbsPath)
@@ -164,60 +145,43 @@ var zip = contractHandler(apicontract.Zip, func(c *gin.Context, request apicontr
}
if err != nil {
logging.LogErrorf("zip add entry [%s] failed: %s", entryAbsPath, err)
- ret.Code = -1
- ret.Msg = "zip failed" + errMsgSeeKernelLog
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "zip failed"+errMsgSeeKernelLog)
}
if err = zipFile.Close(); err != nil {
logging.LogErrorf("close zip [%s] failed: %s", zipAbsFilePath, err)
- ret.Code = -1
- ret.Msg = "close zip file failed" + errMsgSeeKernelLog
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "close zip file failed"+errMsgSeeKernelLog)
}
return apicontract.Success(apicontract.Null{})
})
var unzip = contractHandler(apicontract.Unzip, func(c *gin.Context, request apicontract.UnzipRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
entryPath, zipFilePath := request.Path, request.ZipPath
zipAbsFilePath, err := util.GetAbsPathInWorkspace(zipFilePath)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if err = rejectEncryptedArchivePath(zipAbsFilePath); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
entryAbsPath, err := util.GetAbsPathInWorkspace(entryPath)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if err = rejectEncryptedArchivePath(entryAbsPath); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if !gulu.File.IsExist(zipAbsFilePath) {
- ret.Code = -1
- ret.Msg = "zip file does not exist"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "zip file does not exist")
}
if err := unzipWorkspaceArchive(zipAbsFilePath, entryAbsPath); err != nil {
logging.LogErrorf("unzip [%s] -> [%s] failed: %s", zipAbsFilePath, entryAbsPath, err)
- ret.Code = -1
- ret.Msg = "unzip failed" + errMsgSeeKernelLog
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "unzip failed"+errMsgSeeKernelLog)
}
return apicontract.Success(apicontract.Null{})
diff --git a/kernel/api/attr.go b/kernel/api/attr.go
index 4e55f65d55..fe50945390 100644
--- a/kernel/api/attr.go
+++ b/kernel/api/attr.go
@@ -17,7 +17,6 @@
package api
import (
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/apicontract"
"github.com/siyuan-note/siyuan/kernel/model"
@@ -39,25 +38,21 @@ var batchGetBlockAttrs = contractHandler(apicontract.BatchGetBlockAttrs, func(c
})
var getBlockAttrs = contractHandler(apicontract.GetBlockAttrs, func(c *gin.Context, request apicontract.BlockIDRequest) apicontract.Response[map[string]string] {
- ret := gulu.Ret.NewResult()
-
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[map[string]string](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[map[string]string](err)
}
- if !checkBlockPublishAccess(c, id, ret) {
- return contractFailure[map[string]string](ret)
+ if err := checkBlockPublishAccess(c, id); err != nil {
+ return apicontract.FailureFrom[map[string]string](err)
}
return apicontract.Success(sql.GetBlockAttrs(id))
})
var setBlockAttrs = contractHandler(apicontract.SetBlockAttrs, func(c *gin.Context, request apicontract.SetBlockAttrsRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
attrs := request.Attrs
@@ -80,19 +75,16 @@ var setBlockAttrs = contractHandler(apicontract.SetBlockAttrs, func(c *gin.Conte
}
err := model.SetBlockAttrs(id, nameValues)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
var batchSetBlockAttrs = contractHandler(apicontract.BatchSetBlockAttrs, func(c *gin.Context, request apicontract.BatchSetBlockAttrsRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
var blockAttrs []map[string]any
for _, block := range request.BlockAttrs {
- if util.InvalidIDPattern(block.ID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(block.ID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
attrs := map[string]string{}
for name, value := range block.Attrs {
diff --git a/kernel/api/av.go b/kernel/api/av.go
index f834424e88..a3e1bcf61a 100644
--- a/kernel/api/av.go
+++ b/kernel/api/av.go
@@ -21,7 +21,6 @@ import (
"fmt"
"strings"
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/apicontract"
@@ -32,9 +31,8 @@ import (
)
var removeUnusedAttributeView = contractHandler(apicontract.RemoveUnusedAttributeView, func(c *gin.Context, request apicontract.RemoveUnusedAttributeViewRequest) apicontract.Response[apicontract.AVIDData] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.ID, ret) {
- return contractFailure[apicontract.AVIDData](ret)
+ if err := util.ValidateID(request.ID); err != nil {
+ return apicontract.FailureFrom[apicontract.AVIDData](err)
}
if err := model.RemoveUnusedAttributeView(request.ID); err != nil {
return apicontract.Failure[apicontract.AVIDData](-1, err.Error())
@@ -345,9 +343,20 @@ var getAttributeView = contractHandler(apicontract.GetAttributeView, func(c *gin
})
var getAttributeViewPasteRows = contractHandler(apicontract.GetAttributeViewPasteRows, func(c *gin.Context, request apicontract.GetAttributeViewPasteRowsRequest) apicontract.Response[apicontract.AVPasteRowsData] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.AvID, ret) || util.InvalidIDPattern(request.BlockID, ret) || util.InvalidIDPattern(request.StartItemID, ret) || (request.ViewID != "" && util.InvalidIDPattern(request.ViewID, ret)) || (request.GroupID != "" && util.InvalidIDPattern(request.GroupID, ret)) {
- return contractFailure[apicontract.AVPasteRowsData](ret)
+ if err := util.ValidateID(request.AvID); err != nil {
+ return apicontract.FailureFrom[apicontract.AVPasteRowsData](err)
+ }
+ if err := util.ValidateID(request.BlockID); err != nil {
+ return apicontract.FailureFrom[apicontract.AVPasteRowsData](err)
+ }
+ if err := util.ValidateID(request.StartItemID); err != nil {
+ return apicontract.FailureFrom[apicontract.AVPasteRowsData](err)
+ }
+ if err := util.ValidateOptionalID(request.ViewID); err != nil {
+ return apicontract.FailureFrom[apicontract.AVPasteRowsData](err)
+ }
+ if err := util.ValidateOptionalID(request.GroupID); err != nil {
+ return apicontract.FailureFrom[apicontract.AVPasteRowsData](err)
}
count := int(request.Count)
if request.Count != float64(count) || count < 1 || count > 100000 {
@@ -361,9 +370,11 @@ var getAttributeViewPasteRows = contractHandler(apicontract.GetAttributeViewPast
})
var getAttributeViewFieldViews = contractHandler(apicontract.GetAttributeViewFieldViews, func(c *gin.Context, request apicontract.GetAttributeViewFieldViewsRequest) apicontract.Response[apicontract.AVFieldViewsData] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.AvID, ret) || util.InvalidIDPattern(request.KeyID, ret) {
- return contractFailure[apicontract.AVFieldViewsData](ret)
+ if err := util.ValidateID(request.AvID); err != nil {
+ return apicontract.FailureFrom[apicontract.AVFieldViewsData](err)
+ }
+ if err := util.ValidateID(request.KeyID); err != nil {
+ return apicontract.FailureFrom[apicontract.AVFieldViewsData](err)
}
views, err := model.GetAttributeViewFieldViews(request.AvID, request.KeyID)
if err != nil {
diff --git a/kernel/api/av_row_sort.go b/kernel/api/av_row_sort.go
index 9f23441e6b..35d6d9fb2c 100644
--- a/kernel/api/av_row_sort.go
+++ b/kernel/api/av_row_sort.go
@@ -3,7 +3,6 @@ package api
import (
"fmt"
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/apicontract"
"github.com/siyuan-note/siyuan/kernel/model"
@@ -11,9 +10,11 @@ import (
)
var getAttributeViewRowSort = contractHandler(apicontract.GetAttributeViewRowSort, func(c *gin.Context, request apicontract.GetAttributeViewRowSortRequest) apicontract.Response[apicontract.AVRowSortPreview] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.AvID, ret) || util.InvalidIDPattern(request.ViewID, ret) {
- return contractFailure[apicontract.AVRowSortPreview](ret)
+ if err := util.ValidateID(request.AvID); err != nil {
+ return apicontract.FailureFrom[apicontract.AVRowSortPreview](err)
+ }
+ if err := util.ValidateID(request.ViewID); err != nil {
+ return apicontract.FailureFrom[apicontract.AVRowSortPreview](err)
}
input := model.AttributeViewRowSortRequest{AvID: request.AvID, BlockID: request.BlockID, ViewID: request.ViewID, GroupID: request.GroupID, ItemIDs: request.ItemIDs, PreviousID: request.PreviousID, NextID: request.NextID}
preview, err := model.PrepareAttributeViewRowSort(&input)
diff --git a/kernel/api/block.go b/kernel/api/block.go
index 0ea2f27e10..37a7ce1983 100644
--- a/kernel/api/block.go
+++ b/kernel/api/block.go
@@ -21,7 +21,6 @@ import (
"fmt"
"strings"
- "github.com/88250/gulu"
"github.com/88250/lute/ast"
"github.com/88250/lute/html"
"github.com/88250/lute/parse"
@@ -35,13 +34,12 @@ import (
)
var checkBlockRef = contractHandler(apicontract.CheckBlockRef, func(c *gin.Context, request apicontract.CheckBlockRefRequest) apicontract.Response[bool] {
- ret := gulu.Ret.NewResult()
switch request.Scope {
case "blocks":
ids, exactIDs, deletedIDs := request.IDs, request.ExactIDs, request.DeletedIDs
for _, id := range ids {
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[bool](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[bool](err)
}
}
idSet := map[string]struct{}{}
@@ -49,28 +47,24 @@ var checkBlockRef = contractHandler(apicontract.CheckBlockRef, func(c *gin.Conte
idSet[id] = struct{}{}
}
for _, id := range exactIDs {
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[bool](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[bool](err)
}
if _, exists := idSet[id]; !exists {
- ret.Code = -1
- ret.Msg = "Field [exactIDs] should be a subset of field [ids]"
- return contractFailure[bool](ret)
+ return apicontract.Failure[bool](-1, "Field [exactIDs] should be a subset of field [ids]")
}
}
for _, id := range deletedIDs {
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[bool](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[bool](err)
}
if _, exists := idSet[id]; !exists {
- ret.Code = -1
- ret.Msg = "Field [deletedIDs] should be a subset of field [ids]"
- return contractFailure[bool](ret)
+ return apicontract.Failure[bool](-1, "Field [deletedIDs] should be a subset of field [ids]")
}
}
notebook := request.Notebook
- if "" != notebook && util.InvalidIDPattern(notebook, ret) {
- return contractFailure[bool](ret)
+ if err := util.ValidateOptionalID(notebook); err != nil {
+ return apicontract.FailureFrom[bool](err)
}
if err := holdEncryptedBlockRequests(c, notebook, append([]string{request.ID}, request.IDs...), true); err != nil {
return apicontract.Failure[bool](-1, err.Error())
@@ -105,8 +99,8 @@ var checkBlockRef = contractHandler(apicontract.CheckBlockRef, func(c *gin.Conte
return apicontract.Success(data)
case "notebook":
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[bool](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[bool](err)
}
if err := holdEncryptedBlockRequests(c, notebook, append([]string{request.ID}, request.IDs...), false); err != nil {
return apicontract.Failure[bool](-1, err.Error())
@@ -130,10 +124,8 @@ var checkBlockRef = contractHandler(apicontract.CheckBlockRef, func(c *gin.Conte
}
return apicontract.Success(data)
default:
- ret.Code = -1
- ret.Msg = "invalid block ref check scope"
+ return apicontract.Failure[bool](-1, "invalid block ref check scope")
}
- return contractFailure[bool](ret)
})
var getBlockTreeInfos = contractHandler(apicontract.GetBlockTreeInfos, func(c *gin.Context, request apicontract.BlocksQueryRequest) apicontract.Response[map[string]*apicontract.BlockTreeInfo] {
@@ -173,9 +165,11 @@ var getBlockRelevantIDs = contractHandler(apicontract.GetBlockRelevantIDs, func(
})
var transferBlockRef = contractHandler(apicontract.TransferBlockRef, func(c *gin.Context, request apicontract.TransferBlockRefRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.FromID, ret) || util.InvalidIDPattern(request.ToID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(request.FromID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
+ }
+ if err := util.ValidateID(request.ToID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
var refIDs []string
refIDs = append(refIDs, request.RefIDs...)
@@ -196,9 +190,8 @@ var swapBlockRef = contractHandler(apicontract.SwapBlockRef, func(c *gin.Context
})
var getHeadingChildrenIDs = contractHandler(apicontract.GetHeadingChildrenIDs, func(c *gin.Context, request apicontract.BlockIDRequest) apicontract.Response[[]string] {
- ret := gulu.Ret.NewResult()
- if !checkBlockPublishAccess(c, request.ID, ret) {
- return contractFailure[[]string](ret)
+ if err := checkBlockPublishAccess(c, request.ID); err != nil {
+ return apicontract.FailureFrom[[]string](err)
}
return apicontract.Success(model.GetHeadingChildrenIDs(request.ID))
})
@@ -209,9 +202,8 @@ var appendHeadingChildren = contractHandler(apicontract.AppendHeadingChildren, f
})
var getHeadingChildrenDOM = contractHandler(apicontract.GetHeadingChildrenDOM, func(c *gin.Context, request apicontract.HeadingChildrenRequest) apicontract.Response[string] {
- ret := gulu.Ret.NewResult()
- if !checkBlockPublishAccess(c, request.ID, ret) {
- return contractFailure[string](ret)
+ if err := checkBlockPublishAccess(c, request.ID); err != nil {
+ return apicontract.FailureFrom[string](err)
}
removeFoldAttr := true
if request.RemoveFoldAttr != nil {
@@ -359,15 +351,14 @@ var checkBlocksExist = contractHandler(apicontract.CheckBlocksExist, func(c *gin
})
var getDocInfo = contractHandler(apicontract.GetDocInfo, func(c *gin.Context, request apicontract.BlockQueryRequest) apicontract.Response[*apicontract.DocInfo] {
- ret := gulu.Ret.NewResult()
id := request.ID
boxID, leaseErr := holdContractBlockRequest(c, request.Notebook, request.ID, request.IDs, false)
if leaseErr != nil {
return apicontract.Failure[*apicontract.DocInfo](-1, leaseErr.Error())
}
- if !checkBlockPublishAccessInBox(c, id, boxID, ret) {
- return contractFailure[*apicontract.DocInfo](ret)
+ if err := checkBlockPublishAccessInBox(c, id, boxID); err != nil {
+ return apicontract.FailureFrom[*apicontract.DocInfo](err)
}
var info *model.BlockInfo
@@ -378,15 +369,13 @@ var getDocInfo = contractHandler(apicontract.GetDocInfo, func(c *gin.Context, re
info, err = model.GetDocInfo(id)
}
if nil == info {
- ret.Code = -1
+ msg := fmt.Sprintf(model.Conf.Language(15), id)
if errors.Is(err, model.ErrIndexing) {
- ret.Msg = model.Conf.Language(56)
+ msg = model.Conf.Language(56)
} else if err != nil && !errors.Is(err, model.ErrTreeNotFound) {
- ret.Msg = err.Error()
- } else {
- ret.Msg = fmt.Sprintf(model.Conf.Language(15), id)
+ msg = err.Error()
}
- return contractFailure[*apicontract.DocInfo](ret)
+ return apicontract.Failure[*apicontract.DocInfo](-1, msg)
}
if model.IsReadOnlyRoleContext(c) {
publishAccess := model.GetPublishAccess()
@@ -396,7 +385,6 @@ var getDocInfo = contractHandler(apicontract.GetDocInfo, func(c *gin.Context, re
})
var getDocsInfo = contractHandler(apicontract.GetDocsInfo, func(c *gin.Context, request apicontract.DocsInfoRequest) apicontract.Response[[]*apicontract.DocInfo] {
- ret := gulu.Ret.NewResult()
idsArg := request.IDs
isReadOnlyRole := model.IsReadOnlyRoleContext(c)
@@ -419,9 +407,7 @@ var getDocsInfo = contractHandler(apicontract.GetDocsInfo, func(c *gin.Context,
queryAv := request.AV
info := model.GetDocsInfo(ids, queryRefCount, queryAv)
if nil == info {
- ret.Code = -1
- ret.Msg = fmt.Sprintf(model.Conf.Language(15), ids)
- return contractFailure[[]*apicontract.DocInfo](ret)
+ return apicontract.Failure[[]*apicontract.DocInfo](-1, fmt.Sprintf(model.Conf.Language(15), ids))
}
if isReadOnlyRole {
for i, docinfo := range info {
@@ -454,13 +440,12 @@ var getBlocksWordCount = contractHandler(apicontract.GetBlocksWordCount, func(c
})
var getTreeStat = contractHandler(apicontract.GetTreeStat, func(c *gin.Context, request apicontract.TreeStatRequest) apicontract.Response[apicontract.TreeStatData] {
- ret := gulu.Ret.NewResult()
id, includeEmbed := strings.TrimSpace(request.ID), request.IncludeEmbed
if id == "" {
return apicontract.Failure[apicontract.TreeStatData](-1, "Field [id] must not be empty")
}
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.TreeStatData](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.TreeStatData](err)
}
boxID, err := holdContractBlockRequest(c, request.Notebook, request.ID, request.IDs, false)
if err != nil {
@@ -485,10 +470,9 @@ var getDOMText = contractHandler(apicontract.GetDOMText, func(c *gin.Context, re
})
var getRefText = contractHandler(apicontract.GetRefText, func(c *gin.Context, request apicontract.BlockQueryRequest) apicontract.Response[string] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[string](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[string](err)
}
boxID, err := holdContractBlockRequest(c, request.Notebook, request.ID, request.IDs, false)
@@ -574,7 +558,6 @@ var getBlockDefIDsByRefText = contractHandler(apicontract.GetBlockDefIDsByRefTex
})
var getBlockBreadcrumb = contractHandler(apicontract.GetBlockBreadcrumb, func(c *gin.Context, request apicontract.BlockBreadcrumbRequest) apicontract.Response[[]*apicontract.BlockPath] {
- ret := gulu.Ret.NewResult()
id, excludeTypes := request.ID, request.ExcludeTypes
boxID := request.Notebook
if err := holdEncryptedBlockRequests(c, boxID, append([]string{request.ID}, request.IDs...), false); err != nil {
@@ -592,19 +575,16 @@ var getBlockBreadcrumb = contractHandler(apicontract.GetBlockBreadcrumb, func(c
blockPath, err = model.BuildBlockBreadcrumb(id, excludeTypes)
}
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockPath](ret)
+ return apicontract.Failure[[]*apicontract.BlockPath](-1, err.Error())
}
return apicontract.Success(blockPathContracts(blockPath))
})
var getBlockBreadcrumbChildren = contractHandler(apicontract.GetBlockBreadcrumbChildren, func(c *gin.Context, request apicontract.BlockBreadcrumbChildrenRequest) apicontract.Response[*apicontract.BlockBreadcrumbChildren] {
- ret := gulu.Ret.NewResult()
id, excludeTypes := request.ID, request.ExcludeTypes
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[*apicontract.BlockBreadcrumbChildren](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[*apicontract.BlockBreadcrumbChildren](err)
}
offset, limit := 0, 64
if request.Offset != nil {
@@ -623,9 +603,7 @@ var getBlockBreadcrumbChildren = contractHandler(apicontract.GetBlockBreadcrumbC
children, err := model.GetBlockBreadcrumbChildrenInBox(id, excludeTypes, offset, limit, boxID)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[*apicontract.BlockBreadcrumbChildren](ret)
+ return apicontract.Failure[*apicontract.BlockBreadcrumbChildren](-1, err.Error())
}
if children == nil {
return apicontract.Success[*apicontract.BlockBreadcrumbChildren](nil)
@@ -654,9 +632,11 @@ var getBlocksIndexes = contractHandler(apicontract.GetBlocksIndexes, func(c *gin
})
var getDocBlocksOrders = contractHandler(apicontract.GetDocBlocksOrders, func(c *gin.Context, request apicontract.DocOrdersRequest) apicontract.Response[[]string] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.ID, ret) || !checkBlockPublishAccess(c, request.ID, ret) {
- return contractFailure[[]string](ret)
+ if err := util.ValidateID(request.ID); err != nil {
+ return apicontract.FailureFrom[[]string](err)
+ }
+ if err := checkBlockPublishAccess(c, request.ID); err != nil {
+ return apicontract.FailureFrom[[]string](err)
}
orders, err := model.GetDocBlocksOrders(request.ID)
if err != nil {
@@ -666,11 +646,9 @@ var getDocBlocksOrders = contractHandler(apicontract.GetDocBlocksOrders, func(c
})
var getBlockInfo = contractHandler(apicontract.GetBlockInfo, func(c *gin.Context, request apicontract.BlockInfoRequest) apicontract.Response[apicontract.BlockInfoData] {
- ret := gulu.Ret.NewResult()
-
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.BlockInfoData](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.BlockInfoData](err)
}
boxID := ""
if request.Notebook != "" && model.IsEncryptedBox(request.Notebook) {
@@ -678,20 +656,17 @@ var getBlockInfo = contractHandler(apicontract.GetBlockInfo, func(c *gin.Context
}
// 普通文档的索引可能尚未就绪,先恢复索引,再按实际归属取得响应租约。
if boxID == "" && !model.IsReadOnlyRoleContext(c) && treenode.GetBlockTree(id) == nil {
- if err := model.ReindexMissingNormalBlock(id); setGetBlockInfoError(ret, id, err) {
- return contractFailure[apicontract.BlockInfoData](ret)
+ if err := model.ReindexMissingNormalBlock(id); err != nil {
+ return apicontract.FailureFrom[apicontract.BlockInfoData](blockInfoLoadError(id, err))
}
}
ids := append([]string{id}, request.IDs...)
if err := holdEncryptedBlockRequests(c, boxID, ids, false); err != nil {
- ret.Code, ret.Msg = -1, err.Error()
- return contractFailure[apicontract.BlockInfoData](ret)
+ return apicontract.Failure[apicontract.BlockInfoData](-1, err.Error())
}
blockTree, publishAccessRequired, publishMetadataVisible, publishAccessible := getBlockInfoPublishAccess(c, id, boxID)
if !publishAccessible {
- ret.Code = -1
- ret.Msg = fmt.Sprintf(model.Conf.Language(15), id)
- return contractFailure[apicontract.BlockInfoData](ret)
+ return apicontract.Failure[apicontract.BlockInfoData](-1, fmt.Sprintf(model.Conf.Language(15), id))
}
if publishAccessRequired && !publishMetadataVisible {
return apicontract.Success[apicontract.BlockInfoData](apicontract.PublishedBlockInfo{
@@ -708,20 +683,18 @@ var getBlockInfo = contractHandler(apicontract.GetBlockInfo, func(c *gin.Context
} else {
tree, err = model.LoadTreeByBlockIDWithReindex(id)
}
- if setGetBlockInfoError(ret, id, err) {
- return contractFailure[apicontract.BlockInfoData](ret)
+ if err := blockInfoLoadError(id, err); err != nil {
+ return apicontract.FailureFrom[apicontract.BlockInfoData](err)
}
block, _ := model.GetBlock(id, tree)
if nil == block {
- ret.Code = -1
- ret.Msg = fmt.Sprintf(model.Conf.Language(15), id)
- return contractFailure[apicontract.BlockInfoData](ret)
+ return apicontract.Failure[apicontract.BlockInfoData](-1, fmt.Sprintf(model.Conf.Language(15), id))
}
root, err := model.GetBlock(block.RootID, tree)
if errors.Is(err, model.ErrIndexing) {
- return apicontract.FailureWithText[apicontract.BlockInfoData](3, ret.Msg, model.Conf.Language(56))
+ return apicontract.FailureWithText[apicontract.BlockInfoData](3, "", model.Conf.Language(56))
}
rootTitle := treenode.ReadDocumentTitle(tree.Root).Text
icon := html.UnescapeString(root.IAL["icon"])
@@ -756,25 +729,25 @@ var getBlockInfo = contractHandler(apicontract.GetBlockInfo, func(c *gin.Context
})
})
-func setGetBlockInfoError(ret *gulu.Result, id string, err error) bool {
+// blockInfoLoadError 把加载块时的错误转为响应错误,返回 nil 表示没有错误。
+// 索引未就绪使用错误码 3,其余沿用 -1。
+func blockInfoLoadError(id string, err error) error {
if err == nil {
- return false
+ return nil
}
- ret.Code = -1
switch {
case errors.Is(err, model.ErrIndexing):
- ret.Code = 3
- ret.Msg = model.Conf.Language(56)
+ return apicontract.RejectWith(3, model.Conf.Language(56))
case errors.Is(err, treenode.ErrSpecTooNew):
- ret.Msg = model.Conf.Language(275)
+ return apicontract.Reject(model.Conf.Language(275))
case errors.Is(err, model.ErrBoxUnindexed):
- ret.Msg = "" // 加载时已经推送提示。
+ // 加载时已经推送过提示。
+ return apicontract.Reject("")
case errors.Is(err, model.ErrTreeNotFound):
- ret.Msg = fmt.Sprintf(model.Conf.Language(15), id)
+ return apicontract.Reject(fmt.Sprintf(model.Conf.Language(15), id))
default:
- ret.Msg = err.Error()
+ return apicontract.Reject(err.Error())
}
- return true
}
func getBlockInfoPublishAccess(c *gin.Context, id, boxID string) (blockTree *treenode.BlockTree, passwordRequired, metadataVisible, accessible bool) {
@@ -796,18 +769,17 @@ func getBlockInfoPublishAccess(c *gin.Context, id, boxID string) (blockTree *tre
return blockTree, false, false, false
}
-func checkBlockPublishAccess(c *gin.Context, id string, ret *gulu.Result) bool {
- return checkBlockPublishAccessInBox(c, id, "", ret)
+// checkBlockPublishAccess 检查发布访问权限,返回 nil 表示允许读取。
+func checkBlockPublishAccess(c *gin.Context, id string) error {
+ return checkBlockPublishAccessInBox(c, id, "")
}
-func checkBlockPublishAccessInBox(c *gin.Context, id, boxID string, ret *gulu.Result) bool {
+// checkBlockPublishAccessInBox 同上,并显式指定所属笔记本。
+func checkBlockPublishAccessInBox(c *gin.Context, id, boxID string) error {
if isBlockPublishAccessible(c, id, boxID) {
- return true
+ return nil
}
-
- ret.Code = -1
- ret.Msg = fmt.Sprintf(model.Conf.Language(15), id)
- return false
+ return apicontract.Reject(fmt.Sprintf(model.Conf.Language(15), id))
}
func isBlockPublishAccessible(c *gin.Context, id, boxID string) bool {
@@ -863,13 +835,12 @@ var getBlockDOM = contractHandler(apicontract.GetBlockDOM, func(c *gin.Context,
})
var getOrderedListContinueStart = contractHandler(apicontract.GetOrderedListContinueStart, func(c *gin.Context, request apicontract.BlockQueryRequest) apicontract.Response[apicontract.OrderedListStartData] {
- ret := gulu.Ret.NewResult()
id := strings.TrimSpace(request.ID)
if id == "" {
return apicontract.Failure[apicontract.OrderedListStartData](-1, "Field [id] must not be empty")
}
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.OrderedListStartData](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.OrderedListStartData](err)
}
boxID, err := holdContractBlockRequest(c, request.Notebook, request.ID, request.IDs, false)
if err != nil {
@@ -990,10 +961,9 @@ func filterBlockDOMsByPublishAccess(c *gin.Context, doms map[string]string, ids
}
var getBlockKramdown = contractHandler(apicontract.GetBlockKramdown, func(c *gin.Context, request apicontract.BlockKramdownRequest) apicontract.Response[apicontract.BlockKramdownData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.BlockKramdownData](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.BlockKramdownData](err)
}
// md:Markdown 标记符模式,使用标记符导出
@@ -1003,9 +973,7 @@ var getBlockKramdown = contractHandler(apicontract.GetBlockKramdown, func(c *gin
if request.Mode != nil {
mode = *request.Mode
if "md" != mode && "textmark" != mode {
- ret.Code = -1
- ret.Msg = "Invalid mode"
- return contractFailure[apicontract.BlockKramdownData](ret)
+ return apicontract.Failure[apicontract.BlockKramdownData](-1, "Invalid mode")
}
}
@@ -1042,10 +1010,9 @@ var getBlockKramdown = contractHandler(apicontract.GetBlockKramdown, func(c *gin
})
var getBlockKramdowns = contractHandler(apicontract.GetBlockKramdowns, func(c *gin.Context, request apicontract.BlocksKramdownRequest) apicontract.Response[map[string]string] {
- ret := gulu.Ret.NewResult()
var ids []string
for _, id := range request.IDs {
- if !util.InvalidIDPattern(id, nil) {
+ if err := util.ValidateID(id); err == nil {
ids = append(ids, id)
}
}
@@ -1057,9 +1024,7 @@ var getBlockKramdowns = contractHandler(apicontract.GetBlockKramdowns, func(c *g
if request.Mode != nil {
mode = *request.Mode
if "md" != mode && "textmark" != mode {
- ret.Code = -1
- ret.Msg = "Invalid mode"
- return contractFailure[map[string]string](ret)
+ return apicontract.Failure[map[string]string](-1, "Invalid mode")
}
}
@@ -1105,10 +1070,9 @@ func filterBlockKramdownsByPublishAccess(c *gin.Context, kramdowns map[string]st
}
var getChildBlocks = contractHandler(apicontract.GetChildBlocks, func(c *gin.Context, request apicontract.BlockQueryRequest) apicontract.Response[[]*apicontract.ChildBlock] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[[]*apicontract.ChildBlock](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.ChildBlock](err)
}
boxID, err := holdContractBlockRequest(c, request.Notebook, request.ID, request.IDs, false)
@@ -1119,10 +1083,9 @@ var getChildBlocks = contractHandler(apicontract.GetChildBlocks, func(c *gin.Con
})
var getTailChildBlocks = contractHandler(apicontract.GetTailChildBlocks, func(c *gin.Context, request apicontract.TailChildBlocksRequest) apicontract.Response[[]*apicontract.ChildBlock] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[[]*apicontract.ChildBlock](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.ChildBlock](err)
}
var n int
diff --git a/kernel/api/block_op.go b/kernel/api/block_op.go
index 03ec55e9fa..5193cfbfdb 100644
--- a/kernel/api/block_op.go
+++ b/kernel/api/block_op.go
@@ -78,19 +78,16 @@ func buildUpdatedTaskListItemBlockDOM(id, marker string, luteEngine *lute.Lute)
}
var updateTaskListItemMarker = contractHandler(apicontract.UpdateTaskListItemMarker, func(c *gin.Context, request apicontract.TaskListMarkerRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
id, marker := request.ID, request.Marker
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
luteEngine := util.NewLute()
data, err := buildUpdatedTaskListItemBlockDOM(id, marker, luteEngine)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, err.Error())
}
transactions := []*model.Transaction{
@@ -110,7 +107,6 @@ var updateTaskListItemMarker = contractHandler(apicontract.UpdateTaskListItemMar
})
var batchUpdateTaskListItemMarker = contractHandler(apicontract.BatchUpdateTaskListItemMarker, func(c *gin.Context, request apicontract.BatchTaskListMarkerRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
itemsArg := request.Items
if len(itemsArg) == 0 {
@@ -121,8 +117,8 @@ var batchUpdateTaskListItemMarker = contractHandler(apicontract.BatchUpdateTaskL
idsInOrder := make([]string, 0, len(itemsArg))
for _, itemArg := range itemsArg {
id, marker := itemArg.ID, itemArg.Marker
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
// 相同 id 保留最后一个 marker
idToMarker[id] = marker
@@ -134,9 +130,7 @@ var batchUpdateTaskListItemMarker = contractHandler(apicontract.BatchUpdateTaskL
for _, id := range ids {
data, err := buildUpdatedTaskListItemBlockDOM(id, idToMarker[id], luteEngine)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, err.Error())
}
ops = append(ops, &model.Operation{Action: "update", ID: id, Data: data})
@@ -154,24 +148,22 @@ var batchUpdateTaskListItemMarker = contractHandler(apicontract.BatchUpdateTaskL
})
var moveOutlineHeading = contractHandler(apicontract.MoveOutlineHeading, func(c *gin.Context, request apicontract.MoveBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
-
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
var parentID, previousID string
if request.ParentID != nil {
parentID = *request.ParentID
- if "" != parentID && util.InvalidIDPattern(parentID, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateOptionalID(parentID); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
}
if request.PreviousID != nil {
previousID = *request.PreviousID
- if "" != previousID && util.InvalidIDPattern(previousID, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateOptionalID(previousID); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
}
@@ -197,28 +189,23 @@ var moveOutlineHeading = contractHandler(apicontract.MoveOutlineHeading, func(c
})
var appendDailyNoteBlock = contractHandler(apicontract.AppendDailyNoteBlock, func(c *gin.Context, request apicontract.DailyNoteBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
data, dataType, boxID := request.Data, request.DataType, request.Notebook
- if util.InvalidIDPattern(boxID, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(boxID); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
if "markdown" == dataType {
luteEngine := util.NewLute()
var err error
data, err = dataBlockDOM(data, luteEngine)
if err != nil {
- ret.Code = -1
- ret.Msg = "data block DOM failed: " + err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "data block DOM failed: "+err.Error())
}
}
p, _, err := model.CreateDailyNote(boxID)
if err != nil {
- ret.Code = -1
- ret.Msg = "create daily note failed: " + err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "create daily note failed: "+err.Error())
}
parentID := util.GetTreeID(p)
@@ -243,28 +230,23 @@ var appendDailyNoteBlock = contractHandler(apicontract.AppendDailyNoteBlock, fun
})
var prependDailyNoteBlock = contractHandler(apicontract.PrependDailyNoteBlock, func(c *gin.Context, request apicontract.DailyNoteBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
data, dataType, boxID := request.Data, request.DataType, request.Notebook
- if util.InvalidIDPattern(boxID, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(boxID); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
if "markdown" == dataType {
luteEngine := util.NewLute()
var err error
data, err = dataBlockDOM(data, luteEngine)
if err != nil {
- ret.Code = -1
- ret.Msg = "data block DOM failed: " + err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "data block DOM failed: "+err.Error())
}
}
p, _, err := model.CreateDailyNote(boxID)
if err != nil {
- ret.Code = -1
- ret.Msg = "create daily note failed: " + err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "create daily note failed: "+err.Error())
}
parentID := util.GetTreeID(p)
@@ -289,24 +271,19 @@ var prependDailyNoteBlock = contractHandler(apicontract.PrependDailyNoteBlock, f
})
var unfoldBlock = contractHandler(apicontract.UnfoldBlock, func(c *gin.Context, request apicontract.BlockIDRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
bt := treenode.GetBlockTree(id)
if nil == bt {
- ret.Code = -1
- ret.Msg = "block tree not found [id=" + id + "]"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "block tree not found [id="+id+"]")
}
if bt.Type == "d" {
- ret.Code = -1
- ret.Msg = "document can not be unfolded"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "document can not be unfolded")
}
var transactions []*model.Transaction
@@ -345,24 +322,19 @@ var unfoldBlock = contractHandler(apicontract.UnfoldBlock, func(c *gin.Context,
})
var foldBlock = contractHandler(apicontract.FoldBlock, func(c *gin.Context, request apicontract.BlockIDRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
bt := treenode.GetBlockTree(id)
if nil == bt {
- ret.Code = -1
- ret.Msg = "block tree not found [id=" + id + "]"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "block tree not found [id="+id+"]")
}
if bt.Type == "d" {
- ret.Code = -1
- ret.Msg = "document can not be folded"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "document can not be folded")
}
var transactions []*model.Transaction
@@ -401,43 +373,36 @@ var foldBlock = contractHandler(apicontract.FoldBlock, func(c *gin.Context, requ
})
var moveBlock = contractHandler(apicontract.MoveBlock, func(c *gin.Context, request apicontract.MoveBlockRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
currentBt := treenode.GetBlockTree(id)
if nil == currentBt {
- ret.Code = -1
- ret.Msg = "block not found [id=" + id + "]"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "block not found [id="+id+"]")
}
var parentID, previousID string
if request.ParentID != nil {
parentID = *request.ParentID
- if "" != parentID && util.InvalidIDPattern(parentID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateOptionalID(parentID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
}
if request.PreviousID != nil {
previousID = *request.PreviousID
- if "" != previousID && util.InvalidIDPattern(previousID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateOptionalID(previousID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
// Check the validity of the API `moveBlock` parameter `previousID` https://github.com/siyuan-note/siyuan/issues/8007
// 文档与不存在的块需要分别提示:文档 ID 格式合法但不是同级锚点,块不存在则是调用方传了失效 ID。
if bt := treenode.GetBlockTree(previousID); nil == bt {
- ret.Code = -1
- ret.Msg = "`previousID` block not found"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "`previousID` block not found")
} else if "d" == bt.Type {
- ret.Code = -1
- ret.Msg = "`previousID` can not be the ID of a document"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "`previousID` can not be the ID of a document")
}
}
@@ -449,22 +414,16 @@ var moveBlock = contractHandler(apicontract.MoveBlock, func(c *gin.Context, requ
}
if nil == targetBt {
- ret.Code = -1
- ret.Msg = "target block not found [id=" + parentID + "]"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "target block not found [id="+parentID+"]")
}
// 仅靠 parentID 定位目标时(无 previousID),目标必须是容器块,否则非法嵌套
if "" == previousID && "" != parentID {
if err := treenode.CheckListItemNesting(parentID, id); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if err := treenode.CheckContainerParent(parentID); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
}
@@ -482,9 +441,7 @@ var moveBlock = contractHandler(apicontract.MoveBlock, func(c *gin.Context, requ
}
if err := model.PerformTransactionSync(transactions[0]); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
model.ReloadProtyle(currentBt.RootID)
@@ -495,25 +452,20 @@ var moveBlock = contractHandler(apicontract.MoveBlock, func(c *gin.Context, requ
})
var appendBlock = contractHandler(apicontract.AppendBlock, func(c *gin.Context, request apicontract.AppendBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
data, dataType, parentID := request.Data, request.DataType, request.ParentID
if dataType != "markdown" && dataType != "dom" {
- ret.Code = -1
- ret.Msg = "dataType must be markdown or dom"
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "dataType must be markdown or dom")
}
- if util.InvalidIDPattern(parentID, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(parentID); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
if "markdown" == dataType {
luteEngine := util.NewLute()
var err error
data, err = dataBlockDOM(data, luteEngine)
if err != nil {
- ret.Code = -1
- ret.Msg = "data block DOM failed: " + err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "data block DOM failed: "+err.Error())
}
}
@@ -523,9 +475,7 @@ var appendBlock = contractHandler(apicontract.AppendBlock, func(c *gin.Context,
ParentID: parentID,
})
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, err.Error())
}
broadcastTransactions(transactions)
@@ -533,7 +483,6 @@ var appendBlock = contractHandler(apicontract.AppendBlock, func(c *gin.Context,
})
var batchAppendBlock = contractHandler(apicontract.BatchAppendBlock, func(c *gin.Context, request apicontract.BatchParentBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
blocksArg := request.Blocks
var transactions []*model.Transaction
@@ -542,22 +491,18 @@ var batchAppendBlock = contractHandler(apicontract.BatchAppendBlock, func(c *gin
data := blockArg.Data
dataType := blockArg.DataType
parentID := blockArg.ParentID
- if util.InvalidIDPattern(parentID, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(parentID); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
// append 只用 parentID 定位目标,目标必须是容器块,否则非法嵌套
if err := treenode.CheckContainerParent(parentID); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, err.Error())
}
if "markdown" == dataType {
var err error
data, err = dataBlockDOM(data, luteEngine)
if err != nil {
- ret.Code = -1
- ret.Msg = "data block DOM failed: " + err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "data block DOM failed: "+err.Error())
}
}
@@ -581,26 +526,21 @@ var batchAppendBlock = contractHandler(apicontract.BatchAppendBlock, func(c *gin
})
var prependBlock = contractHandler(apicontract.PrependBlock, func(c *gin.Context, request apicontract.PrependBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
data, dataType, parentID := request.Data, request.DataType, request.ParentID
- if util.InvalidIDPattern(parentID, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(parentID); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
// prepend 只用 parentID 定位目标,目标必须是容器块,否则非法嵌套
if err := treenode.CheckContainerParent(parentID); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, err.Error())
}
if "markdown" == dataType {
luteEngine := util.NewLute()
var err error
data, err = dataBlockDOM(data, luteEngine)
if err != nil {
- ret.Code = -1
- ret.Msg = "data block DOM failed: " + err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "data block DOM failed: "+err.Error())
}
}
@@ -625,7 +565,6 @@ var prependBlock = contractHandler(apicontract.PrependBlock, func(c *gin.Context
})
var batchPrependBlock = contractHandler(apicontract.BatchPrependBlock, func(c *gin.Context, request apicontract.BatchParentBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
blocksArg := request.Blocks
var transactions []*model.Transaction
@@ -634,22 +573,18 @@ var batchPrependBlock = contractHandler(apicontract.BatchPrependBlock, func(c *g
data := blockArg.Data
dataType := blockArg.DataType
parentID := blockArg.ParentID
- if util.InvalidIDPattern(parentID, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(parentID); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
// prepend 只用 parentID 定位目标,目标必须是容器块,否则非法嵌套
if err := treenode.CheckContainerParent(parentID); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, err.Error())
}
if "markdown" == dataType {
var err error
data, err = dataBlockDOM(data, luteEngine)
if err != nil {
- ret.Code = -1
- ret.Msg = "data block DOM failed: " + err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "data block DOM failed: "+err.Error())
}
}
@@ -673,22 +608,17 @@ var batchPrependBlock = contractHandler(apicontract.BatchPrependBlock, func(c *g
})
var insertBlock = contractHandler(apicontract.InsertBlock, func(c *gin.Context, request apicontract.InsertBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
data, dataType, parentID, previousID, nextID := request.Data, request.DataType, request.ParentID, request.PreviousID, request.NextID
if dataType != "markdown" && dataType != "dom" {
- ret.Code = -1
- ret.Msg = "dataType must be markdown or dom"
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "dataType must be markdown or dom")
}
if parentID == "" && previousID == "" && nextID == "" {
- ret.Code = -1
- ret.Msg = "at least one of parentID, previousID or nextID is required"
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "at least one of parentID, previousID or nextID is required")
}
for _, id := range []string{parentID, previousID, nextID} {
- if id != "" && util.InvalidIDPattern(id, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateOptionalID(id); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
}
if "markdown" == dataType {
@@ -696,9 +626,7 @@ var insertBlock = contractHandler(apicontract.InsertBlock, func(c *gin.Context,
var err error
data, err = dataBlockDOM(data, luteEngine)
if err != nil {
- ret.Code = -1
- ret.Msg = "data block DOM failed: " + err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "data block DOM failed: "+err.Error())
}
}
@@ -710,9 +638,7 @@ var insertBlock = contractHandler(apicontract.InsertBlock, func(c *gin.Context,
NextID: nextID,
})
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, err.Error())
}
broadcastTransactions(transactions)
@@ -720,17 +646,14 @@ var insertBlock = contractHandler(apicontract.InsertBlock, func(c *gin.Context,
})
var updateBlock = contractHandler(apicontract.UpdateBlock, func(c *gin.Context, request apicontract.UpdateBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
input := blockUpdateInput(request)
- if util.InvalidIDPattern(input.ID, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(input.ID); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
transactions, _, err := model.PerformBlockUpdates([]model.BlockUpdateInput{input})
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, err.Error())
}
broadcastTransactions(transactions)
@@ -738,7 +661,6 @@ var updateBlock = contractHandler(apicontract.UpdateBlock, func(c *gin.Context,
})
var batchInsertBlock = contractHandler(apicontract.BatchInsertBlock, func(c *gin.Context, request apicontract.BatchInsertBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
blocksArg := request.Blocks
var transactions []*model.Transaction
@@ -747,16 +669,14 @@ var batchInsertBlock = contractHandler(apicontract.BatchInsertBlock, func(c *gin
data, dataType := blockArg.Data, blockArg.DataType
parentID, previousID, nextID := blockArg.ParentID, blockArg.PreviousID, blockArg.NextID
for _, id := range []string{parentID, previousID, nextID} {
- if id != "" && util.InvalidIDPattern(id, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateOptionalID(id); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
}
// 仅靠 parentID 定位目标时(无 previousID/nextID),目标必须是容器块,否则非法嵌套
if "" != parentID && "" == previousID && "" == nextID {
if err := treenode.CheckContainerParent(parentID); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, err.Error())
}
}
@@ -764,9 +684,7 @@ var batchInsertBlock = contractHandler(apicontract.BatchInsertBlock, func(c *gin
var err error
data, err = dataBlockDOM(data, luteEngine)
if err != nil {
- ret.Code = -1
- ret.Msg = "data block DOM failed: " + err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "data block DOM failed: "+err.Error())
}
}
@@ -792,7 +710,6 @@ var batchInsertBlock = contractHandler(apicontract.BatchInsertBlock, func(c *gin
})
var batchUpdateBlock = contractHandler(apicontract.BatchUpdateBlock, func(c *gin.Context, request apicontract.BatchUpdateBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
if len(request.Blocks) == 0 {
return apicontract.Failure[[]*apicontract.BlockTransaction](-1, "Field [blocks] must not be empty")
@@ -800,17 +717,15 @@ var batchUpdateBlock = contractHandler(apicontract.BatchUpdateBlock, func(c *gin
inputs := make([]model.BlockUpdateInput, 0, len(request.Blocks))
for i, block := range request.Blocks {
input := blockUpdateInput(block)
- if util.InvalidIDPattern(input.ID, ret) {
- ret.Msg = fmt.Sprintf("blocks[%d]: %s", i, ret.Msg)
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(input.ID); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](
+ apicontract.Reject(fmt.Sprintf("blocks[%d]: %s", i, err.Error())))
}
inputs = append(inputs, input)
}
transactions, _, err := model.PerformBlockUpdates(inputs)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, err.Error())
}
broadcastTransactions(transactions)
@@ -818,11 +733,10 @@ var batchUpdateBlock = contractHandler(apicontract.BatchUpdateBlock, func(c *gin
})
var deleteBlock = contractHandler(apicontract.DeleteBlock, func(c *gin.Context, request apicontract.DeleteBlockRequest) apicontract.Response[[]*apicontract.BlockTransaction] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.BlockTransaction](err)
}
transactions, err := model.PerformBlockOperation(&model.Operation{
@@ -830,9 +744,7 @@ var deleteBlock = contractHandler(apicontract.DeleteBlock, func(c *gin.Context,
ID: id,
})
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.BlockTransaction](ret)
+ return apicontract.Failure[[]*apicontract.BlockTransaction](-1, err.Error())
}
broadcastTransactions(transactions)
diff --git a/kernel/api/contract.go b/kernel/api/contract.go
index 04207bbfce..9fe69379a0 100644
--- a/kernel/api/contract.go
+++ b/kernel/api/contract.go
@@ -3,11 +3,9 @@ package api
import (
"bytes"
"encoding/base64"
- "fmt"
"io"
"mime/multipart"
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
goccyJSON "github.com/goccy/go-json"
"github.com/siyuan-note/siyuan/kernel/apicontract"
@@ -178,18 +176,6 @@ func mergeSettingBody(namespace string, body []byte) []byte {
return body
}
-// contractFailure 保留既有业务校验的错误码和消息,并限制其错误载荷形态。
-func contractFailure[Data any](result *gulu.Result) apicontract.Response[Data] {
- switch data := result.Data.(type) {
- case nil:
- return apicontract.Failure[Data](result.Code, result.Msg)
- case string:
- return apicontract.FailureWithText[Data](result.Code, result.Msg, data)
- default:
- panic(fmt.Sprintf("unsupported API error data %T", result.Data))
- }
-}
-
func notebookContract(box *model.Box) *apicontract.Notebook {
if box == nil {
return nil
diff --git a/kernel/api/contract_account_test.go b/kernel/api/contract_account_test.go
index e210cfaeae..ed57962bb2 100644
--- a/kernel/api/contract_account_test.go
+++ b/kernel/api/contract_account_test.go
@@ -2,37 +2,51 @@ package api
import (
"encoding/json"
- "github.com/88250/gulu"
- "github.com/gin-gonic/gin"
- "github.com/siyuan-note/siyuan/kernel/apicontract"
"net/http/httptest"
"reflect"
"strings"
"testing"
+
+ "github.com/gin-gonic/gin"
+ "github.com/siyuan-note/siyuan/kernel/apicontract"
)
func TestAPIContractAccountLoginResponses(t *testing.T) {
- for _, result := range []*gulu.Result{
- {Code: -1, Msg: "offline"},
- {Code: 1, Msg: "captcha", Data: map[string]any{"userName": nil, "token": nil, "needCaptcha": "user-id"}},
- {Code: 10, Data: map[string]any{"userName": nil, "token": "second-factor", "needCaptcha": nil}},
- {Code: 0, Data: map[string]any{"userName": "user", "token": "token", "needCaptcha": nil}},
+ str := func(value string) *string { return &value }
+ for _, test := range []struct {
+ name string
+ code int
+ msg string
+ data *apicontract.AccountLoginData
+ want string
+ }{
+ // 云端失败时由模型层给出本地提示,载荷为 null。
+ {name: "offline", code: -1, msg: "offline", want: `{"code":-1,"msg":"offline","data":null}`},
+ // 需要验证码时仍然返回 needCaptcha(值为 user id)。
+ {name: "captcha", code: 1, msg: "captcha", data: &apicontract.AccountLoginData{NeedCaptcha: str("user-id")},
+ want: `{"code":1,"msg":"captcha","data":{"userName":null,"token":null,"needCaptcha":"user-id"}}`},
+ // 云端返回的其他码原样透传。
+ {name: "second factor", code: 10, data: &apicontract.AccountLoginData{Token: str("second-factor")},
+ want: `{"code":10,"msg":"","data":{"userName":null,"token":"second-factor","needCaptcha":null}}`},
+ {name: "success", code: 0, data: &apicontract.AccountLoginData{UserName: str("user"), Token: str("token")},
+ want: `{"code":0,"msg":"","data":{"userName":"user","token":"token","needCaptcha":null}}`},
} {
- recorder := httptest.NewRecorder()
- context, _ := gin.CreateTestContext(recorder)
- context.JSON(200, accountLoginResponse(result))
- requireAPIContract(t, "POST", "/api/account/login", recorder)
- original, _ := json.Marshal(result)
- var before, after map[string]any
- if err := json.Unmarshal(original, &before); err != nil {
- t.Fatal(err)
- }
- if err := json.Unmarshal(recorder.Body.Bytes(), &after); err != nil {
- t.Fatal(err)
- }
- if !reflect.DeepEqual(before, after) {
- t.Fatalf("login response changed: %s != %s", original, recorder.Body.String())
- }
+ t.Run(test.name, func(t *testing.T) {
+ recorder := httptest.NewRecorder()
+ context, _ := gin.CreateTestContext(recorder)
+ context.JSON(200, apicontract.AccountLogin.FailureWithData(test.code, test.msg, test.data))
+ requireAPIContract(t, "POST", "/api/account/login", recorder)
+ var got, want map[string]any
+ if err := json.Unmarshal(recorder.Body.Bytes(), &got); err != nil {
+ t.Fatalf("%s: %s", recorder.Body.String(), err)
+ }
+ if err := json.Unmarshal([]byte(test.want), &want); err != nil {
+ t.Fatal(err)
+ }
+ if !reflect.DeepEqual(want, got) {
+ t.Fatalf("login response changed: %s != %s", recorder.Body.String(), test.want)
+ }
+ })
}
}
diff --git a/kernel/api/contract_bazaar_test.go b/kernel/api/contract_bazaar_test.go
index f73dacc914..3c7c6a48c1 100644
--- a/kernel/api/contract_bazaar_test.go
+++ b/kernel/api/contract_bazaar_test.go
@@ -9,8 +9,6 @@ import (
"github.com/siyuan-note/siyuan/kernel/apicontract"
"github.com/siyuan-note/siyuan/kernel/bazaar"
"github.com/siyuan-note/siyuan/kernel/conf"
- "github.com/siyuan-note/siyuan/kernel/util"
- "maps"
"mime/multipart"
"net/http"
"net/http/httptest"
@@ -24,1653 +22,723 @@ func TestBazaarContractInputCompatibility(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var frontend string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("frontend", &frontend, true, true)) {
+ if !legacyParseArgs(arg, ret, legacyBind("frontend", &frontend, true, true)) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"frontend":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"frontend":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/batchUpdatePackage", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/batchUpdatePackage", `{"frontend":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.BatchUpdatePackage.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getUpdatedPackage", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var frontend string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("frontend", &frontend, true, true)) {
+ if !legacyParseArgs(arg, ret, legacyBind("frontend", &frontend, true, true)) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"frontend":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"frontend":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getUpdatedPackage", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getUpdatedPackage", `{"frontend":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetUpdatedPackage.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("updateBazaarPackage", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var pkgType, packageName, frontend, keyword string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("packageType", &pkgType, true, true),
- util.BindJsonArg("packageName", &packageName, true, true),
- util.BindJsonArg("frontend", &frontend, true, true),
- util.BindJsonArg("keyword", &keyword, false, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("packageType", &pkgType, true, true),
+ legacyBind("packageName", &packageName, true, true),
+ legacyBind("frontend", &frontend, true, true),
+ legacyBind("keyword", &keyword, false, false),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"packageType":"plugins","packageName":" valid ","frontend":" valid ","keyword":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"packageType":"plugins","packageName":" valid ","frontend":" valid ","keyword":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/updateBazaarPackage", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/updateBazaarPackage", `{"packageType":"plugins","packageName":" valid ","frontend":" valid ","keyword":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.UpdateBazaarPackage.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getInstalledPackageSize", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var pkgType, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("packageType", &pkgType, true, true),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("packageType", &pkgType, true, true),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"packageType":"plugins","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"packageType":"plugins","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getInstalledPackageSize", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getInstalledPackageSize", `{"packageType":"plugins","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetInstalledPackageSize.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getBazaarPackage", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var pkgType, packageName, frontend string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("packageType", &pkgType, true, true),
- util.BindJsonArg("packageName", &packageName, true, true),
- util.BindJsonArg("frontend", &frontend, false, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("packageType", &pkgType, true, true),
+ legacyBind("packageName", &packageName, true, true),
+ legacyBind("frontend", &frontend, false, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"packageType":"plugins","packageName":" valid ","frontend":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"packageType":"plugins","packageName":" valid ","frontend":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getBazaarPackage", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getBazaarPackage", `{"packageType":"plugins","packageName":" valid ","frontend":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetBazaarPackage.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getBazaarPackageRatings", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var pkgType string
var packageNamesArg []any
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("packageType", &pkgType, true, true),
- util.BindJsonArg("packageNames", &packageNamesArg, true, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("packageType", &pkgType, true, true),
+ legacyBind("packageNames", &packageNamesArg, true, false),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"packageType":"plugins","packageNames":[]}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"packageType":"plugins","packageNames":[]}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getBazaarPackageRatings", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getBazaarPackageRatings", `{"packageType":"plugins","packageNames":[]}`, legacy, func(body []byte) error {
_, err := apicontract.GetBazaarPackageRatings.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getBazaarPackageUserRatings", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var pkgType string
var packageNamesArg []any
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("packageType", &pkgType, true, true),
- util.BindJsonArg("packageNames", &packageNamesArg, true, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("packageType", &pkgType, true, true),
+ legacyBind("packageNames", &packageNamesArg, true, false),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"packageType":"plugins","packageNames":[]}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"packageType":"plugins","packageNames":[]}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getBazaarPackageUserRatings", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getBazaarPackageUserRatings", `{"packageType":"plugins","packageNames":[]}`, legacy, func(body []byte) error {
_, err := apicontract.GetBazaarPackageUserRatings.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getBazaarPackageRating", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var pkgType, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("packageType", &pkgType, true, true),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("packageType", &pkgType, true, true),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"packageType":"plugins","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"packageType":"plugins","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getBazaarPackageRating", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getBazaarPackageRating", `{"packageType":"plugins","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetBazaarPackageRating.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("setBazaarPackageRating", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var pkgType, packageName string
var ratingArg float64
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("packageType", &pkgType, true, true),
- util.BindJsonArg("packageName", &packageName, true, true),
- util.BindJsonArg("rating", &ratingArg, true, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("packageType", &pkgType, true, true),
+ legacyBind("packageName", &packageName, true, true),
+ legacyBind("rating", &ratingArg, true, false),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"packageType":"plugins","packageName":" valid ","rating":3}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"packageType":"plugins","packageName":" valid ","rating":3}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/setBazaarPackageRating", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/setBazaarPackageRating", `{"packageType":"plugins","packageName":" valid ","rating":3}`, legacy, func(body []byte) error {
_, err := apicontract.SetBazaarPackageRating.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getBazaarPackageREADME", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var repoURL, repoHash, pkgType string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("repoURL", &repoURL, true, true),
- util.BindJsonArg("repoHash", &repoHash, true, true),
- util.BindJsonArg("packageType", &pkgType, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("repoURL", &repoURL, true, true),
+ legacyBind("repoHash", &repoHash, true, true),
+ legacyBind("packageType", &pkgType, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"repoURL":" valid ","repoHash":" valid ","packageType":"plugins"}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"repoURL":" valid ","repoHash":" valid ","packageType":"plugins"}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getBazaarPackageREADME", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getBazaarPackageREADME", `{"repoURL":" valid ","repoHash":" valid ","packageType":"plugins"}`, legacy, func(body []byte) error {
_, err := apicontract.GetBazaarPackageREADME.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getBazaarPlugin", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var frontend, keyword string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("frontend", &frontend, true, true),
- util.BindJsonArg("keyword", &keyword, false, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("frontend", &frontend, true, true),
+ legacyBind("keyword", &keyword, false, false),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"frontend":" valid ","keyword":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"frontend":" valid ","keyword":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getBazaarPlugin", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getBazaarPlugin", `{"frontend":" valid ","keyword":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetBazaarPlugin.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getInstalledPlugin", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var frontend, keyword string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("frontend", &frontend, true, true),
- util.BindJsonArg("keyword", &keyword, false, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("frontend", &frontend, true, true),
+ legacyBind("keyword", &keyword, false, false),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"frontend":" valid ","keyword":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"frontend":" valid ","keyword":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getInstalledPlugin", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getInstalledPlugin", `{"frontend":" valid ","keyword":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetInstalledPlugin.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("installBazaarPlugin", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var frontend, keyword, repoURL, repoHash, repoRef, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("frontend", &frontend, true, true),
- util.BindJsonArg("keyword", &keyword, false, false),
- util.BindJsonArg("repoURL", &repoURL, true, true),
- util.BindJsonArg("repoHash", &repoHash, true, true),
- util.BindJsonArg("repoRef", &repoRef, false, false),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("frontend", &frontend, true, true),
+ legacyBind("keyword", &keyword, false, false),
+ legacyBind("repoURL", &repoURL, true, true),
+ legacyBind("repoHash", &repoHash, true, true),
+ legacyBind("repoRef", &repoRef, false, false),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"frontend":" valid ","keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"frontend":" valid ","keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/installBazaarPlugin", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/installBazaarPlugin", `{"frontend":" valid ","keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.InstallBazaarPlugin.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("uninstallBazaarPlugin", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var frontend, keyword, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("frontend", &frontend, false, false),
- util.BindJsonArg("keyword", &keyword, false, false),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("frontend", &frontend, false, false),
+ legacyBind("keyword", &keyword, false, false),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"frontend":" valid ","keyword":" valid ","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"frontend":" valid ","keyword":" valid ","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/uninstallBazaarPlugin", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/uninstallBazaarPlugin", `{"frontend":" valid ","keyword":" valid ","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.UninstallBazaarPlugin.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getBazaarWidget", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("keyword", &keyword, false, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("keyword", &keyword, false, false)) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getBazaarWidget", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getBazaarWidget", `{"keyword":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetBazaarWidget.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getInstalledWidget", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("keyword", &keyword, false, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("keyword", &keyword, false, false)) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getInstalledWidget", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getInstalledWidget", `{"keyword":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetInstalledWidget.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("installBazaarWidget", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword, repoURL, repoHash, repoRef, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("keyword", &keyword, false, false),
- util.BindJsonArg("repoURL", &repoURL, true, true),
- util.BindJsonArg("repoHash", &repoHash, true, true),
- util.BindJsonArg("repoRef", &repoRef, false, false),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("keyword", &keyword, false, false),
+ legacyBind("repoURL", &repoURL, true, true),
+ legacyBind("repoHash", &repoHash, true, true),
+ legacyBind("repoRef", &repoRef, false, false),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/installBazaarWidget", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/installBazaarWidget", `{"keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.InstallBazaarWidget.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("uninstallBazaarWidget", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("keyword", &keyword, false, false),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("keyword", &keyword, false, false),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid ","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid ","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/uninstallBazaarWidget", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/uninstallBazaarWidget", `{"keyword":" valid ","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.UninstallBazaarWidget.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getBazaarIcon", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("keyword", &keyword, false, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("keyword", &keyword, false, false)) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getBazaarIcon", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getBazaarIcon", `{"keyword":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetBazaarIcon.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getInstalledIcon", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("keyword", &keyword, false, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("keyword", &keyword, false, false)) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getInstalledIcon", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getInstalledIcon", `{"keyword":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetInstalledIcon.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("installBazaarIcon", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword, repoURL, repoHash, repoRef, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("keyword", &keyword, false, false),
- util.BindJsonArg("repoURL", &repoURL, true, true),
- util.BindJsonArg("repoHash", &repoHash, true, true),
- util.BindJsonArg("repoRef", &repoRef, false, false),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("keyword", &keyword, false, false),
+ legacyBind("repoURL", &repoURL, true, true),
+ legacyBind("repoHash", &repoHash, true, true),
+ legacyBind("repoRef", &repoRef, false, false),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/installBazaarIcon", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/installBazaarIcon", `{"keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.InstallBazaarIcon.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("uninstallBazaarIcon", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("keyword", &keyword, false, false),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("keyword", &keyword, false, false),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid ","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid ","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/uninstallBazaarIcon", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/uninstallBazaarIcon", `{"keyword":" valid ","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.UninstallBazaarIcon.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getBazaarTemplate", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("keyword", &keyword, false, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("keyword", &keyword, false, false)) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getBazaarTemplate", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getBazaarTemplate", `{"keyword":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetBazaarTemplate.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getInstalledTemplate", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("keyword", &keyword, false, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("keyword", &keyword, false, false)) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getInstalledTemplate", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getInstalledTemplate", `{"keyword":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetInstalledTemplate.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("installBazaarTemplate", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword, repoURL, repoHash, repoRef, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("keyword", &keyword, false, false),
- util.BindJsonArg("repoURL", &repoURL, true, true),
- util.BindJsonArg("repoHash", &repoHash, true, true),
- util.BindJsonArg("repoRef", &repoRef, false, false),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("keyword", &keyword, false, false),
+ legacyBind("repoURL", &repoURL, true, true),
+ legacyBind("repoHash", &repoHash, true, true),
+ legacyBind("repoRef", &repoRef, false, false),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/installBazaarTemplate", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/installBazaarTemplate", `{"keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.InstallBazaarTemplate.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("uninstallBazaarTemplate", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("keyword", &keyword, false, false),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("keyword", &keyword, false, false),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"keyword":" valid ","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"keyword":" valid ","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/uninstallBazaarTemplate", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/uninstallBazaarTemplate", `{"keyword":" valid ","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.UninstallBazaarTemplate.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getBazaarTheme", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var frontend, keyword string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("frontend", &frontend, false, false),
- util.BindJsonArg("keyword", &keyword, false, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("frontend", &frontend, false, false),
+ legacyBind("keyword", &keyword, false, false),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"frontend":" valid ","keyword":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"frontend":" valid ","keyword":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getBazaarTheme", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getBazaarTheme", `{"frontend":" valid ","keyword":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetBazaarTheme.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("getInstalledTheme", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var frontend, keyword string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("frontend", &frontend, false, false),
- util.BindJsonArg("keyword", &keyword, false, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("frontend", &frontend, false, false),
+ legacyBind("keyword", &keyword, false, false),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"frontend":" valid ","keyword":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"frontend":" valid ","keyword":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/getInstalledTheme", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/getInstalledTheme", `{"frontend":" valid ","keyword":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.GetInstalledTheme.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("installBazaarTheme", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var frontend, keyword, repoURL, repoHash, repoRef, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("frontend", &frontend, false, false),
- util.BindJsonArg("keyword", &keyword, false, false),
- util.BindJsonArg("repoURL", &repoURL, true, true),
- util.BindJsonArg("repoHash", &repoHash, true, true),
- util.BindJsonArg("repoRef", &repoRef, false, false),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("frontend", &frontend, false, false),
+ legacyBind("keyword", &keyword, false, false),
+ legacyBind("repoURL", &repoURL, true, true),
+ legacyBind("repoHash", &repoHash, true, true),
+ legacyBind("repoRef", &repoRef, false, false),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"frontend":" valid ","keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"frontend":" valid ","keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/installBazaarTheme", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/installBazaarTheme", `{"frontend":" valid ","keyword":" valid ","repoURL":" valid ","repoHash":" valid ","repoRef":" valid ","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.InstallBazaarTheme.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
t.Run("uninstallBazaarTheme", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var frontend, keyword, packageName string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("frontend", &frontend, false, false),
- util.BindJsonArg("keyword", &keyword, false, false),
- util.BindJsonArg("packageName", &packageName, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("frontend", &frontend, false, false),
+ legacyBind("keyword", &keyword, false, false),
+ legacyBind("packageName", &packageName, true, true),
) {
return
}
return
}
- base := map[string]json.RawMessage{}
- if err := json.Unmarshal([]byte(`{"frontend":" valid ","keyword":" valid ","packageName":" valid "}`), &base); err != nil {
- t.Fatal(err)
- }
- bodies := [][]byte{[]byte(`{"frontend":" valid ","keyword":" valid ","packageName":" valid "}`), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/bazaar/uninstallBazaarTheme", bytes.NewReader(body))
- expected := legacy(c)
+ checkLegacyInputCompatibility(t, "/api/bazaar/uninstallBazaarTheme", `{"frontend":" valid ","keyword":" valid ","packageName":" valid "}`, legacy, func(body []byte) error {
_, err := apicontract.UninstallBazaarTheme.Decode(bytes.NewReader(body))
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q, want %q", body, message, expected.Msg)
- }
- }
+ return err
+ })
})
}
diff --git a/kernel/api/contract_format_test.go b/kernel/api/contract_format_test.go
index 5cf0dd6000..769417f399 100644
--- a/kernel/api/contract_format_test.go
+++ b/kernel/api/contract_format_test.go
@@ -8,7 +8,6 @@ import (
"github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/apicontract"
- "github.com/siyuan-note/siyuan/kernel/util"
)
func TestAPIContractFormatInputCompatibility(t *testing.T) {
@@ -17,10 +16,10 @@ func TestAPIContractFormatInputCompatibility(t *testing.T) {
legacy := gulu.Ret.NewResult()
context, _ := gin.CreateTestContext(httptest.NewRecorder())
context.Request = httptest.NewRequest("POST", "/api/format/netImg2LocalAssets", strings.NewReader(body))
- args, ok := util.JsonArg(context, legacy)
+ args, ok := legacyJSONArg(context, legacy)
var id, url string
if ok {
- ok = util.ParseJsonArgs(args, legacy, util.BindJsonArg("id", &id, true, true), util.BindJsonArg("url", &url, false, false))
+ ok = legacyParseArgs(args, legacy, legacyBind("id", &id, true, true), legacyBind("url", &url, false, false))
}
request, err := apicontract.NetImg2LocalAssets.Decode(strings.NewReader(body))
if ok != (err == nil) {
diff --git a/kernel/api/contract_legacy_parse_test.go b/kernel/api/contract_legacy_parse_test.go
new file mode 100644
index 0000000000..7018bb22af
--- /dev/null
+++ b/kernel/api/contract_legacy_parse_test.go
@@ -0,0 +1,178 @@
+// SiYuan - https://github.com/siyuan-note/siyuan
+// Copyright (c) 2020-present, b3log.org
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package api
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "maps"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "github.com/88250/gulu"
+ "github.com/gin-gonic/gin"
+)
+
+// 本文件是契约迁移前的请求解析实现,**冻结**为兼容性测试的参照。
+//
+// 迁移完成时,这些函数从 util 包移出:生产代码已全部改用 apicontract 的类型化解码器,
+// 留在 util 里只是一个只有测试可达的导出 API。测试仍然需要它们,因为兼容性用例断言的正是
+// 「新解码器与迁移前的解析结果逐字相同」。
+//
+// **不要为了让用例通过而修改这里的规则。** 这里代表的是迁移前已经上线、调用方可能依赖的行为;
+// 确需调整期望时,应在用例里显式写出新的期望值,并确认该变化是有意的接口变更。
+
+// legacyJSONArg 读取请求体为 JSON 对象,失败时把错误写进 result。
+func legacyJSONArg(c *gin.Context, result *gulu.Result) (arg map[string]any, ok bool) {
+ arg = map[string]any{}
+ if err := c.ShouldBindJSON(&arg); err != nil {
+ result.Code = -1
+ var detail string
+ if errors.Is(err, io.EOF) {
+ detail = "the request body is empty or truncated (EOF)"
+ } else {
+ detail = err.Error()
+ }
+ result.Msg = fmt.Sprintf("Parses request [%s] failed: %s", c.Request.URL.Path, detail)
+ return
+ }
+
+ ok = true
+ return
+}
+
+// legacyParseArg 从已解析的对象里取出指定键,按 required / rejectEmpty 校验后写入 result。
+func legacyParseArg[T any](key string, arg map[string]any, ret *gulu.Result, required, rejectEmpty bool) (value T, ok bool) {
+ raw, exists := arg[key]
+ if !exists || raw == nil {
+ if required {
+ ret.Code = -1
+ ret.Msg = fmt.Sprintf("Field [%s] is required", key)
+ } else {
+ ok = true
+ }
+ return
+ }
+
+ value, ok = raw.(T)
+ if !ok {
+ var zero T
+ ret.Code = -1
+
+ jsonType := ""
+ switch any(zero).(type) {
+ case string:
+ jsonType = "String"
+ case float64:
+ jsonType = "Number"
+ case bool:
+ jsonType = "Boolean"
+ case []any:
+ jsonType = "Array"
+ case map[string]any:
+ jsonType = "Object"
+ default:
+ jsonType = fmt.Sprintf("%T", zero)
+ }
+
+ ret.Msg = fmt.Sprintf("Field [%s] should be of type [%s]", key, jsonType)
+ return
+ }
+
+ if rejectEmpty {
+ var bad bool
+ switch x := any(value).(type) {
+ case string:
+ if t := strings.TrimSpace(x); t == "" {
+ bad = true
+ } else {
+ value = any(t).(T)
+ }
+ case []any:
+ bad = len(x) == 0
+ case map[string]any:
+ bad = len(x) == 0
+ }
+ if bad {
+ ret.Code = -1
+ ret.Msg = fmt.Sprintf("Field [%s] must not be empty", key)
+ ok = false
+ }
+ }
+ return
+}
+
+// legacyArgExtractor 为单次提取函数,供 legacyParseArgs 批量使用。
+type legacyArgExtractor func(arg map[string]any, ret *gulu.Result) bool
+
+// legacyBind 生成一个提取函数:取出 key 并写入 dest。
+func legacyBind[T any](key string, dest *T, required, rejectEmpty bool) legacyArgExtractor {
+ return func(arg map[string]any, ret *gulu.Result) bool {
+ v, ok := legacyParseArg[T](key, arg, ret, required, rejectEmpty)
+ if !ok {
+ return false
+ }
+ *dest = v
+ return true
+ }
+}
+
+// legacyParseArgs 依次执行提取函数,任一失败即返回 false 并写错误。
+func legacyParseArgs(arg map[string]any, ret *gulu.Result, extractors ...legacyArgExtractor) bool {
+ for _, ext := range extractors {
+ if !ext(arg, ret) {
+ return false
+ }
+ }
+ return true
+}
+
+// checkLegacyInputCompatibility 以 base 为模板生成一组变异请求体,
+// 逐个比对「迁移前解析」与契约解码器给出的错误消息,要求逐字相同。
+// base 的每个字段都会被替换为 null、false、1、[]、{}、""、" " 以及整体删除,
+// 另外还包含空体、null、非法 JSON 等整体形态。
+func checkLegacyInputCompatibility(t *testing.T, routePath, base string, legacy func(*gin.Context) *gulu.Result, decode func([]byte) error) {
+ t.Helper()
+ fields := map[string]json.RawMessage{}
+ if err := json.Unmarshal([]byte(base), &fields); err != nil {
+ t.Fatalf("%s: base body is not a JSON object: %s", routePath, err)
+ }
+ bodies := [][]byte{[]byte(base), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
+ for key := range fields {
+ for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
+ changed := map[string]json.RawMessage{}
+ maps.Copy(changed, fields)
+ changed[key] = json.RawMessage(value)
+ data, _ := json.Marshal(changed)
+ bodies = append(bodies, data)
+ }
+ changed := map[string]json.RawMessage{}
+ for k, v := range fields {
+ if k != key {
+ changed[k] = v
+ }
+ }
+ data, _ := json.Marshal(changed)
+ bodies = append(bodies, data)
+ }
+ for _, body := range bodies {
+ c, _ := gin.CreateTestContext(httptest.NewRecorder())
+ c.Request = httptest.NewRequest(http.MethodPost, routePath, bytes.NewReader(body))
+ expected := legacy(c)
+ err := decode(body)
+ message := ""
+ if err != nil {
+ message = err.Error()
+ }
+ if message != expected.Msg {
+ t.Errorf("%s: body %s: got %q, want %q", routePath, body, message, expected.Msg)
+ }
+ }
+}
diff --git a/kernel/api/contract_repo_test.go b/kernel/api/contract_repo_test.go
index ebd58b019c..ea21f1835c 100644
--- a/kernel/api/contract_repo_test.go
+++ b/kernel/api/contract_repo_test.go
@@ -15,7 +15,6 @@ import (
"github.com/siyuan-note/siyuan/kernel/model"
"github.com/siyuan-note/siyuan/kernel/util"
"io"
- "maps"
"mime"
"net/http"
"net/http/httptest"
@@ -30,18 +29,18 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var days float64
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("days", &days, true, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("days", &days, true, false)) {
return
}
return
}
- checkRepoInputCompatibility(t, "setRepoIndexRetentionDays", `{"days":1.75}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/setRepoIndexRetentionDays", `{"days":1.75}`, legacy, func(body []byte) error {
_, err := apicontract.SetRepoIndexRetentionDays.Decode(bytes.NewReader(body))
return err
})
@@ -51,18 +50,18 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var indexes float64
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("indexes", &indexes, true, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("indexes", &indexes, true, false)) {
return
}
return
}
- checkRepoInputCompatibility(t, "setRetentionIndexesDaily", `{"indexes":1.75}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/setRetentionIndexesDaily", `{"indexes":1.75}`, legacy, func(body []byte) error {
_, err := apicontract.SetRetentionIndexesDaily.Decode(bytes.NewReader(body))
return err
})
@@ -73,36 +72,36 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var id string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("id", &id, true, true)) {
+ if !legacyParseArgs(arg, ret, legacyBind("id", &id, true, true)) {
return
}
return
}
- checkRepoInputCompatibility(t, "getRepoFile", `{"id":" value "}`, legacy, func(body []byte) error { _, err := apicontract.GetRepoFile.Decode(bytes.NewReader(body)); return err })
+ checkLegacyInputCompatibility(t, "/api/repo/getRepoFile", `{"id":" value "}`, legacy, func(body []byte) error { _, err := apicontract.GetRepoFile.Decode(bytes.NewReader(body)); return err })
})
t.Run("rollbackRepoSnapshotFile", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var id string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("id", &id, true, true)) {
+ if !legacyParseArgs(arg, ret, legacyBind("id", &id, true, true)) {
return
}
return
}
- checkRepoInputCompatibility(t, "rollbackRepoSnapshotFile", `{"id":" value "}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/rollbackRepoSnapshotFile", `{"id":" value "}`, legacy, func(body []byte) error {
_, err := apicontract.RollbackRepoSnapshotFile.Decode(bytes.NewReader(body))
return err
})
@@ -112,18 +111,18 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var id string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("id", &id, true, true)) {
+ if !legacyParseArgs(arg, ret, legacyBind("id", &id, true, true)) {
return
}
return
}
- checkRepoInputCompatibility(t, "openRepoSnapshotFile", `{"id":" value "}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/openRepoSnapshotFile", `{"id":" value "}`, legacy, func(body []byte) error {
_, err := apicontract.OpenRepoSnapshotFile.Decode(bytes.NewReader(body))
return err
})
@@ -133,21 +132,21 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var left, right string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("left", &left, true, true),
- util.BindJsonArg("right", &right, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("left", &left, true, true),
+ legacyBind("right", &right, true, true),
) {
return
}
return
}
- checkRepoInputCompatibility(t, "diffRepoSnapshots", `{"left":" value ","right":" value "}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/diffRepoSnapshots", `{"left":" value ","right":" value "}`, legacy, func(body []byte) error {
_, err := apicontract.DiffRepoSnapshots.Decode(bytes.NewReader(body))
return err
})
@@ -157,42 +156,42 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var id, sessionID string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("id", &id, true, true),
- util.BindJsonArg("sessionID", &sessionID, false, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("id", &id, true, true),
+ legacyBind("sessionID", &sessionID, false, false),
) {
return
}
return
}
- checkRepoInputCompatibility(t, "checkoutRepo", `{"id":" value ","sessionID":" value "}`, legacy, func(body []byte) error { _, err := apicontract.CheckoutRepo.Decode(bytes.NewReader(body)); return err })
+ checkLegacyInputCompatibility(t, "/api/repo/checkoutRepo", `{"id":" value ","sessionID":" value "}`, legacy, func(body []byte) error { _, err := apicontract.CheckoutRepo.Decode(bytes.NewReader(body)); return err })
})
t.Run("downloadCloudSnapshot", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var id, tag string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("id", &id, true, true),
- util.BindJsonArg("tag", &tag, true, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("id", &id, true, true),
+ legacyBind("tag", &tag, true, false),
) {
return
}
return
}
- checkRepoInputCompatibility(t, "downloadCloudSnapshot", `{"id":" value ","tag":" value "}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/downloadCloudSnapshot", `{"id":" value ","tag":" value "}`, legacy, func(body []byte) error {
_, err := apicontract.DownloadCloudSnapshot.Decode(bytes.NewReader(body))
return err
})
@@ -202,21 +201,21 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var id, tag string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("id", &id, true, true),
- util.BindJsonArg("tag", &tag, true, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("id", &id, true, true),
+ legacyBind("tag", &tag, true, false),
) {
return
}
return
}
- checkRepoInputCompatibility(t, "uploadCloudSnapshot", `{"id":" value ","tag":" value "}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/uploadCloudSnapshot", `{"id":" value ","tag":" value "}`, legacy, func(body []byte) error {
_, err := apicontract.UploadCloudSnapshot.Decode(bytes.NewReader(body))
return err
})
@@ -226,18 +225,18 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var page float64
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("page", &page, true, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("page", &page, true, false)) {
return
}
return
}
- checkRepoInputCompatibility(t, "getRepoSnapshots", `{"page":1.75}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/getRepoSnapshots", `{"page":1.75}`, legacy, func(body []byte) error {
_, err := apicontract.GetRepoSnapshots.Decode(bytes.NewReader(body))
return err
})
@@ -247,22 +246,22 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var keyword string
var page float64
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("keyword", &keyword, true, true),
- util.BindJsonArg("page", &page, true, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("keyword", &keyword, true, true),
+ legacyBind("page", &page, true, false),
) {
return
}
return
}
- checkRepoInputCompatibility(t, "searchRepoFile", `{"keyword":" value ","page":1.75}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/searchRepoFile", `{"keyword":" value ","page":1.75}`, legacy, func(body []byte) error {
_, err := apicontract.SearchRepoFile.Decode(bytes.NewReader(body))
return err
})
@@ -272,22 +271,22 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var id string
var page float64
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("id", &id, true, true),
- util.BindJsonArg("page", &page, true, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("id", &id, true, true),
+ legacyBind("page", &page, true, false),
) {
return
}
return
}
- checkRepoInputCompatibility(t, "getRepoDocHistory", `{"id":" value ","page":1.75}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/getRepoDocHistory", `{"id":" value ","page":1.75}`, legacy, func(body []byte) error {
_, err := apicontract.GetRepoDocHistory.Decode(bytes.NewReader(body))
return err
})
@@ -297,20 +296,20 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var id string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("id", &id, true, true),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("id", &id, true, true),
) {
return
}
return
}
- checkRepoInputCompatibility(t, "exportRepoFile", `{"id":" value "}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/exportRepoFile", `{"id":" value "}`, legacy, func(body []byte) error {
_, err := apicontract.ExportRepoFile.Decode(bytes.NewReader(body))
return err
})
@@ -320,18 +319,18 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var page float64
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("page", &page, true, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("page", &page, true, false)) {
return
}
return
}
- checkRepoInputCompatibility(t, "getCloudRepoSnapshots", `{"page":1.75}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/getCloudRepoSnapshots", `{"page":1.75}`, legacy, func(body []byte) error {
_, err := apicontract.GetCloudRepoSnapshots.Decode(bytes.NewReader(body))
return err
})
@@ -346,18 +345,18 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var tag string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("tag", &tag, true, true)) {
+ if !legacyParseArgs(arg, ret, legacyBind("tag", &tag, true, true)) {
return
}
return
}
- checkRepoInputCompatibility(t, "removeCloudRepoTagSnapshot", `{"tag":" value "}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/removeCloudRepoTagSnapshot", `{"tag":" value "}`, legacy, func(body []byte) error {
_, err := apicontract.RemoveCloudRepoTagSnapshot.Decode(bytes.NewReader(body))
return err
})
@@ -372,18 +371,18 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var tag string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("tag", &tag, true, true)) {
+ if !legacyParseArgs(arg, ret, legacyBind("tag", &tag, true, true)) {
return
}
return
}
- checkRepoInputCompatibility(t, "removeRepoTagSnapshot", `{"tag":" value "}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/removeRepoTagSnapshot", `{"tag":" value "}`, legacy, func(body []byte) error {
_, err := apicontract.RemoveRepoTagSnapshot.Decode(bytes.NewReader(body))
return err
})
@@ -393,57 +392,57 @@ func TestRepoContractInputs(t *testing.T) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var id, name string
- if !util.ParseJsonArgs(arg, ret,
- util.BindJsonArg("id", &id, true, true),
- util.BindJsonArg("name", &name, true, false),
+ if !legacyParseArgs(arg, ret,
+ legacyBind("id", &id, true, true),
+ legacyBind("name", &name, true, false),
) {
return
}
return
}
- checkRepoInputCompatibility(t, "tagSnapshot", `{"id":" value ","name":" value "}`, legacy, func(body []byte) error { _, err := apicontract.TagSnapshot.Decode(bytes.NewReader(body)); return err })
+ checkLegacyInputCompatibility(t, "/api/repo/tagSnapshot", `{"id":" value ","name":" value "}`, legacy, func(body []byte) error { _, err := apicontract.TagSnapshot.Decode(bytes.NewReader(body)); return err })
})
t.Run("importRepoKey", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var base64Key string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("key", &base64Key, true, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("key", &base64Key, true, false)) {
return
}
return
}
- checkRepoInputCompatibility(t, "importRepoKey", `{"key":" value "}`, legacy, func(body []byte) error { _, err := apicontract.ImportRepoKey.Decode(bytes.NewReader(body)); return err })
+ checkLegacyInputCompatibility(t, "/api/repo/importRepoKey", `{"key":" value "}`, legacy, func(body []byte) error { _, err := apicontract.ImportRepoKey.Decode(bytes.NewReader(body)); return err })
})
t.Run("initRepoKeyFromPassphrase", func(t *testing.T) {
legacy := func(c *gin.Context) (result *gulu.Result) {
ret := gulu.Ret.NewResult()
defer func() { result = ret }()
- arg, ok := util.JsonArg(c, ret)
+ arg, ok := legacyJSONArg(c, ret)
if !ok {
return
}
var pass string
- if !util.ParseJsonArgs(arg, ret, util.BindJsonArg("pass", &pass, true, false)) {
+ if !legacyParseArgs(arg, ret, legacyBind("pass", &pass, true, false)) {
return
}
return
}
- checkRepoInputCompatibility(t, "initRepoKeyFromPassphrase", `{"pass":" value "}`, legacy, func(body []byte) error {
+ checkLegacyInputCompatibility(t, "/api/repo/initRepoKeyFromPassphrase", `{"pass":" value "}`, legacy, func(body []byte) error {
_, err := apicontract.InitRepoKeyFromPassphrase.Decode(bytes.NewReader(body))
return err
})
@@ -470,43 +469,6 @@ func TestRepoContractInputs(t *testing.T) {
})
}
-func checkRepoInputCompatibility(t *testing.T, name, valid string, legacy func(*gin.Context) *gulu.Result, decode func([]byte) error) {
- t.Helper()
- base := map[string]json.RawMessage{}
- json.Unmarshal([]byte(valid), &base)
- bodies := [][]byte{[]byte(valid), []byte(`{}`), []byte(`null`), []byte(``), []byte(`[`), []byte(`[]`), []byte(`1`)}
- for key := range base {
- for _, value := range []string{"null", "false", "1", "[]", "{}", `""`, `" "`} {
- changed := map[string]json.RawMessage{}
- maps.Copy(changed, base)
- changed[key] = json.RawMessage(value)
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- changed := map[string]json.RawMessage{}
- for k, v := range base {
- if k != key {
- changed[k] = v
- }
- }
- data, _ := json.Marshal(changed)
- bodies = append(bodies, data)
- }
- for _, body := range bodies {
- c, _ := gin.CreateTestContext(httptest.NewRecorder())
- c.Request = httptest.NewRequest(http.MethodPost, "/api/repo/"+name, bytes.NewReader(body))
- expected := legacy(c)
- err := decode(body)
- message := ""
- if err != nil {
- message = err.Error()
- }
- if message != expected.Msg {
- t.Errorf("body %s: got %q want %q", body, message, expected.Msg)
- }
- }
-}
-
func TestRepoFileWireCompatibility(t *testing.T) {
for _, test := range []struct {
path string
diff --git a/kernel/api/contract_setting_test.go b/kernel/api/contract_setting_test.go
index 007e8b0d8d..bbed99225d 100644
--- a/kernel/api/contract_setting_test.go
+++ b/kernel/api/contract_setting_test.go
@@ -29,7 +29,7 @@ func compareSettingConfig[Request settingConfigInput, Data, Config any](t *testi
context, _ := gin.CreateTestContext(httptest.NewRecorder())
context.Request = httptest.NewRequest("POST", endpoint.Definition().Path, strings.NewReader(body))
result := gulu.Ret.NewResult()
- fields, ok := util.JsonArg(context, result)
+ fields, ok := legacyJSONArg(context, result)
if !ok {
t.Fatal(result.Msg)
}
@@ -186,7 +186,7 @@ func TestAPIContractSettingParserCompatibility(t *testing.T) {
context, _ := gin.CreateTestContext(httptest.NewRecorder())
context.Request = httptest.NewRequest("POST", "/api/setting/setEditor", strings.NewReader(body))
result := gulu.Ret.NewResult()
- _, ok := util.JsonArg(context, result)
+ _, ok := legacyJSONArg(context, result)
_, err := apicontract.SetEditor.Decode(strings.NewReader(body))
if ok != (err == nil) || err != nil && err.Error() != result.Msg {
t.Fatalf("parser changed for %s: before=%s after=%v", body, result.Msg, err)
diff --git a/kernel/api/contract_sync_test.go b/kernel/api/contract_sync_test.go
index 9c03e1e00b..15d6926dd9 100644
--- a/kernel/api/contract_sync_test.go
+++ b/kernel/api/contract_sync_test.go
@@ -48,8 +48,8 @@ func compareSyncDecode[Request, Data, Value any](t *testing.T, endpoint apicontr
context.Request = httptest.NewRequest("POST", endpoint.Definition().Path, strings.NewReader(body))
expected := gulu.Ret.NewResult()
var value Value
- if args, ok := util.JsonArg(context, expected); ok {
- util.ParseJsonArgs(args, expected, util.BindJsonArg(key, &value, required, rejectEmpty))
+ if args, ok := legacyJSONArg(context, expected); ok {
+ legacyParseArgs(args, expected, legacyBind(key, &value, required, rejectEmpty))
}
request, err := endpoint.Decode(strings.NewReader(body))
if expected.Code != 0 {
diff --git a/kernel/api/export.go b/kernel/api/export.go
index d9f6e431ab..c98d98ff17 100644
--- a/kernel/api/export.go
+++ b/kernel/api/export.go
@@ -42,180 +42,154 @@ import (
)
var exportCodeBlock = contractHandler(apicontract.ExportCodeBlock, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportPathData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportPathData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportPathData](err)
}
filePath, err := model.ExportCodeBlock(id)
if err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.ExportPathData](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.ExportPathData](1, err.Error(), 7000)
}
return apicontract.Success(apicontract.ExportPathData{Path: filePath})
})
var exportAttributeView = contractHandler(apicontract.ExportAttributeView, func(c *gin.Context, request apicontract.ExportAttributeViewRequest) apicontract.Response[apicontract.ExportZipData] {
- ret := gulu.Ret.NewResult()
avID := request.ID
blockID := request.BlockID
- if !holdEncryptedExportRequest(c, blockID, ret) {
- return contractFailure[apicontract.ExportZipData](ret)
+ if err := holdEncryptedExportRequest(c, blockID); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportZipData](err)
}
zipPath, err := model.ExportAv2CSV(avID, blockID)
if err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.ExportZipData](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.ExportZipData](1, err.Error(), 7000)
}
return apicontract.Success(apicontract.ExportZipData{Zip: zipPath})
})
var exportEPUB = contractHandler(apicontract.ExportEPUB, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportNamedZipData](err)
}
name, zipPath := model.ExportPandocConvertZip([]string{id}, "epub", ".epub")
return apicontract.Success(apicontract.ExportNamedZipData{Name: name, Zip: zipPath})
})
var exportRTF = contractHandler(apicontract.ExportRTF, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportNamedZipData](err)
}
name, zipPath := model.ExportPandocConvertZip([]string{id}, "rtf", ".rtf")
return apicontract.Success(apicontract.ExportNamedZipData{Name: name, Zip: zipPath})
})
var exportODT = contractHandler(apicontract.ExportODT, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportNamedZipData](err)
}
name, zipPath := model.ExportPandocConvertZip([]string{id}, "odt", ".odt")
return apicontract.Success(apicontract.ExportNamedZipData{Name: name, Zip: zipPath})
})
var exportMediaWiki = contractHandler(apicontract.ExportMediaWiki, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportNamedZipData](err)
}
name, zipPath := model.ExportPandocConvertZip([]string{id}, "mediawiki", ".wiki")
return apicontract.Success(apicontract.ExportNamedZipData{Name: name, Zip: zipPath})
})
var exportOrgMode = contractHandler(apicontract.ExportOrgMode, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportNamedZipData](err)
}
name, zipPath := model.ExportPandocConvertZip([]string{id}, "org", ".org")
return apicontract.Success(apicontract.ExportNamedZipData{Name: name, Zip: zipPath})
})
var exportOPML = contractHandler(apicontract.ExportOPML, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportNamedZipData](err)
}
name, zipPath := model.ExportPandocConvertZip([]string{id}, "opml", ".opml")
return apicontract.Success(apicontract.ExportNamedZipData{Name: name, Zip: zipPath})
})
var exportTextile = contractHandler(apicontract.ExportTextile, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportNamedZipData](err)
}
name, zipPath := model.ExportPandocConvertZip([]string{id}, "textile", ".textile")
return apicontract.Success(apicontract.ExportNamedZipData{Name: name, Zip: zipPath})
})
var exportAsciiDoc = contractHandler(apicontract.ExportAsciiDoc, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportNamedZipData](err)
}
name, zipPath := model.ExportPandocConvertZip([]string{id}, "asciidoc", ".adoc")
return apicontract.Success(apicontract.ExportNamedZipData{Name: name, Zip: zipPath})
})
var exportReStructuredText = contractHandler(apicontract.ExportReStructuredText, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportNamedZipData](err)
}
name, zipPath := model.ExportPandocConvertZip([]string{id}, "rst", ".rst")
return apicontract.Success(apicontract.ExportNamedZipData{Name: name, Zip: zipPath})
})
var export2Liandi = contractHandler(apicontract.Export2Liandi, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
id := request.ID
err := model.Export2Liandi(id)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
var exportDataInFolder = contractHandler(apicontract.ExportDataInFolder, func(c *gin.Context, request apicontract.ExportFolderRequest) apicontract.Response[apicontract.ExportNameData] {
- ret := gulu.Ret.NewResult()
exportFolder := request.Folder
name, err := model.ExportDataInFolder(exportFolder)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.ExportNameData](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.ExportNameData](-1, err.Error(), 7000)
}
return apicontract.Success(apicontract.ExportNameData{Name: name})
})
var exportData = contractHandler(apicontract.ExportData, func(c *gin.Context, request apicontract.EmptyRequest) apicontract.Response[apicontract.ExportZipData] {
- ret := gulu.Ret.NewResult()
zipPath, err := model.ExportData()
if err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.ExportZipData](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.ExportZipData](1, err.Error(), 7000)
}
return apicontract.Success(apicontract.ExportZipData{Zip: zipPath})
})
var exportResources = contractHandler(apicontract.ExportResources, func(c *gin.Context, request apicontract.ExportResourcesRequest) apicontract.Response[apicontract.ExportPathData] {
- ret := gulu.Ret.NewResult()
-
var name string
if request.Name != nil {
name = util.TruncateLenFileName(*request.Name)
@@ -225,7 +199,6 @@ var exportResources = contractHandler(apicontract.ExportResources, func(c *gin.C
}
if request.Paths == nil {
- ret.Code = 1
return apicontract.FailureWithText[apicontract.ExportPathData](1, "[paths] is required", "")
}
@@ -233,122 +206,95 @@ var exportResources = contractHandler(apicontract.ExportResources, func(c *gin.C
zipFilePath, err := model.ExportResources(resourcePaths, name)
if err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.ExportPathData](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.ExportPathData](1, err.Error(), 7000)
}
return apicontract.Success(apicontract.ExportPathData{Path: zipFilePath})
})
var exportNotebookMd = contractHandler(apicontract.ExportNotebookMd, func(c *gin.Context, request apicontract.ExportNotebookMarkdownRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ return apicontract.Failure[apicontract.ExportNamedZipData](-1, model.Conf.Language(314))
}
if err := request.Validate(); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ return apicontract.Failure[apicontract.ExportNamedZipData](-1, err.Error())
}
zipPath := model.ExportNotebookMarkdownWithOptions(notebook, exportMarkdownOptions(request.ExportMarkdownOptions))
return apicontract.Success(apicontract.ExportNamedZipData{Name: path.Base(zipPath), Zip: zipPath})
})
var exportNotebooksMd = contractHandler(apicontract.ExportNotebooksMd, func(c *gin.Context, request apicontract.ExportNotebooksMarkdownRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
notebooks := request.IDs()
if len(notebooks) < 1 {
- ret.Code = -1
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ return apicontract.Failure[apicontract.ExportNamedZipData](-1, "")
}
if slices.ContainsFunc(notebooks, model.IsEncryptedBox) {
- ret.Code = -1
- ret.Msg = model.Conf.Language(395)
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ return apicontract.Failure[apicontract.ExportNamedZipData](-1, model.Conf.Language(395))
}
if err := request.Validate(); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ return apicontract.Failure[apicontract.ExportNamedZipData](-1, err.Error())
}
zipPath := model.ExportNotebooksMarkdownWithOptions(notebooks, exportMarkdownOptions(request.ExportMarkdownOptions))
return apicontract.Success(apicontract.ExportNamedZipData{Name: path.Base(zipPath), Zip: zipPath})
})
var exportMds = contractHandler(apicontract.ExportMds, func(c *gin.Context, request apicontract.ExportDocumentsMarkdownRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
ids := exportStrings(request.IDs)
- if !holdEncryptedExportRequests(c, ids, ret) {
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ if err := holdEncryptedExportRequests(c, ids); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportNamedZipData](err)
}
if err := request.Validate(); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ return apicontract.Failure[apicontract.ExportNamedZipData](-1, err.Error())
}
name, zipPath := model.ExportPandocConvertZipWithOptions(ids, "", ".md", exportMarkdownOptions(request.ExportMarkdownOptions))
return apicontract.Success(apicontract.ExportNamedZipData{Name: name, Zip: zipPath})
})
var exportMd = contractHandler(apicontract.ExportMd, func(c *gin.Context, request apicontract.ExportMarkdownRequest) apicontract.Response[apicontract.ExportNamedZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportNamedZipData](err)
}
if err := request.Validate(); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportNamedZipData](ret)
+ return apicontract.Failure[apicontract.ExportNamedZipData](-1, err.Error())
}
name, zipPath := model.ExportPandocConvertZipWithOptions([]string{id}, "", ".md", exportMarkdownOptions(request.ExportMarkdownOptions))
return apicontract.Success(apicontract.ExportNamedZipData{Name: name, Zip: zipPath})
})
var exportNotebookSY = contractHandler(apicontract.ExportNotebookSY, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
if err := holdEncryptedBoxRequest(c, id); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.ExportZipData](ret)
+ return apicontract.Failure[apicontract.ExportZipData](-1, model.Conf.Language(314))
}
zipPath := model.ExportNotebookSY(id)
return apicontract.Success(apicontract.ExportZipData{Zip: zipPath})
})
var exportNotebooksSY = contractHandler(apicontract.ExportNotebooksSY, func(c *gin.Context, request apicontract.ExportNotebooksRequest) apicontract.Response[apicontract.ExportZipData] {
- ret := gulu.Ret.NewResult()
notebooks := request.IDs()
if len(notebooks) < 1 {
- ret.Code = -1
- return contractFailure[apicontract.ExportZipData](ret)
+ return apicontract.Failure[apicontract.ExportZipData](-1, "")
}
if slices.ContainsFunc(notebooks, model.IsEncryptedBox) {
- ret.Code = -1
- ret.Msg = model.Conf.Language(395)
- return contractFailure[apicontract.ExportZipData](ret)
+ return apicontract.Failure[apicontract.ExportZipData](-1, model.Conf.Language(395))
}
zipPath := model.ExportNotebooksSY(notebooks)
return apicontract.Success(apicontract.ExportZipData{Zip: zipPath})
})
var exportSYs = contractHandler(apicontract.ExportSYs, func(c *gin.Context, request apicontract.ExportIDsRequest) apicontract.Response[apicontract.ExportZipData] {
- ret := gulu.Ret.NewResult()
ids := exportStrings(request.IDs)
- if !holdEncryptedExportRequests(c, ids, ret) {
- return contractFailure[apicontract.ExportZipData](ret)
+ if err := holdEncryptedExportRequests(c, ids); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportZipData](err)
}
zipPath := model.ExportSYs(ids)
@@ -356,11 +302,10 @@ var exportSYs = contractHandler(apicontract.ExportSYs, func(c *gin.Context, requ
})
var exportSY = contractHandler(apicontract.ExportSY, func(c *gin.Context, request apicontract.ExportIDRequest) apicontract.Response[apicontract.ExportZipData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportZipData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportZipData](err)
}
zipPath := model.ExportSYs([]string{id})
return apicontract.Success(apicontract.ExportZipData{Zip: zipPath})
@@ -369,20 +314,16 @@ var exportSY = contractHandler(apicontract.ExportSY, func(c *gin.Context, reques
var exportMdContent = contractHandler(apicontract.ExportMdContent, func(c *gin.Context, request apicontract.ExportMarkdownContentRequest) apicontract.Response[apicontract.ExportMarkdownContentData] {
confExportSnapshot := model.Conf.LoadExport()
- ret := gulu.Ret.NewResult()
-
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.ExportMarkdownContentData](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportMarkdownContentData](err)
}
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportMarkdownContentData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportMarkdownContentData](err)
}
if err := request.Validate(); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportMarkdownContentData](ret)
+ return apicontract.Failure[apicontract.ExportMarkdownContentData](-1, err.Error())
}
refMode, embedMode, yfm := confExportSnapshot.BlockRefMode, confExportSnapshot.BlockEmbedMode, true
if request.RefMode != nil {
@@ -416,7 +357,6 @@ var exportMdContent = contractHandler(apicontract.ExportMdContent, func(c *gin.C
})
var exportDocx = contractHandler(apicontract.ExportDocx, func(c *gin.Context, request apicontract.ExportDocxRequest) apicontract.Response[apicontract.ExportPathData] {
- ret := gulu.Ret.NewResult()
id := request.ID
savePath := request.SavePath
@@ -424,34 +364,29 @@ var exportDocx = contractHandler(apicontract.ExportDocx, func(c *gin.Context, re
merge := request.Merge
mergeDocHeadingMode := request.MergeDocHeadingMode
mergeContentHeadingMode := request.MergeContentHeadingMode
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportPathData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportPathData](err)
}
// savePath 由客户端指定,禁止写入加密笔记本目录(明文导出物会绕过加密、锁定后残留)
if rejectEncryptedBoxPath(savePath) {
- ret.Code = -1
- ret.Msg = model.Conf.Language(383)
- return contractFailure[apicontract.ExportPathData](ret)
+ return apicontract.Failure[apicontract.ExportPathData](-1, model.Conf.Language(383))
}
mergeHeadingOptions := model.MergeHeadingOptions{DocHeadingMode: mergeDocHeadingMode, ContentHeadingMode: mergeContentHeadingMode}
fullPath, err := model.ExportDocx(id, savePath, removeAssets, merge, mergeHeadingOptions)
if err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.ExportPathData](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.ExportPathData](1, err.Error(), 7000)
}
return apicontract.Success(apicontract.ExportPathData{Path: fullPath})
})
var exportMdHTML = contractHandler(apicontract.ExportMdHTML, func(c *gin.Context, request apicontract.ExportMarkdownHTMLRequest) apicontract.Response[apicontract.ExportHTMLData] {
- ret := gulu.Ret.NewResult()
id := request.ID
savePath := request.SavePath
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportHTMLData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportHTMLData](err)
}
savePath = strings.TrimSpace(savePath)
@@ -468,9 +403,7 @@ var exportMdHTML = contractHandler(apicontract.ExportMdHTML, func(c *gin.Context
// savePath 由客户端指定,禁止写入加密笔记本目录(明文导出物会绕过加密、锁定后残留)
if rejectEncryptedBoxPath(savePath) {
- ret.Code = -1
- ret.Msg = model.Conf.Language(383)
- return contractFailure[apicontract.ExportHTMLData](ret)
+ return apicontract.Failure[apicontract.ExportHTMLData](-1, model.Conf.Language(383))
}
name, content := model.ExportMarkdownHTML(id, savePath, false, false)
@@ -478,12 +411,11 @@ var exportMdHTML = contractHandler(apicontract.ExportMdHTML, func(c *gin.Context
})
var exportTempContent = contractHandler(apicontract.ExportTempContent, func(c *gin.Context, request apicontract.ExportTempContentRequest) apicontract.Response[apicontract.ExportURLData] {
- ret := gulu.Ret.NewResult()
content := request.Content
id := request.ID
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportURLData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportURLData](err)
}
tmpExport := filepath.Join(util.TempDir, "export")
// 加密笔记本的临时导出归入 boxID 子目录,确保 LockBox 清理和服务端校验锁定状态
@@ -494,15 +426,11 @@ var exportTempContent = contractHandler(apicontract.ExportTempContent, func(c *g
}
tmpExport = filepath.Join(tmpExport, "temp")
if err := os.MkdirAll(tmpExport, 0755); err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.ExportURLData](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.ExportURLData](1, err.Error(), 7000)
}
p := filepath.Join(tmpExport, gulu.Rand.String(7))
if err := os.WriteFile(p, []byte(content), 0644); err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.ExportURLData](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.ExportURLData](1, err.Error(), 7000)
}
baseName := filepath.Base(p)
urlPath := "/export/"
@@ -524,7 +452,6 @@ var exportTempContent = contractHandler(apicontract.ExportTempContent, func(c *g
})
var exportBrowserHTML = contractHandler(apicontract.ExportBrowserHTML, func(c *gin.Context, request apicontract.ExportBrowserHTMLRequest) apicontract.Response[apicontract.ExportZipData] {
- ret := gulu.Ret.NewResult()
folder := request.Folder
htmlContent := request.HTML
@@ -534,9 +461,7 @@ var exportBrowserHTML = contractHandler(apicontract.ExportBrowserHTML, func(c *g
exportDir := filepath.Join(util.TempDir, "export")
tmpDir := filepath.Join(exportDir, folder)
if !gulu.File.IsSubPath(exportDir, tmpDir) {
- ret.Code = -1
- ret.Msg = model.Conf.Language(383)
- return contractFailure[apicontract.ExportZipData](ret)
+ return apicontract.Failure[apicontract.ExportZipData](-1, model.Conf.Language(383))
}
// 检测是否来自加密笔记本:folder 形如 <boxID>/<folderName>
@@ -546,17 +471,13 @@ var exportBrowserHTML = contractHandler(apicontract.ExportBrowserHTML, func(c *g
}
if boxID != "" {
if err := holdEncryptedBoxRequest(c, boxID); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.ExportZipData](ret)
+ return apicontract.Failure[apicontract.ExportZipData](-1, model.Conf.Language(314))
}
}
htmlPath := filepath.Join(tmpDir, "index.html")
if err := filelock.WriteFile(htmlPath, []byte(htmlContent)); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportZipData](ret)
+ return apicontract.Failure[apicontract.ExportZipData](-1, err.Error())
}
zipFileName := util.FilterFileName(name) + ".zip"
@@ -565,9 +486,7 @@ var exportBrowserHTML = contractHandler(apicontract.ExportBrowserHTML, func(c *g
// 加密笔记本的导出 ZIP 写入 boxID 子目录,并注册托管 token
zipAbsPath = filepath.Join(util.TempDir, "export", boxID, "html", gulu.Rand.String(7)+"-"+zipFileName)
if err := os.MkdirAll(filepath.Dir(zipAbsPath), 0755); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportZipData](ret)
+ return apicontract.Failure[apicontract.ExportZipData](-1, err.Error())
}
} else {
zipAbsPath = filepath.Join(util.TempDir, "export", zipFileName)
@@ -575,25 +494,19 @@ var exportBrowserHTML = contractHandler(apicontract.ExportBrowserHTML, func(c *g
zip, err := gulu.Zip.Create(zipAbsPath)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportZipData](ret)
+ return apicontract.Failure[apicontract.ExportZipData](-1, err.Error())
}
err = zip.AddDirectory("", tmpDir, func(string) {})
if err != nil {
_ = zip.Close()
_ = os.Remove(zipAbsPath)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportZipData](ret)
+ return apicontract.Failure[apicontract.ExportZipData](-1, err.Error())
}
if err = zip.Close(); err != nil {
_ = os.Remove(zipAbsPath)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportZipData](ret)
+ return apicontract.Failure[apicontract.ExportZipData](-1, err.Error())
}
os.RemoveAll(tmpDir)
@@ -608,15 +521,14 @@ var exportBrowserHTML = contractHandler(apicontract.ExportBrowserHTML, func(c *g
})
var exportPreviewHTML = contractHandler(apicontract.ExportPreviewHTML, func(c *gin.Context, request apicontract.ExportPreviewHTMLRequest) apicontract.Response[apicontract.ExportPreviewHTMLData] {
- ret := gulu.Ret.NewResult()
id := request.ID
keepFold := request.KeepFold
merge := request.Merge
mergeDocHeadingMode := request.MergeDocHeadingMode
mergeContentHeadingMode := request.MergeContentHeadingMode
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportPreviewHTMLData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportPreviewHTMLData](err)
}
addTitle, customTitle := exportTitleOptions(request.ExportTitleOptions)
mergeHeadingOptions := model.MergeHeadingOptions{DocHeadingMode: mergeDocHeadingMode, ContentHeadingMode: mergeContentHeadingMode}
@@ -637,7 +549,6 @@ var exportPreviewHTML = contractHandler(apicontract.ExportPreviewHTML, func(c *g
})
var exportHTML = contractHandler(apicontract.ExportHTML, func(c *gin.Context, request apicontract.ExportHTMLRequest) apicontract.Response[apicontract.ExportHTMLData] {
- ret := gulu.Ret.NewResult()
id := request.ID
pdf := request.PDF
@@ -646,8 +557,8 @@ var exportHTML = contractHandler(apicontract.ExportHTML, func(c *gin.Context, re
merge := request.Merge
mergeDocHeadingMode := request.MergeDocHeadingMode
mergeContentHeadingMode := request.MergeContentHeadingMode
- if !holdEncryptedExportRequest(c, id, ret) {
- return contractFailure[apicontract.ExportHTMLData](ret)
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return apicontract.FailureFrom[apicontract.ExportHTMLData](err)
}
addTitle, customTitle := exportTitleOptions(request.ExportTitleOptions)
@@ -666,9 +577,7 @@ var exportHTML = contractHandler(apicontract.ExportHTML, func(c *gin.Context, re
// savePath 由客户端指定,禁止写入加密笔记本目录(明文导出物会绕过加密、锁定后残留)
if rejectEncryptedBoxPath(savePath) {
- ret.Code = -1
- ret.Msg = model.Conf.Language(383)
- return contractFailure[apicontract.ExportHTMLData](ret)
+ return apicontract.Failure[apicontract.ExportHTMLData](-1, model.Conf.Language(383))
}
name, content, _ := model.ExportHTMLWithTitle(id, savePath, pdf, keepFold, merge, addTitle, customTitle, mergeHeadingOptions)
@@ -715,30 +624,29 @@ func exportMarkdownOptions(options apicontract.ExportMarkdownOptions) *model.Exp
}
}
-func holdEncryptedExportRequest(c *gin.Context, id string, ret *gulu.Result) bool {
+// holdEncryptedExportRequest 在导出加密笔记本内容前取得租约,返回 nil 表示可以继续。
+func holdEncryptedExportRequest(c *gin.Context, id string) error {
block := treenode.GetBlockTree(id)
if block == nil || !model.IsEncryptedBox(block.BoxID) {
- return true
+ return nil
}
if err := holdEncryptedBoxRequest(c, block.BoxID); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return false
+ return apicontract.Reject(model.Conf.Language(314))
}
- return true
+ return nil
}
-func holdEncryptedExportRequests(c *gin.Context, ids []string, ret *gulu.Result) bool {
+// holdEncryptedExportRequests 同上,对一组块按顺序取得租约,遇错即返回。
+func holdEncryptedExportRequests(c *gin.Context, ids []string) error {
for _, id := range ids {
- if !holdEncryptedExportRequest(c, id, ret) {
- return false
+ if err := holdEncryptedExportRequest(c, id); err != nil {
+ return err
}
}
- return true
+ return nil
}
var processPDF = contractHandler(apicontract.ProcessPDF, func(c *gin.Context, request apicontract.ProcessPDFRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
if request.ExportAssets {
if !filepath.IsAbs(request.Path) {
return apicontract.Failure[apicontract.Null](-1, "path must be absolute for PDF asset export")
@@ -746,8 +654,8 @@ var processPDF = contractHandler(apicontract.ProcessPDF, func(c *gin.Context, re
if rejectEncryptedBoxPath(request.Path) {
return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(383))
}
- if !holdEncryptedExportRequest(c, request.ID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := holdEncryptedExportRequest(c, request.ID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
}
@@ -761,9 +669,7 @@ var processPDF = contractHandler(apicontract.ProcessPDF, func(c *gin.Context, re
mergeHeadingOptions := model.MergeHeadingOptions{DocHeadingMode: mergeDocHeadingMode, ContentHeadingMode: mergeContentHeadingMode}
err := model.ProcessPDF(id, pdfPath, merge, removeAssets, watermark, request.ExportAssets, mergeHeadingOptions)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
@@ -803,25 +709,20 @@ var exportPreview = contractHandler(apicontract.ExportPreview, func(c *gin.Conte
})
var exportAsFile = contractHandler(apicontract.ExportAsFile, func(c *gin.Context, request apicontract.ExportAsFileRequest) apicontract.Response[apicontract.ExportFileData] {
- ret := gulu.Ret.NewResult()
file := request.File
reader, err := file.Open()
if err != nil {
logging.LogErrorf("export as file failed: %s", err)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportFileData](ret)
+ return apicontract.Failure[apicontract.ExportFileData](-1, err.Error())
}
defer reader.Close()
data, err := io.ReadAll(reader)
if err != nil {
logging.LogErrorf("export as file failed: %s", err)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportFileData](ret)
+ return apicontract.Failure[apicontract.ExportFileData](-1, err.Error())
}
name := "file-" + file.Filename
@@ -835,33 +736,26 @@ var exportAsFile = contractHandler(apicontract.ExportAsFile, func(c *gin.Context
tmpDir := filepath.Join(util.TempDir, "export")
if err = os.MkdirAll(tmpDir, 0755); err != nil {
logging.LogErrorf("export as file failed: %s", err)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportFileData](ret)
+ return apicontract.Failure[apicontract.ExportFileData](-1, err.Error())
}
tmp := filepath.Join(tmpDir, name)
err = os.WriteFile(tmp, data, 0644)
if err != nil {
logging.LogErrorf("export as file failed: %s", err)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.ExportFileData](ret)
+ return apicontract.Failure[apicontract.ExportFileData](-1, err.Error())
}
return apicontract.Success(apicontract.ExportFileData{File: path.Join("/export/", name)})
})
var copyExportFile = contractHandler(apicontract.CopyExportFile, func(c *gin.Context, request apicontract.CopyExportFileRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
srcPath := request.SrcPath
dest := request.Dest
if !filepath.IsAbs(dest) {
- ret.Code = -1
- ret.Msg = "dest must be an absolute path"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "dest must be an absolute path")
}
srcPath = filepath.Clean(srcPath)
@@ -873,9 +767,7 @@ var copyExportFile = contractHandler(apicontract.CopyExportFile, func(c *gin.Con
exportBaseDir := filepath.Join(util.TempDir, "export")
if !gulu.File.IsSubPath(exportBaseDir, srcFullPath) && srcFullPath != exportBaseDir {
- ret.Code = -1
- ret.Msg = "invalid source path"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "invalid source path")
}
// 加密导出受控路径(<boxID>/<kind>/<file>):按注册表无条件校验,不依赖 IsEncryptedBox。
@@ -886,36 +778,26 @@ var copyExportFile = contractHandler(apicontract.CopyExportFile, func(c *gin.Con
if model.IsManagedEncryptedExportPath(relativeExportPath) {
boxID, _, ok := model.ResolveManagedEncryptedExport(relativeExportPath)
if !ok {
- ret.Code = -1
- ret.Msg = "export file is not available"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "export file is not available")
}
if err := holdEncryptedBoxRequest(c, boxID); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(314))
}
model.HoldBoxReadLock(boxID)
if _, dekErr := model.GetDEKIfUnlocked(boxID); dekErr != nil {
model.ReleaseBoxReadLock(boxID)
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(314))
}
defer model.ReleaseBoxReadLock(boxID)
}
if util.IsSensitivePath(dest) {
- ret.Code = -2
- ret.Msg = "refuse to copy to sensitive path: " + dest
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-2, "refuse to copy to sensitive path: "+dest)
}
if err := copyExportFileToDestination(srcFullPath, dest); err != nil {
logging.LogErrorf("copy export file [%s] to [%s] failed: %s", srcFullPath, dest, err)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
diff --git a/kernel/api/file.go b/kernel/api/file.go
index 49d85f2eb3..c81a15d1ad 100644
--- a/kernel/api/file.go
+++ b/kernel/api/file.go
@@ -94,12 +94,9 @@ func copyDecryptedAsset(src, dest string) error {
}
var getUniqueFilename = contractHandler(apicontract.GetUniqueFilename, func(c *gin.Context, request apicontract.FilePathRequest) apicontract.Response[apicontract.FilePathData] {
- ret := gulu.Ret.NewResult()
filePath := request.Path
if rejectEncryptedBoxPath(filePath) {
- ret.Code = -3
- ret.Msg = model.Conf.Language(321)
- return contractFailure[apicontract.FilePathData](ret)
+ return apicontract.Failure[apicontract.FilePathData](-3, model.Conf.Language(321))
}
return apicontract.Success(apicontract.FilePathData{Path: util.GetUniqueFilename(filePath)})
})
@@ -127,7 +124,6 @@ func prepareFileAssets(absPath string) error {
}
var globalCopyFiles = contractHandler(apicontract.GlobalCopyFiles, func(c *gin.Context, request apicontract.CopyFilesRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
var changedPaths []string
defer func() {
model.IncSyncIfNeeded(changedPaths...)
@@ -137,9 +133,7 @@ var globalCopyFiles = contractHandler(apicontract.GlobalCopyFiles, func(c *gin.C
for i, src := range srcs {
if !filepath.IsAbs(src) {
logging.LogErrorf("global copy files src [%s] is not an absolute path", src)
- ret.Code = -1
- ret.Msg = "Field [srcs]: each path must be absolute"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "Field [srcs]: each path must be absolute")
}
absSrc, _ := filepath.Abs(src)
@@ -149,44 +143,32 @@ var globalCopyFiles = contractHandler(apicontract.GlobalCopyFiles, func(c *gin.C
if util.IsSensitivePath(absSrc) {
logging.LogErrorf("refuse to copy sensitive file [%s]", src)
- ret.Code = -2
- ret.Msg = fmt.Sprintf("refuse to copy sensitive file [%s]", src)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-2, fmt.Sprintf("refuse to copy sensitive file [%s]", src))
}
if rejectEncryptedBoxPath(absSrc) {
- ret.Code = -3
- ret.Msg = model.Conf.Language(321)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-3, model.Conf.Language(321))
}
if err := prepareFileAssets(absSrc); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if !filelock.IsExist(absSrc) {
- ret.Code = -1
- ret.Msg = fmt.Sprintf("file [%s] does not exist", src)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, fmt.Sprintf("file [%s] does not exist", src))
}
srcs[i] = absSrc
}
destDir, err := util.GetAbsPathInWorkspace(destDirArg)
if err != nil {
- ret.Code = http.StatusForbidden
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusForbidden, err.Error())
}
// 在 MkdirAll 前拒绝加密笔记本目录,避免在加密笔记本内创建明文目录
if util.IsPluginDevelopmentRawPathForbidden(destDir, false) {
return apicontract.Failure[apicontract.Null](http.StatusForbidden, "managed plugin development files require their dedicated tools")
}
if rejectEncryptedBoxPath(destDir) {
- ret.Code = -1
- ret.Msg = "copying encrypted notebook files is not supported via this API"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "copying encrypted notebook files is not supported via this API")
}
var destinations []string
for _, src := range srcs {
@@ -198,21 +180,15 @@ var globalCopyFiles = contractHandler(apicontract.GlobalCopyFiles, func(c *gin.C
if filelock.IsExist(destDir) {
destInfo, statErr := os.Stat(destDir)
if statErr != nil {
- ret.Code = -1
- ret.Msg = statErr.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, statErr.Error())
}
if !destInfo.IsDir() {
- ret.Code = -1
- ret.Msg = fmt.Sprintf("Field [destDir]: path [%s] is not a directory", destDirArg)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, fmt.Sprintf("Field [destDir]: path [%s] is not a directory", destDirArg))
}
} else {
if err = os.MkdirAll(destDir, 0755); err != nil {
logging.LogErrorf("make dir [%s] failed: %s", destDir, err)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
}
@@ -222,21 +198,15 @@ var globalCopyFiles = contractHandler(apicontract.GlobalCopyFiles, func(c *gin.C
return apicontract.Failure[apicontract.Null](http.StatusForbidden, "managed plugin development files require their dedicated tools")
}
if rejectEncryptedBoxPath(dest) {
- ret.Code = -3
- ret.Msg = model.Conf.Language(321)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-3, model.Conf.Language(321))
}
// 拒绝目标已存在的 symlink:os.Create 会跟随 symlink,可能写入加密笔记本内部
if li, lerr := os.Lstat(dest); lerr == nil && li.Mode()&os.ModeSymlink != 0 {
- ret.Code = -1
- ret.Msg = "destination path is a symlink, which is not supported"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "destination path is a symlink, which is not supported")
}
if err := model.CopyFileWithDocumentAddressing(src, dest); err != nil {
logging.LogErrorf("copy file [%s] to [%s] failed: %s", src, dest, err)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
changedPaths = append(changedPaths, dest)
}
@@ -244,7 +214,6 @@ var globalCopyFiles = contractHandler(apicontract.GlobalCopyFiles, func(c *gin.C
})
var workspaceCopyFiles = contractHandler(apicontract.WorkspaceCopyFiles, func(c *gin.Context, request apicontract.CopyFilesRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
var changedPaths []string
defer func() {
model.IncSyncIfNeeded(changedPaths...)
@@ -255,51 +224,37 @@ var workspaceCopyFiles = contractHandler(apicontract.WorkspaceCopyFiles, func(c
for _, src := range relSrcs {
absSrc, err := util.GetAbsPathInWorkspace(src)
if err != nil {
- ret.Code = http.StatusForbidden
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusForbidden, err.Error())
}
if util.IsSensitivePath(absSrc) {
logging.LogErrorf("refuse to copy sensitive file [%s]", src)
- ret.Code = -2
- ret.Msg = fmt.Sprintf("refuse to copy sensitive file [%s]", src)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-2, fmt.Sprintf("refuse to copy sensitive file [%s]", src))
}
if util.IsPluginDevelopmentRawPathForbidden(absSrc, true) {
return apicontract.Failure[apicontract.Null](http.StatusForbidden, "managed plugin development files require their dedicated tools")
}
if rejectEncryptedBoxPath(absSrc) {
- ret.Code = -3
- ret.Msg = model.Conf.Language(321)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-3, model.Conf.Language(321))
}
if err = prepareFileAssets(absSrc); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if !filelock.IsExist(absSrc) {
- ret.Code = -1
- ret.Msg = fmt.Sprintf("file [%s] does not exist", src)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, fmt.Sprintf("file [%s] does not exist", src))
}
absSrcs = append(absSrcs, absSrc)
}
destDir, err := util.GetAbsPathInWorkspace(destDirArg)
if err != nil {
- ret.Code = http.StatusForbidden
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusForbidden, err.Error())
}
// 在 MkdirAll 前拒绝加密笔记本目录,避免在加密笔记本内创建明文目录
if util.IsPluginDevelopmentRawPathForbidden(destDir, false) {
return apicontract.Failure[apicontract.Null](http.StatusForbidden, "managed plugin development files require their dedicated tools")
}
if rejectEncryptedBoxPath(destDir) {
- ret.Code = -1
- ret.Msg = "copying encrypted notebook files is not supported via this API"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "copying encrypted notebook files is not supported via this API")
}
var destinations []string
for _, src := range absSrcs {
@@ -311,21 +266,15 @@ var workspaceCopyFiles = contractHandler(apicontract.WorkspaceCopyFiles, func(c
if filelock.IsExist(destDir) {
destInfo, err := os.Stat(destDir)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if !destInfo.IsDir() {
- ret.Code = -1
- ret.Msg = "Field [destDir]: path is not a directory"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "Field [destDir]: path is not a directory")
}
} else {
if err = os.MkdirAll(destDir, 0755); err != nil {
logging.LogErrorf("make dir [%s] failed: %s", destDir, err)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
}
@@ -335,20 +284,14 @@ var workspaceCopyFiles = contractHandler(apicontract.WorkspaceCopyFiles, func(c
return apicontract.Failure[apicontract.Null](http.StatusForbidden, "managed plugin development files require their dedicated tools")
}
if rejectEncryptedBoxPath(dest) {
- ret.Code = -3
- ret.Msg = model.Conf.Language(321)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-3, model.Conf.Language(321))
}
if li, lerr := os.Lstat(dest); lerr == nil && li.Mode()&os.ModeSymlink != 0 {
- ret.Code = -1
- ret.Msg = "destination path is a symlink, which is not supported"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "destination path is a symlink, which is not supported")
}
if err := model.CopyFileWithDocumentAddressing(absSrc, dest); err != nil {
logging.LogErrorf("copy file [%s] to [%s] failed: %s", absSrc, dest, err)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
changedPaths = append(changedPaths, dest)
}
@@ -356,22 +299,17 @@ var workspaceCopyFiles = contractHandler(apicontract.WorkspaceCopyFiles, func(c
})
var copyFile = contractHandler(apicontract.CopyFile, func(c *gin.Context, request apicontract.CopyFileRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
src, dest := request.Src, request.Dest
if !filepath.IsAbs(dest) {
logging.LogErrorf("copy file dest [%s] is not an absolute path", dest)
- ret.Code = -1
- ret.Msg = "Field [dest]: path must be absolute"
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, "Field [dest]: path must be absolute", 5000)
}
src, err := model.GetAssetAbsPathInBox(src, "")
if err != nil {
logging.LogErrorf("get asset [%s] abs path failed: %s", src, err)
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 5000)
}
if util.IsPluginDevelopmentRawPathForbidden(src, true) || util.IsPluginDevelopmentRawPathForbidden(dest, true) {
return apicontract.Failure[apicontract.Null](http.StatusForbidden, "managed plugin development files require their dedicated tools")
@@ -384,46 +322,32 @@ var copyFile = contractHandler(apicontract.CopyFile, func(c *gin.Context, reques
// dest 在工作区外且非加密 box,允许解密后复制
boxID := model.ExtractBoxIDFromAssetsPath(src)
if err = holdEncryptedBoxRequest(c, boxID); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(314))
}
if err = copyDecryptedAsset(src, dest); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 5000)
}
return apicontract.Success(apicontract.Null{})
}
- ret.Code = -1
- ret.Msg = "copying encrypted notebook files is not supported via this API"
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, "copying encrypted notebook files is not supported via this API", 5000)
}
if err = prepareFileAssets(src); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 7000)
}
info, err := os.Stat(src)
if err != nil {
logging.LogErrorf("stat [%s] failed: %s", src, err)
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 5000)
}
if info.IsDir() {
- ret.Code = -1
- ret.Msg = "Field [src]: path is a directory"
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, "Field [src]: path is a directory", 5000)
}
if util.IsSensitivePath(dest) {
logging.LogErrorf("refuse to copy sensitive file [%s]", dest)
- ret.Code = -2
- ret.Msg = fmt.Sprintf("refuse to copy sensitive file [%s]", dest)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-2, fmt.Sprintf("refuse to copy sensitive file [%s]", dest))
}
if err = model.CheckDocumentAddressingFileCopies([]string{src}, []string{dest}); err != nil {
@@ -431,9 +355,7 @@ var copyFile = contractHandler(apicontract.CopyFile, func(c *gin.Context, reques
}
if err = model.CopyFileWithDocumentAddressing(src, dest); err != nil {
logging.LogErrorf("copy file [%s] to [%s] failed: %s", src, dest, err)
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 5000)
}
model.IncSyncIfNeeded(dest)
@@ -441,7 +363,6 @@ var copyFile = contractHandler(apicontract.CopyFile, func(c *gin.Context, reques
})
var getFile = contractHandler(apicontract.GetFile, func(c *gin.Context, request apicontract.FilePathRequest) apicontract.Response[apicontract.BinaryContent] {
- ret := gulu.Ret.NewResult()
filePath := request.Path
if !model.IsAdminRoleContext(c) {
c.Header("Cache-Control", "private, no-store")
@@ -464,31 +385,23 @@ var getFile = contractHandler(apicontract.GetFile, func(c *gin.Context, request
fileAbsPath, err := util.GetAbsPathInWorkspace(filePath)
if err != nil {
- ret.Code = http.StatusForbidden
- ret.Msg = err.Error()
- return contractFailure[apicontract.BinaryContent](ret)
+ return apicontract.Failure[apicontract.BinaryContent](http.StatusForbidden, err.Error())
}
// 加密笔记本的任何文件都不允许通过原始文件 API 读取(不只 .sy):
// 密文对插件无意义,且可能被误解析或泄漏;合法读取走专用 API(已加密感知)
if rejectEncryptedBoxPath(fileAbsPath) {
- ret.Code = -3
- ret.Msg = model.Conf.Language(321)
- return contractFailure[apicontract.BinaryContent](ret)
+ return apicontract.Failure[apicontract.BinaryContent](-3, model.Conf.Language(321))
}
// 解析符号链接(Windows 下含目录联接)后再做授权判断,防止 reader 通过 data/assets
// 等目录下的链接读取工作空间外的文件(security advisory GHSA-g7gf-v79m-jwrm)
resolvedPath, err := model.ResolveAssetPathWithMissingLeaf(fileAbsPath)
if err != nil {
logging.LogErrorf("resolve symlinks for [%s] failed: %s", fileAbsPath, err)
- ret.Code = http.StatusInternalServerError
- ret.Msg = http.StatusText(http.StatusInternalServerError) + errMsgSeeKernelLog
- return contractFailure[apicontract.BinaryContent](ret)
+ return apicontract.Failure[apicontract.BinaryContent](http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)+errMsgSeeKernelLog)
}
// 符号链接指向加密笔记本时同样拒绝读取,防止密文泄漏
if rejectEncryptedBoxPath(resolvedPath) {
- ret.Code = -3
- ret.Msg = model.Conf.Language(321)
- return contractFailure[apicontract.BinaryContent](ret)
+ return apicontract.Failure[apicontract.BinaryContent](-3, model.Conf.Language(321))
}
fileAbsPath = resolvedPath
if util.IsPluginDevelopmentRawPathForbidden(fileAbsPath, false) {
@@ -500,21 +413,17 @@ var getFile = contractHandler(apicontract.GetFile, func(c *gin.Context, request
// 符号链接解析后的真实路径必须仍位于工作空间内(admin 不受此限制,兼容 assets
// 指向工作空间外目录的合法用法),发布权限与敏感路径检查也基于解析后的路径执行
if !gulu.File.IsSubPath(util.NormalizeAndResolve(util.WorkspaceDir), util.NormalizeAndResolve(fileAbsPath)) {
- ret.Code = http.StatusForbidden
- ret.Msg = http.StatusText(http.StatusForbidden)
- return contractFailure[apicontract.BinaryContent](ret)
+ return apicontract.Failure[apicontract.BinaryContent](http.StatusForbidden, http.StatusText(http.StatusForbidden))
}
- if refuseToAccess(c, fileAbsPath, ret) {
- return contractFailure[apicontract.BinaryContent](ret)
+ if err := refuseToAccess(c, fileAbsPath); err != nil {
+ return apicontract.FailureFrom[apicontract.BinaryContent](err)
}
}
if model.IsReadOnlyRoleContext(c) {
publishAccess := model.GetPublishAccess()
if !model.CheckAbsPathAccessableByPublishAccess(c, fileAbsPath, publishAccess) {
- ret.Code = http.StatusForbidden
- ret.Msg = http.StatusText(http.StatusForbidden)
- return contractFailure[apicontract.BinaryContent](ret)
+ return apicontract.Failure[apicontract.BinaryContent](http.StatusForbidden, http.StatusText(http.StatusForbidden))
}
}
@@ -526,34 +435,28 @@ var getFile = contractHandler(apicontract.GetFile, func(c *gin.Context, request
return apicontract.Failure[apicontract.BinaryContent](http.StatusInternalServerError, relErr.Error())
}
if err = model.EnsureAssetLocal(filepath.Join(util.DataDir, rel)); err != nil {
- ret.Code = http.StatusServiceUnavailable
+ code := http.StatusServiceUnavailable
if os.IsNotExist(err) {
- ret.Code = http.StatusNotFound
+ code = http.StatusNotFound
}
- ret.Msg = err.Error()
- return contractFailure[apicontract.BinaryContent](ret)
+ return apicontract.Failure[apicontract.BinaryContent](code, err.Error())
}
}
info, err := os.Stat(fileAbsPath)
if err != nil {
- ret.Code = http.StatusInternalServerError
+ code := http.StatusInternalServerError
if os.IsNotExist(err) {
- ret.Code = http.StatusNotFound
+ code = http.StatusNotFound
}
- ret.Msg = err.Error()
- return contractFailure[apicontract.BinaryContent](ret)
+ return apicontract.Failure[apicontract.BinaryContent](code, err.Error())
}
if info.IsDir() {
- ret.Code = http.StatusConflict
- ret.Msg = "path is a directory"
- return contractFailure[apicontract.BinaryContent](ret)
+ return apicontract.Failure[apicontract.BinaryContent](http.StatusConflict, "path is a directory")
}
data, err := filelock.ReadFile(fileAbsPath)
if err != nil {
logging.LogErrorf("read file [%s] failed: %s", fileAbsPath, err)
- ret.Code = http.StatusInternalServerError
- ret.Msg = err.Error()
- return contractFailure[apicontract.BinaryContent](ret)
+ return apicontract.Failure[apicontract.BinaryContent](http.StatusInternalServerError, err.Error())
}
contentType := mime.TypeByExtension(filepath.Ext(fileAbsPath))
@@ -568,35 +471,30 @@ var getFile = contractHandler(apicontract.GetFile, func(c *gin.Context, request
return apicontract.SuccessBinary(contentType, data)
})
-func refuseToAccess(c *gin.Context, fileAbsPath string, ret *gulu.Result) bool {
+// refuseToAccess 判定该路径不可访问,返回 nil 表示允许。
+// 敏感文件与无发布访问权限的文件均以 HTTP 403 拒绝。
+func refuseToAccess(c *gin.Context, fileAbsPath string) error {
// 禁止访问敏感文件(conf 目录下的 conf.json 与 TLS 密钥材料、data/snippets/conf.json、
// data/templates、data/.siyuan/publishAccess.json),
// 规范化与符号链接解析见 util.NormalizeAndResolve,防止通过大小写或符号链接绕过
if util.IsForbiddenAbsPath(fileAbsPath) {
- ret.Code = http.StatusForbidden
- ret.Msg = http.StatusText(http.StatusForbidden)
- return true
+ return apicontract.RejectWith(http.StatusForbidden, http.StatusText(http.StatusForbidden))
}
// 禁止访问 无发布访问权限的文件
publishAccess := model.GetPublishAccess()
if !model.CheckAbsPathAccessableByPublishAccess(c, fileAbsPath, publishAccess) {
- ret.Code = http.StatusForbidden
- ret.Msg = http.StatusText(http.StatusForbidden)
- return true
+ return apicontract.RejectWith(http.StatusForbidden, http.StatusText(http.StatusForbidden))
}
- return false
+ return nil
}
var readDir = contractHandler(apicontract.ReadDirectory, func(c *gin.Context, request apicontract.ReadDirectoryRequest) apicontract.Response[[]apicontract.DirectoryEntry] {
- ret := gulu.Ret.NewResult()
dirPath := request.Path
dirAbsPath, err := util.GetAbsPathInWorkspace(dirPath)
if err != nil {
- ret.Code = http.StatusForbidden
- ret.Msg = err.Error()
- return contractFailure[[]apicontract.DirectoryEntry](ret)
+ return apicontract.Failure[[]apicontract.DirectoryEntry](http.StatusForbidden, err.Error())
}
// 加密笔记本的任何目录都不允许通过原始文件 API 枚举(不只 .sy):
// 目录结构、文档 ID、随机化资产名和时间戳可能泄漏信息;合法读取走专用 API(已加密感知)
@@ -604,35 +502,25 @@ var readDir = contractHandler(apicontract.ReadDirectory, func(c *gin.Context, re
return apicontract.Failure[[]apicontract.DirectoryEntry](http.StatusForbidden, "managed plugin development files require their dedicated tools")
}
if rejectEncryptedBoxPath(dirAbsPath) {
- ret.Code = -3
- ret.Msg = model.Conf.Language(321)
- return contractFailure[[]apicontract.DirectoryEntry](ret)
+ return apicontract.Failure[[]apicontract.DirectoryEntry](-3, model.Conf.Language(321))
}
info, err := os.Stat(dirAbsPath)
if os.IsNotExist(err) {
- ret.Code = http.StatusNotFound
- ret.Msg = "path does not exist"
- return contractFailure[[]apicontract.DirectoryEntry](ret)
+ return apicontract.Failure[[]apicontract.DirectoryEntry](http.StatusNotFound, "path does not exist")
}
if err != nil {
logging.LogErrorf("stat [%s] failed: %s", dirAbsPath, err)
- ret.Code = http.StatusInternalServerError
- ret.Msg = http.StatusText(http.StatusInternalServerError) + errMsgSeeKernelLog
- return contractFailure[[]apicontract.DirectoryEntry](ret)
+ return apicontract.Failure[[]apicontract.DirectoryEntry](http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)+errMsgSeeKernelLog)
}
if !info.IsDir() {
logging.LogErrorf("file [%s] is not a directory", dirAbsPath)
- ret.Code = http.StatusConflict
- ret.Msg = "path is not a directory"
- return contractFailure[[]apicontract.DirectoryEntry](ret)
+ return apicontract.Failure[[]apicontract.DirectoryEntry](http.StatusConflict, "path is not a directory")
}
entries, err := os.ReadDir(dirAbsPath)
if err != nil {
logging.LogErrorf("read dir [%s] failed: %s", dirAbsPath, err)
- ret.Code = http.StatusInternalServerError
- ret.Msg = http.StatusText(http.StatusInternalServerError) + errMsgSeeKernelLog
- return contractFailure[[]apicontract.DirectoryEntry](ret)
+ return apicontract.Failure[[]apicontract.DirectoryEntry](http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)+errMsgSeeKernelLog)
}
files := []apicontract.DirectoryEntry{}
@@ -644,9 +532,7 @@ var readDir = contractHandler(apicontract.ReadDirectory, func(c *gin.Context, re
info, err = os.Stat(path)
if err != nil {
logging.LogErrorf("stat [%s] failed: %s", path, err)
- ret.Code = http.StatusInternalServerError
- ret.Msg = http.StatusText(http.StatusInternalServerError) + errMsgSeeKernelLog
- return contractFailure[[]apicontract.DirectoryEntry](ret)
+ return apicontract.Failure[[]apicontract.DirectoryEntry](http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)+errMsgSeeKernelLog)
}
files = append(files, apicontract.DirectoryEntry{Name: entry.Name(), IsDir: info.IsDir(), IsSymlink: util.IsSymlink(entry), Updated: info.ModTime().Unix()})
}
@@ -655,56 +541,42 @@ var readDir = contractHandler(apicontract.ReadDirectory, func(c *gin.Context, re
})
var renameFile = contractHandler(apicontract.RenameFile, func(c *gin.Context, request apicontract.RenameFileRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
srcPath, destPath := request.Path, request.NewPath
srcAbsPath, err := util.GetAbsPathInWorkspace(srcPath)
if err != nil {
- ret.Code = http.StatusForbidden
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusForbidden, err.Error())
}
destAbsPath, err := util.GetAbsPathInWorkspace(destPath)
if err != nil {
- ret.Code = http.StatusForbidden
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusForbidden, err.Error())
}
// 加密笔记本的文件不允许通过原始文件 API 重命名(会破坏加密存储结构/跨 box 搬运密文)
if util.IsPluginDevelopmentRawPathForbidden(srcAbsPath, true) || util.IsPluginDevelopmentRawPathForbidden(destAbsPath, true) {
return apicontract.Failure[apicontract.Null](http.StatusForbidden, "managed plugin development files require their dedicated tools")
}
if rejectEncryptedBoxPath(srcAbsPath) || rejectEncryptedBoxPath(destAbsPath) {
- ret.Code = -3
- ret.Msg = model.Conf.Language(321)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-3, model.Conf.Language(321))
}
if err = prepareFileAssets(srcAbsPath); err == nil {
err = prepareFileAssets(destAbsPath)
}
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
srcInfo, srcStatErr := os.Stat(srcAbsPath)
if srcStatErr != nil {
- ret.Code = http.StatusInternalServerError
+ code := http.StatusInternalServerError
if os.IsNotExist(srcStatErr) {
- ret.Code = http.StatusNotFound
+ code = http.StatusNotFound
}
- ret.Msg = srcStatErr.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](code, srcStatErr.Error())
}
if filelock.IsExist(destAbsPath) {
- ret.Code = http.StatusConflict
- ret.Msg = "Field [newPath]: path already exists"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusConflict, "Field [newPath]: path already exists")
}
if srcInfo.IsDir() && gulu.File.IsSubPath(srcAbsPath, destAbsPath) {
- ret.Code = http.StatusConflict
- ret.Msg = "Field [newPath]: cannot rename a directory into its own subdirectory"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusConflict, "Field [newPath]: cannot rename a directory into its own subdirectory")
}
if err = model.CheckDocumentAddressingFileCopies([]string{srcAbsPath}, []string{destAbsPath}); err != nil {
return apicontract.Failure[apicontract.Null](-1, err.Error())
@@ -719,21 +591,15 @@ var renameFile = contractHandler(apicontract.RenameFile, func(c *gin.Context, re
parentInfo, statErr := os.Stat(destParent)
if statErr != nil {
logging.LogErrorf("stat [%s] failed: %s", destParent, statErr)
- ret.Code = http.StatusInternalServerError
- ret.Msg = http.StatusText(http.StatusInternalServerError) + errMsgSeeKernelLog
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)+errMsgSeeKernelLog)
}
if !parentInfo.IsDir() {
- ret.Code = http.StatusConflict
- ret.Msg = fmt.Sprintf("Field [newPath]: parent path [%s] is not a directory", filepath.Dir(destPath))
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusConflict, fmt.Sprintf("Field [newPath]: parent path [%s] is not a directory", filepath.Dir(destPath)))
}
} else {
if err = os.MkdirAll(destParent, 0755); err != nil {
logging.LogErrorf("make dir [%s] failed: %s", destParent, err)
- ret.Code = http.StatusInternalServerError
- ret.Msg = http.StatusText(http.StatusInternalServerError) + errMsgSeeKernelLog
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)+errMsgSeeKernelLog)
}
}
@@ -747,9 +613,7 @@ var renameFile = contractHandler(apicontract.RenameFile, func(c *gin.Context, re
return filelock.RenameWithoutFatal(srcAbsPath, destAbsPath)
}); err != nil {
logging.LogErrorf("rename file failed: %s", err)
- ret.Code = http.StatusInternalServerError
- ret.Msg = http.StatusText(http.StatusInternalServerError) + errMsgSeeKernelLog
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)+errMsgSeeKernelLog)
}
if affectsSync || model.PathsAffectSync(destAbsPath) {
@@ -759,46 +623,35 @@ var renameFile = contractHandler(apicontract.RenameFile, func(c *gin.Context, re
})
var removeFile = contractHandler(apicontract.RemoveFile, func(c *gin.Context, request apicontract.RemoveFileRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
app, filePath := request.App, request.Path
app = resolveRequestAppID(c, app)
fileAbsPath, err := util.GetAbsPathInWorkspace(filePath)
if err != nil {
- ret.Code = http.StatusForbidden
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusForbidden, err.Error())
}
// 加密笔记本的文件不允许通过原始文件 API 删除(破坏加密存储结构)
if util.IsPluginDevelopmentRawPathForbidden(fileAbsPath, true) {
return apicontract.Failure[apicontract.Null](http.StatusForbidden, "managed plugin development files require their dedicated tools")
}
if rejectEncryptedBoxPath(fileAbsPath) {
- ret.Code = -3
- ret.Msg = model.Conf.Language(321)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-3, model.Conf.Language(321))
}
if err = model.CheckDocumentAddressingFileRemoval(fileAbsPath); err != nil {
return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if model.CheckDocumentAddressingPath(fileAbsPath) == nil {
if err = prepareFileAssets(fileAbsPath); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
}
_, err = os.Stat(fileAbsPath)
if os.IsNotExist(err) {
- ret.Code = http.StatusNotFound
- ret.Msg = "path does not exist"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusNotFound, "path does not exist")
}
if err != nil {
logging.LogErrorf("stat [%s] failed: %s", fileAbsPath, err)
- ret.Code = http.StatusInternalServerError
- ret.Msg = http.StatusText(http.StatusInternalServerError) + errMsgSeeKernelLog
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)+errMsgSeeKernelLog)
}
affectsSync := model.PathsAffectSync(fileAbsPath)
@@ -809,9 +662,7 @@ var removeFile = contractHandler(apicontract.RemoveFile, func(c *gin.Context, re
return filelock.RemoveWithoutFatal(fileAbsPath)
}); err != nil {
logging.LogErrorf("remove [%s] failed: %s", fileAbsPath, err)
- ret.Code = http.StatusInternalServerError
- ret.Msg = http.StatusText(http.StatusInternalServerError) + errMsgSeeKernelLog
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)+errMsgSeeKernelLog)
}
model.PushPluginStorageDataChanged(fileAbsPath, app)
@@ -828,8 +679,6 @@ var putFile = contractHandler(apicontract.PutFile, func(c *gin.Context, request
putFileLock.Lock()
defer putFileLock.Unlock()
- ret := gulu.Ret.NewResult()
-
isDirStr := request.IsDir
isDir, _ := strconv.ParseBool(isDirStr)
app := resolveRequestAppID(c, request.App)
@@ -838,15 +687,11 @@ var putFile = contractHandler(apicontract.PutFile, func(c *gin.Context, request
filePath := request.Path
filePath = strings.TrimSpace(filePath)
if filePath == "" {
- ret.Code = http.StatusBadRequest
- ret.Msg = "path must not be empty"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusBadRequest, "path must not be empty")
}
fileAbsPath, err := util.GetAbsPathInWorkspace(filePath)
if err != nil {
- ret.Code = http.StatusForbidden
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusForbidden, err.Error())
}
// 加密笔记本的任何文件都不允许通过原始文件 API 写入(不只 .sy):
@@ -855,30 +700,22 @@ var putFile = contractHandler(apicontract.PutFile, func(c *gin.Context, request
}
// 明文写入会破坏密文格式或污染加密存储;合法写入走专用 API(已加密感知)
if rejectEncryptedBoxPath(fileAbsPath) {
- ret.Code = -3
- ret.Msg = model.Conf.Language(321)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-3, model.Conf.Language(321))
}
fileExists := filelock.IsExist(fileAbsPath)
if !fileExists {
if !util.IsValidUploadFileName(filepath.Base(fileAbsPath)) { // Improve kernel API `/api/file/putFile` parameter validation https://github.com/siyuan-note/siyuan/issues/14658
- ret.Code = http.StatusBadRequest
- ret.Msg = "invalid file path. For details, please check https://github.com/siyuan-note/siyuan/issues/14658"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusBadRequest, "invalid file path. For details, please check https://github.com/siyuan-note/siyuan/issues/14658")
}
} else {
info, statErr := os.Stat(fileAbsPath)
if statErr != nil {
logging.LogErrorf("stat file [%s] failed: %s", fileAbsPath, statErr)
- ret.Code = http.StatusInternalServerError
- ret.Msg = statErr.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusInternalServerError, statErr.Error())
}
if info.IsDir() && !isDir {
- ret.Code = http.StatusBadRequest
- ret.Msg = "path is a directory"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusBadRequest, "path is a directory")
}
}
@@ -894,9 +731,7 @@ var putFile = contractHandler(apicontract.PutFile, func(c *gin.Context, request
fileHeader := request.File
if nil == fileHeader {
logging.LogErrorf("form file is nil [path=%s]", fileAbsPath)
- ret.Code = http.StatusBadRequest
- ret.Msg = "Field [file] must not be empty"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusBadRequest, "Field [file] must not be empty")
}
for range 1 {
@@ -931,9 +766,7 @@ var putFile = contractHandler(apicontract.PutFile, func(c *gin.Context, request
}
}
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
modTimeStr := request.ModTime
@@ -942,17 +775,13 @@ var putFile = contractHandler(apicontract.PutFile, func(c *gin.Context, request
modTimeInt, parseErr := strconv.ParseInt(modTimeStr, 10, 64)
if nil != parseErr {
logging.LogErrorf("parse mod time [%s] failed: %s", modTimeStr, parseErr)
- ret.Code = http.StatusInternalServerError
- ret.Msg = parseErr.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusInternalServerError, parseErr.Error())
}
modTime = millisecond2Time(modTimeInt)
}
if err = os.Chtimes(fileAbsPath, modTime, modTime); err != nil {
logging.LogErrorf("change time failed: %s", err)
- ret.Code = http.StatusInternalServerError
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](http.StatusInternalServerError, err.Error())
}
if !isDir {
diff --git a/kernel/api/filetree.go b/kernel/api/filetree.go
index 5bc09b57ae..3938610478 100644
--- a/kernel/api/filetree.go
+++ b/kernel/api/filetree.go
@@ -43,18 +43,15 @@ var documentBaseNameReplacer = strings.NewReplacer("\r\n", "", "\r", "", "\n", "
var moveLocalShorthands = contractHandler(apicontract.MoveLocalShorthands, moveLocalShorthandsContract)
func moveLocalShorthandsContract(c *gin.Context, request apicontract.FileTreeNotebookRequest) apicontract.Response[[]string] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[[]string](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[[]string](err)
}
ids, err := model.MoveLocalShorthands(notebook)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]string](ret)
+ return apicontract.Failure[[]string](-1, err.Error())
}
return apicontract.Success(ids)
@@ -65,18 +62,14 @@ var listDocTree = contractHandler(apicontract.ListDocTree, listDocTreeContract)
func listDocTreeContract(c *gin.Context, request apicontract.FileTreePathRequest) apicontract.Response[apicontract.FileTreeDocTreeData] {
// Add kernel API `/api/filetree/listDocTree` https://github.com/siyuan-note/siyuan/issues/10482
- ret := gulu.Ret.NewResult()
-
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.FileTreeDocTreeData](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.FileTreeDocTreeData](err)
}
// 加密笔记本锁定时拒绝直接列举磁盘目录,防止泄漏文档 ID、层级和数量
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.FileTreeDocTreeData](ret)
+ return apicontract.Failure[apicontract.FileTreeDocTreeData](-1, model.Conf.Language(314))
}
if err := request.PathError(); err != nil {
@@ -87,22 +80,16 @@ func listDocTreeContract(c *gin.Context, request apicontract.FileTreePathRequest
// 越界校验:拒绝 ..,确保路径位于 <data>/<notebook>/ 内。
// 无需 filepath.IsAbs —— notebook 路径全为 notebook 内相对路径,且跨 OS 对 "/" 判定不一致。
if found := strings.Contains(p, ".."); found {
- ret.Code = -1
- ret.Msg = "path must not contain '..'"
- return contractFailure[apicontract.FileTreeDocTreeData](ret)
+ return apicontract.Failure[apicontract.FileTreeDocTreeData](-1, "path must not contain '..'")
}
var doctree []*DocFile
root := filepath.Join(util.WorkspaceDir, "data", notebook, p)
if !gulu.File.IsSubPath(filepath.Join(util.WorkspaceDir, "data", notebook), root) {
- ret.Code = -1
- ret.Msg = "path escapes notebook directory"
- return contractFailure[apicontract.FileTreeDocTreeData](ret)
+ return apicontract.Failure[apicontract.FileTreeDocTreeData](-1, "path escapes notebook directory")
}
dir, err := os.ReadDir(root)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.FileTreeDocTreeData](ret)
+ return apicontract.Failure[apicontract.FileTreeDocTreeData](-1, err.Error())
}
ids := map[string]bool{}
@@ -122,9 +109,7 @@ func listDocTreeContract(c *gin.Context, request apicontract.FileTreePathRequest
subPath := filepath.Join(root, entry.Name())
if err = walkDocTree(subPath, parent, ids); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.FileTreeDocTreeData](ret)
+ return apicontract.Failure[apicontract.FileTreeDocTreeData](-1, err.Error())
}
} else {
id := strings.TrimSuffix(entry.Name(), ".sy")
@@ -186,44 +171,37 @@ func walkDocTree(p string, docFile *DocFile, ids map[string]bool) (err error) {
var upsertIndexes = contractHandler(apicontract.UpsertIndexes, upsertIndexesContract)
func upsertIndexesContract(c *gin.Context, request apicontract.FileTreePathsRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
pathsArg := request.Paths
var paths []string
for _, p := range pathsArg {
paths = append(paths, p)
}
model.UpsertIndexes(paths)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var removeIndexes = contractHandler(apicontract.RemoveIndexes, removeIndexesContract)
func removeIndexesContract(c *gin.Context, request apicontract.FileTreePathsRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
pathsArg := request.Paths
var paths []string
for _, p := range pathsArg {
paths = append(paths, p)
}
model.RemoveIndexes(paths)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var doc2Heading = contractHandler(apicontract.Doc2Heading, doc2HeadingContract)
func doc2HeadingContract(c *gin.Context, request apicontract.FileTreeDocHeadingRequest) apicontract.Response[apicontract.FileTreeDocHeadingData] {
- ret := gulu.Ret.NewResult()
srcID := request.SrcID
targetID := request.TargetID
after := request.After
srcTreeBox, srcTreePath, err := model.Doc2Heading(srcID, targetID, after)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.FileTreeDocHeadingData](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.FileTreeDocHeadingData](-1, err.Error(), 5000)
}
return apicontract.Success(apicontract.FileTreeDocHeadingData{SrcTreeBox: srcTreeBox, SrcTreePath: srcTreePath})
@@ -232,16 +210,13 @@ func doc2HeadingContract(c *gin.Context, request apicontract.FileTreeDocHeadingR
var heading2Doc = contractHandler(apicontract.Heading2Doc, heading2DocContract)
func heading2DocContract(c *gin.Context, request apicontract.FileTreeHeadingDocRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
srcHeadingID := request.SrcHeadingID
targetNotebook := request.TargetNotebook
// 禁止跨加密笔记本移动块:加密笔记本是孤岛
if bt := treenode.GetBlockTree(srcHeadingID); bt != nil && model.IsEncryptedBox(bt.BoxID) && bt.BoxID != targetNotebook {
- ret.Code = -1
- ret.Msg = model.Conf.Language(391)
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, model.Conf.Language(391), 5000)
}
options, err := request.Options()
if err != nil {
@@ -250,9 +225,7 @@ func heading2DocContract(c *gin.Context, request apicontract.FileTreeHeadingDocR
targetPath, previousPath, toTop := options.TargetPath, options.PreviousPath, options.ToTop
srcRootBlockID, targetPath, err := model.Heading2Doc(srcHeadingID, targetNotebook, targetPath, previousPath, toTop)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 5000)
}
model.FlushTxQueue()
@@ -265,22 +238,19 @@ func heading2DocContract(c *gin.Context, request apicontract.FileTreeHeadingDocR
"srcRootBlockID": srcRootBlockID,
}
util.PushEvent(evt)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var li2Doc = contractHandler(apicontract.Li2Doc, li2DocContract)
func li2DocContract(c *gin.Context, request apicontract.FileTreeListItemDocRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
srcListItemID := request.SrcListItemID
targetNotebook := request.TargetNotebook
// 禁止跨加密笔记本移动块:加密笔记本是孤岛
if bt := treenode.GetBlockTree(srcListItemID); bt != nil && model.IsEncryptedBox(bt.BoxID) && bt.BoxID != targetNotebook {
- ret.Code = -1
- ret.Msg = model.Conf.Language(391)
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, model.Conf.Language(391), 5000)
}
options, err := request.Options()
@@ -290,9 +260,7 @@ func li2DocContract(c *gin.Context, request apicontract.FileTreeListItemDocReque
targetPath, previousPath, toTop := options.TargetPath, options.PreviousPath, options.ToTop
srcRootBlockID, targetPath, err := model.ListItem2Doc(srcListItemID, targetNotebook, targetPath, previousPath, toTop)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 5000)
}
model.FlushTxQueue()
@@ -305,34 +273,29 @@ func li2DocContract(c *gin.Context, request apicontract.FileTreeListItemDocReque
"srcRootBlockID": srcRootBlockID,
}
util.PushEvent(evt)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var getHPathByPath = contractHandler(apicontract.GetHPathByPath, getHPathByPathContract)
func getHPathByPathContract(c *gin.Context, request apicontract.FileTreePathRequest) apicontract.Response[string] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[string](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[string](err)
}
p := request.Path
hPath, err := model.GetHPathByPath(notebook, p)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[string](ret)
+ return apicontract.Failure[string](-1, err.Error())
}
if p != "/" && model.IsReadOnlyRoleContext(c) {
publishAccess := model.GetPublishAccess()
id := util.GetTreeID(p)
if !model.CheckBlockIdMetadataAccessableByPublishAccessInBox(c, publishAccess, id, notebook) {
- ret.Code = -1
- ret.Msg = model.ErrBlockNotFound.Error()
- return contractFailure[string](ret)
+ return apicontract.Failure[string](-1, model.ErrBlockNotFound.Error())
}
}
return apicontract.Success(hPath)
@@ -341,7 +304,6 @@ func getHPathByPathContract(c *gin.Context, request apicontract.FileTreePathRequ
var getHPathsByPaths = contractHandler(apicontract.GetHPathsByPaths, getHPathsByPathsContract)
func getHPathsByPathsContract(c *gin.Context, request apicontract.FileTreePathsRequest) apicontract.Response[[]string] {
- ret := gulu.Ret.NewResult()
pathsArg := request.Paths
var paths []string
@@ -351,9 +313,7 @@ func getHPathsByPathsContract(c *gin.Context, request apicontract.FileTreePathsR
paths = filterFileTreePathsByPublishMetadataAccess(c, paths)
hPath, err := model.GetHPathsByPaths(paths)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]string](ret)
+ return apicontract.Failure[[]string](-1, err.Error())
}
return apicontract.Success(hPath)
}
@@ -361,25 +321,20 @@ func getHPathsByPathsContract(c *gin.Context, request apicontract.FileTreePathsR
var getHPathByID = contractHandler(apicontract.GetHPathByID, getHPathByIDContract)
func getHPathByIDContract(c *gin.Context, request apicontract.FileTreeIDRequest) apicontract.Response[string] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[string](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[string](err)
}
hPath, err := model.GetHPathByID(id)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[string](ret)
+ return apicontract.Failure[string](-1, err.Error())
}
if model.IsReadOnlyRoleContext(c) {
publishAccess := model.GetPublishAccess()
if !model.CheckBlockIdMetadataAccessableByPublishAccess(c, publishAccess, id) {
- ret.Code = -1
- ret.Msg = model.ErrTreeNotFound.Error()
- return contractFailure[string](ret)
+ return apicontract.Failure[string](-1, model.ErrTreeNotFound.Error())
}
}
return apicontract.Success(hPath)
@@ -388,25 +343,20 @@ func getHPathByIDContract(c *gin.Context, request apicontract.FileTreeIDRequest)
var getPathByID = contractHandler(apicontract.GetPathByID, getPathByIDContract)
func getPathByIDContract(c *gin.Context, request apicontract.FileTreeTrimIDRequest) apicontract.Response[apicontract.FileTreeDocPathData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.FileTreeDocPathData](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.FileTreeDocPathData](err)
}
p, notebook, err := model.GetPathByID(id)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.FileTreeDocPathData](ret)
+ return apicontract.Failure[apicontract.FileTreeDocPathData](-1, err.Error())
}
if model.IsReadOnlyRoleContext(c) {
publishAccess := model.GetPublishAccess()
if !model.CheckBlockIdMetadataAccessableByPublishAccessInBox(c, publishAccess, id, notebook) {
- ret.Code = -1
- ret.Msg = model.ErrTreeNotFound.Error()
- return contractFailure[apicontract.FileTreeDocPathData](ret)
+ return apicontract.Failure[apicontract.FileTreeDocPathData](-1, model.ErrTreeNotFound.Error())
}
}
return apicontract.Success(apicontract.FileTreeDocPathData{Path: p, Notebook: notebook})
@@ -415,28 +365,22 @@ func getPathByIDContract(c *gin.Context, request apicontract.FileTreeTrimIDReque
var getFullHPathByID = contractHandler(apicontract.GetFullHPathByID, getFullHPathByIDContract)
func getFullHPathByIDContract(c *gin.Context, request apicontract.FileTreeOptionalIDRequest) apicontract.Response[*string] {
- ret := gulu.Ret.NewResult()
-
if request.ID == nil {
- return contractFailure[*string](ret)
+ return apicontract.SuccessWithoutData[*string]()
}
id := *request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[*string](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[*string](err)
}
hPath, err := model.GetFullHPathByID(id)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[*string](ret)
+ return apicontract.Failure[*string](-1, err.Error())
}
if model.IsReadOnlyRoleContext(c) {
publishAccess := model.GetPublishAccess()
if !model.CheckBlockIdMetadataAccessableByPublishAccess(c, publishAccess, id) {
- ret.Code = -1
- ret.Msg = model.ErrTreeNotFound.Error()
- return contractFailure[*string](ret)
+ return apicontract.Failure[*string](-1, model.ErrTreeNotFound.Error())
}
}
return apicontract.Success(&hPath)
@@ -445,18 +389,16 @@ func getFullHPathByIDContract(c *gin.Context, request apicontract.FileTreeOption
var getIDsByHPath = contractHandler(apicontract.GetIDsByHPath, getIDsByHPathContract)
func getIDsByHPathContract(c *gin.Context, request apicontract.FileTreeOptionalPathRequest) apicontract.Response[apicontract.LegacyPathIDsResult] {
- ret := gulu.Ret.NewResult()
-
if request.Path == nil {
- return contractFailure[apicontract.LegacyPathIDsResult](ret)
+ return apicontract.SuccessWithoutData[apicontract.LegacyPathIDsResult]()
}
if request.Notebook == nil {
- return contractFailure[apicontract.LegacyPathIDsResult](ret)
+ return apicontract.SuccessWithoutData[apicontract.LegacyPathIDsResult]()
}
notebook := *request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.LegacyPathIDsResult](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.LegacyPathIDsResult](err)
}
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
@@ -472,9 +414,7 @@ func getIDsByHPathContract(c *gin.Context, request apicontract.FileTreeOptionalP
UnsupportedIDs: filterFileTreeBlockIDsByPublishDiscoverability(c, failure.UnsupportedIDs, notebook)}
return apicontract.GetIDsByHPath.FailureWithData(-1, err.Error(), apicontract.NewLegacyPathIDsFailure(data))
}
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.LegacyPathIDsResult](ret)
+ return apicontract.Failure[apicontract.LegacyPathIDsResult](-1, err.Error())
}
ids = filterFileTreeBlockIDsByPublishDiscoverability(c, ids, notebook)
return apicontract.Success(apicontract.NewLegacyPathIDs(ids))
@@ -519,7 +459,6 @@ func filterFileTreeBlockIDsByPublishDiscoverability(c *gin.Context, ids []string
var moveDocs = contractHandler(apicontract.MoveDocs, moveDocsContract)
func moveDocsContract(c *gin.Context, request apicontract.FileTreeMoveRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
var fromPaths []string
fromPathsArg := request.FromPaths
@@ -528,45 +467,40 @@ func moveDocsContract(c *gin.Context, request apicontract.FileTreeMoveRequest) a
}
toPath := request.ToPath
toNotebook := request.ToNotebook
- if util.InvalidIDPattern(toNotebook, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(toNotebook); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
callback := fileTreeCallback(request.Callback)
err := model.MoveDocs(fromPaths, toNotebook, toPath, callback)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 7000)
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var moveDocsByID = contractHandler(apicontract.MoveDocsByID, moveDocsByIDContract)
func moveDocsByIDContract(c *gin.Context, request apicontract.FileTreeMoveIDsRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
fromIDsArg := request.FromIDs
var fromIDs []string
for _, fromIDArg := range fromIDsArg {
fromID := fromIDArg
- if util.InvalidIDPattern(fromID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(fromID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
fromIDs = append(fromIDs, fromID)
}
toID := request.ToID
- if util.InvalidIDPattern(toID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(toID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
var fromPaths []string
for _, fromID := range fromIDs {
tree, err := model.LoadTreeByBlockID(fromID)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 7000)
}
fromPaths = append(fromPaths, tree.Path)
}
@@ -577,9 +511,7 @@ func moveDocsByIDContract(c *gin.Context, request apicontract.FileTreeMoveIDsReq
if err != nil {
box = model.Conf.Box(toID)
if nil == box {
- ret.Code = -1
- ret.Msg = "can't found box or tree by id [" + toID + "]"
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, "can't found box or tree by id ["+toID+"]", 7000)
}
}
@@ -594,59 +526,50 @@ func moveDocsByIDContract(c *gin.Context, request apicontract.FileTreeMoveIDsReq
callback := fileTreeCallback(request.Callback)
err = model.MoveDocs(fromPaths, toNotebook, toPath, callback)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 7000)
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var removeDoc = contractHandler(apicontract.RemoveDoc, removeDocContract)
func removeDocContract(c *gin.Context, request apicontract.FileTreePathRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
p := request.Path
if err := model.RemoveDoc(notebook, p); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Success(apicontract.Null{})
}
var removeDocByID = contractHandler(apicontract.RemoveDocByID, removeDocByIDContract)
func removeDocByIDContract(c *gin.Context, request apicontract.FileTreeTrimIDRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
p, notebook, err := model.GetPathByID(id)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 7000)
}
if err = model.RemoveDoc(notebook, p); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Success(apicontract.Null{})
}
var removeDocs = contractHandler(apicontract.RemoveDocs, removeDocsContract)
func removeDocsContract(c *gin.Context, request apicontract.FileTreePathsRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
pathsArg := request.Paths
var paths []string
@@ -654,20 +577,17 @@ func removeDocsContract(c *gin.Context, request apicontract.FileTreePathsRequest
paths = append(paths, path)
}
if err := model.RemoveDocs(paths); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Success(apicontract.Null{})
}
var renameDoc = contractHandler(apicontract.RenameDoc, renameDocContract)
func renameDocContract(c *gin.Context, request apicontract.FileTreeRenameRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
p := request.Path
@@ -675,25 +595,21 @@ func renameDocContract(c *gin.Context, request apicontract.FileTreeRenameRequest
err := model.RenameDoc(notebook, p, title)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var renameDocByID = contractHandler(apicontract.RenameDocByID, renameDocByIDContract)
func renameDocByIDContract(c *gin.Context, request apicontract.FileTreeRenameIDRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
if request.ID == nil {
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
id := *request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
title, decodeErr := request.DocTitle()
@@ -703,18 +619,14 @@ func renameDocByIDContract(c *gin.Context, request apicontract.FileTreeRenameIDR
tree, err := model.LoadTreeByBlockID(id)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 7000)
}
err = model.RenameDoc(tree.Box, tree.Path, title)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var duplicateDoc = contractHandler(apicontract.DuplicateDoc, duplicateDocContract)
@@ -733,14 +645,11 @@ func duplicateDocTreeContract(c *gin.Context, request apicontract.FileTreeIDRequ
}
func duplicateDocContract(c *gin.Context, request apicontract.FileTreeIDRequest) apicontract.Response[apicontract.FileTreeDuplicateData] {
- ret := gulu.Ret.NewResult()
id := request.ID
tree, err := model.LoadTreeByBlockID(id)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.FileTreeDuplicateData](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.FileTreeDuplicateData](-1, err.Error(), 7000)
}
notebook := tree.Box
@@ -754,7 +663,6 @@ func duplicateDocContract(c *gin.Context, request apicontract.FileTreeIDRequest)
var createDoc = contractHandler(apicontract.CreateDoc, createDocContract)
func createDocContract(c *gin.Context, request apicontract.FileTreeCreateRequest) apicontract.Response[apicontract.FileTreeCreateData] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
p := request.Path
@@ -763,9 +671,7 @@ func createDocContract(c *gin.Context, request apicontract.FileTreeCreateRequest
sorts := append([]string(nil), request.Sorts...)
tree, err := model.CreateDocByMd(notebook, p, title, md, sorts, fileTreeCreateContext(request.FileTreeCreateOptions))
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.FileTreeCreateData](ret.Code, ret.Msg, 7000)
+ return apicontract.FailureWithTimeout[apicontract.FileTreeCreateData](-1, err.Error(), 7000)
}
return apicontract.Success(apicontract.FileTreeCreateData{ID: tree.Root.ID})
@@ -774,7 +680,6 @@ func createDocContract(c *gin.Context, request apicontract.FileTreeCreateRequest
var createDailyNote = contractHandler(apicontract.CreateDailyNote, createDailyNoteContract)
func createDailyNoteContract(c *gin.Context, request apicontract.FileTreeDailyNoteRequest) apicontract.Response[apicontract.FileTreeCreateData] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
@@ -793,13 +698,11 @@ func createDailyNoteContract(c *gin.Context, request apicontract.FileTreeDailyNo
}
}
if err != nil {
+ code := -1
if errors.Is(err, model.ErrBoxNotFound) {
- ret.Code = 1
- } else {
- ret.Code = -1
+ code = 1
}
- ret.Msg = err.Error()
- return contractFailure[apicontract.FileTreeCreateData](ret)
+ return apicontract.Failure[apicontract.FileTreeCreateData](code, err.Error())
}
model.FlushTxQueue()
@@ -807,9 +710,7 @@ func createDailyNoteContract(c *gin.Context, request apicontract.FileTreeDailyNo
luteEngine := util.NewLute()
tree, err := filesys.LoadTree(box.ID, p, luteEngine)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.FileTreeCreateData](ret)
+ return apicontract.Failure[apicontract.FileTreeCreateData](-1, err.Error())
}
if !existed {
@@ -834,11 +735,10 @@ func createDailyNoteContract(c *gin.Context, request apicontract.FileTreeDailyNo
var createDocWithMd = contractHandler(apicontract.CreateDocWithMd, createDocWithMdContract)
func createDocWithMdContract(c *gin.Context, request apicontract.FileTreeCreateMarkdownRequest) apicontract.Response[apicontract.LegacyPathDocumentResult] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.LegacyPathDocumentResult](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.LegacyPathDocumentResult](err)
}
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
@@ -875,9 +775,7 @@ func createDocWithMdContract(c *gin.Context, request apicontract.FileTreeCreateM
UnsupportedIDs: filterFileTreeBlockIDsByPublishDiscoverability(c, failure.UnsupportedIDs, notebook)}
return apicontract.CreateDocWithMd.FailureWithData(-1, err.Error(), apicontract.NewLegacyPathDocumentFailure(data))
}
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.LegacyPathDocumentResult](ret)
+ return apicontract.Failure[apicontract.LegacyPathDocumentResult](-1, err.Error())
}
return apicontract.Success(apicontract.NewLegacyPathDocument(id))
}
@@ -885,7 +783,6 @@ func createDocWithMdContract(c *gin.Context, request apicontract.FileTreeCreateM
var getDocCreateSavePath = contractHandler(apicontract.GetDocCreateSavePath, getDocCreateSavePathContract)
func getDocCreateSavePathContract(c *gin.Context, request apicontract.FileTreeNotebookRequest) apicontract.Response[apicontract.FileTreeCreateSavePathResult] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
if model.Conf.Box(notebook) != nil {
@@ -922,9 +819,7 @@ func getDocCreateSavePathContract(c *gin.Context, request apicontract.FileTreeNo
docCreateSavePath, err := model.RenderGoTemplateInBox(docCreateSavePathTpl, docCreateSaveBox)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.FileTreeCreateSavePathResult](ret)
+ return apicontract.Failure[apicontract.FileTreeCreateSavePathResult](-1, err.Error())
}
return apicontract.Success(apicontract.NewFileTreeCreateSavePathResult(apicontract.FileTreeCreateSavePathData{FileTreeSavePathData: apicontract.FileTreeSavePathData{Box: docCreateSaveBox, Path: docCreateSavePath}, DocCreateTemplatePath: docCreateTemplatePath}))
@@ -935,8 +830,6 @@ var getRefCreateSavePath = contractHandler(apicontract.GetRefCreateSavePath, get
func getRefCreateSavePathContract(c *gin.Context, request apicontract.FileTreeNotebookRequest) apicontract.Response[apicontract.FileTreeSavePathResult] {
confFileTreeSnapshot := model.Conf.LoadFileTree()
- ret := gulu.Ret.NewResult()
-
notebook := request.Notebook
if model.Conf.Box(notebook) != nil {
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
@@ -986,9 +879,7 @@ func getRefCreateSavePathContract(c *gin.Context, request apicontract.FileTreeNo
refCreateSavePath, err := model.RenderGoTemplateInBox(refCreateSavePathTpl, refCreateSaveBox)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.FileTreeSavePathResult](ret)
+ return apicontract.Failure[apicontract.FileTreeSavePathResult](-1, err.Error())
}
return apicontract.Success(apicontract.NewFileTreeSavePathResult(apicontract.FileTreeSavePathData{Box: refCreateSaveBox, Path: refCreateSavePath}))
}
@@ -998,8 +889,6 @@ var getShorthandSavePath = contractHandler(apicontract.GetShorthandSavePath, get
func getShorthandSavePathContract(c *gin.Context, request apicontract.FileTreeNotebookRequest) apicontract.Response[apicontract.FileTreeSavePathData] {
confFileTreeSnapshot := model.Conf.LoadFileTree()
- ret := gulu.Ret.NewResult()
-
notebook := request.Notebook
shorthandSaveBox := confFileTreeSnapshot.ShorthandSaveBox
@@ -1009,9 +898,7 @@ func getShorthandSavePathContract(c *gin.Context, request apicontract.FileTreeNo
shorthandSaveBox = notebook
}
if !model.IsShorthandSaveBoxAvailable(shorthandSaveBox) {
- ret.Code = -1
- ret.Msg = model.Conf.Language(375)
- return contractFailure[apicontract.FileTreeSavePathData](ret)
+ return apicontract.Failure[apicontract.FileTreeSavePathData](-1, model.Conf.Language(375))
}
if shorthandSaveBox != notebook {
@@ -1022,9 +909,7 @@ func getShorthandSavePathContract(c *gin.Context, request apicontract.FileTreeNo
shorthandSavePath, err := model.RenderGoTemplateInBox(shorthandSavePathTpl, shorthandSaveBox)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.FileTreeSavePathData](ret)
+ return apicontract.Failure[apicontract.FileTreeSavePathData](-1, err.Error())
}
return apicontract.Success(apicontract.FileTreeSavePathData{Box: shorthandSaveBox, Path: shorthandSavePath})
}
@@ -1032,8 +917,6 @@ func getShorthandSavePathContract(c *gin.Context, request apicontract.FileTreeNo
var changeSort = contractHandler(apicontract.ChangeSort, changeSortContract)
func changeSortContract(c *gin.Context, request apicontract.FileTreeChangeSortRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
notebook := request.Notebook
pathsArg := request.Paths
var paths []string
@@ -1041,16 +924,14 @@ func changeSortContract(c *gin.Context, request apicontract.FileTreeChangeSortRe
paths = append(paths, p)
}
model.ChangeFileTreeSort(notebook, paths)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var reorderDocs = contractHandler(apicontract.ReorderDocs, reorderDocsContract)
func reorderDocsContract(c *gin.Context, request apicontract.FileTreeReorderRequest) apicontract.Response[*apicontract.FileTreeReorderData] {
- ret := gulu.Ret.NewResult()
-
- if !validateReorderRequest(request.SourceIDs, request.TargetID, request.Position, ret) {
- return contractFailure[*apicontract.FileTreeReorderData](ret)
+ if err := validateReorderRequest(request.SourceIDs, request.TargetID, request.Position); err != nil {
+ return apicontract.FailureFrom[*apicontract.FileTreeReorderData](err)
}
if request.RespectSort {
@@ -1070,38 +951,30 @@ func reorderDocsContract(c *gin.Context, request apicontract.FileTreeReorderRequ
return apicontract.Success(data)
}
-func validateReorderRequest(sourceIDs []string, targetID, position string, ret *gulu.Result) bool {
+func validateReorderRequest(sourceIDs []string, targetID, position string) error {
if 1 > len(sourceIDs) {
- ret.Code = -1
- ret.Msg = "Field [sourceIDs] must not be empty"
- return false
+ return apicontract.Reject("Field [sourceIDs] must not be empty")
}
- if util.InvalidIDPattern(targetID, ret) {
- return false
+ if err := util.ValidateID(targetID); err != nil {
+ return err
}
if "before" != position && "after" != position {
- ret.Code = -1
- ret.Msg = "Field [position] must be [before] or [after]"
- return false
+ return apicontract.Reject("Field [position] must be [before] or [after]")
}
ids := map[string]struct{}{}
for i, sourceID := range sourceIDs {
- if util.InvalidIDPattern(sourceID, ret) {
- return false
+ if err := util.ValidateID(sourceID); err != nil {
+ return err
}
if sourceID == targetID {
- ret.Code = -1
- ret.Msg = fmt.Sprintf("Field [targetID] must not be included in [sourceIDs] at index [%d]", i)
- return false
+ return apicontract.Reject(fmt.Sprintf("Field [targetID] must not be included in [sourceIDs] at index [%d]", i))
}
if _, exists := ids[sourceID]; exists {
- ret.Code = -1
- ret.Msg = fmt.Sprintf("Field [sourceIDs] contains duplicate ID [%s]", sourceID)
- return false
+ return apicontract.Reject(fmt.Sprintf("Field [sourceIDs] contains duplicate ID [%s]", sourceID))
}
ids[sourceID] = struct{}{}
}
- return true
+ return nil
}
type sortRequestItem = apicontract.FileTreeSortItem
@@ -1109,20 +982,17 @@ type sortRequestItem = apicontract.FileTreeSortItem
var setSort = contractHandler(apicontract.SetSort, setSortContract)
func setSortContract(c *gin.Context, request apicontract.FileTreeSetSortRequest) apicontract.Response[*apicontract.FileTreeSetSortData] {
- ret := gulu.Ret.NewResult()
-
if 1 > len(request.NotebookSorts)+len(request.DocSorts) {
- ret.Code = -1
- ret.Msg = "Fields [notebookSorts] and [docSorts] must not both be empty"
- return contractFailure[*apicontract.FileTreeSetSortData](ret)
+ return apicontract.Failure[*apicontract.FileTreeSetSortData](-1,
+ "Fields [notebookSorts] and [docSorts] must not both be empty")
}
- notebookSorts, ok := parseSortItems("notebookSorts", request.NotebookSorts, ret)
- if !ok {
- return contractFailure[*apicontract.FileTreeSetSortData](ret)
+ notebookSorts, err := parseSortItems("notebookSorts", request.NotebookSorts)
+ if err != nil {
+ return apicontract.FailureFrom[*apicontract.FileTreeSetSortData](err)
}
- docSorts, ok := parseSortItems("docSorts", request.DocSorts, ret)
- if !ok {
- return contractFailure[*apicontract.FileTreeSetSortData](ret)
+ docSorts, err := parseSortItems("docSorts", request.DocSorts)
+ if err != nil {
+ return apicontract.FailureFrom[*apicontract.FileTreeSetSortData](err)
}
result, err := model.SetFileTreeSort(notebookSorts, docSorts)
@@ -1136,10 +1006,9 @@ func setSortContract(c *gin.Context, request apicontract.FileTreeSetSortRequest)
var setDocSortMode = contractHandler(apicontract.SetDocSortMode, setDocSortModeContract)
func setDocSortModeContract(c *gin.Context, request apicontract.FileTreeSortModeRequest) apicontract.Response[*apicontract.FileTreeSortModeData] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.ID, ret) {
- return contractFailure[*apicontract.FileTreeSortModeData](ret)
+ if err := util.ValidateID(request.ID); err != nil {
+ return apicontract.FailureFrom[*apicontract.FileTreeSortModeData](err)
}
sortMode, decodeErr := request.Mode()
if decodeErr != nil {
@@ -1153,31 +1022,25 @@ func setDocSortModeContract(c *gin.Context, request apicontract.FileTreeSortMode
return apicontract.Success(data)
}
-func parseSortItems(field string, items []*sortRequestItem, ret *gulu.Result) (retItems []*model.SortItem, ok bool) {
+func parseSortItems(field string, items []*sortRequestItem) (retItems []*model.SortItem, err error) {
ids := map[string]struct{}{}
for i, item := range items {
if nil == item {
- ret.Code = -1
- ret.Msg = fmt.Sprintf("Field [%s][%d] must not be null", field, i)
- return
+ return nil, apicontract.Reject(fmt.Sprintf("Field [%s][%d] must not be null", field, i))
}
- if util.InvalidIDPattern(item.ID, ret) {
- return
+ if err := util.ValidateID(item.ID); err != nil {
+ return nil, err
}
if nil == item.Sort {
- ret.Code = -1
- ret.Msg = fmt.Sprintf("Field [%s][%d].sort is required", field, i)
- return
+ return nil, apicontract.Reject(fmt.Sprintf("Field [%s][%d].sort is required", field, i))
}
if _, ok := ids[item.ID]; ok {
- ret.Code = -1
- ret.Msg = fmt.Sprintf("Field [%s] contains duplicate ID [%s]", field, item.ID)
- return nil, false
+ return nil, apicontract.Reject(fmt.Sprintf("Field [%s] contains duplicate ID [%s]", field, item.ID))
}
ids[item.ID] = struct{}{}
retItems = append(retItems, &model.SortItem{ID: item.ID, Sort: *item.Sort})
}
- return retItems, true
+ return retItems, nil
}
var searchDocs = contractHandler(apicontract.SearchDocs, searchDocsContract)
@@ -1200,16 +1063,12 @@ var listDocsByPath = contractHandler(apicontract.ListDocsByPath, listDocsByPathC
func listDocsByPathContract(c *gin.Context, request apicontract.FileTreeListRequest) apicontract.Response[apicontract.FileTreeListData] {
confFileTreeSnapshot := model.Conf.LoadFileTree()
- ret := gulu.Ret.NewResult()
-
notebook := request.Notebook
p := request.Path
// 越界校验:拒绝 ..,确保路径位于 <data>/<notebook>/ 内
if strings.Contains(p, "..") {
- ret.Code = -1
- ret.Msg = "path must not contain '..' and must be relative"
- return contractFailure[apicontract.FileTreeListData](ret)
+ return apicontract.Failure[apicontract.FileTreeListData](-1, "path must not contain '..' and must be relative")
}
if isEncryptedNotebookDeniedForPublish(c, notebook) {
@@ -1230,9 +1089,7 @@ func listDocsByPathContract(c *gin.Context, request apicontract.FileTreeListRequ
var resolveErr error
effectiveSortMode, resolveErr = model.ResolveDocTreeSortMode(notebook, p)
if nil != resolveErr {
- ret.Code = -1
- ret.Msg = resolveErr.Error()
- return contractFailure[apicontract.FileTreeListData](ret)
+ return apicontract.Failure[apicontract.FileTreeListData](-1, resolveErr.Error())
}
}
flashcard := options.Flashcard
@@ -1248,9 +1105,7 @@ func listDocsByPathContract(c *gin.Context, request apicontract.FileTreeListRequ
files, totals, err := model.ListDocTree(notebook, p, effectiveSortMode, flashcard, showHidden, maxListCount)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.FileTreeListData](ret)
+ return apicontract.Failure[apicontract.FileTreeListData](-1, err.Error())
}
// 过滤掉发布不可见的文件
if model.IsReadOnlyRoleContext(c) {
@@ -1289,23 +1144,19 @@ func listDocsByPathContract(c *gin.Context, request apicontract.FileTreeListRequ
var getDoc = contractHandler(apicontract.GetDoc, getDocContract)
func getDocContract(c *gin.Context, request apicontract.FileTreeGetDocRequest) apicontract.Response[apicontract.FileTreeGetDocData] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.FileTreeGetDocData](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.FileTreeGetDocData](err)
}
requestedNotebook := request.Notebook
if model.IsReadOnlyRoleContext(c) &&
((requestedNotebook != "" && model.IsEncryptedBoxDeniedByPublishAccess(requestedNotebook)) ||
model.IsEncryptedPublishRuntimeTarget(id)) {
- ret.Code = 3
- return contractFailure[apicontract.FileTreeGetDocData](ret)
+ return apicontract.Failure[apicontract.FileTreeGetDocData](3, "")
}
if err := holdEncryptedBoxRequest(c, requestedNotebook); err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return contractFailure[apicontract.FileTreeGetDocData](ret)
+ return apicontract.Failure[apicontract.FileTreeGetDocData](1, err.Error())
}
options, decodeErr := request.Options()
if decodeErr != nil {
@@ -1354,14 +1205,11 @@ func getDocContract(c *gin.Context, request apicontract.FileTreeGetDocRequest) a
model.GetDoc(startID, endID, id, index, query, queryTypes, querySubTypes, queryMethod, mode, size, isBacklink, originalRefBlockIDs, highlight, includeDocInfo)
}
if errors.Is(err, model.ErrBlockNotFound) {
- ret.Code = 3
- return contractFailure[apicontract.FileTreeGetDocData](ret)
+ return apicontract.Failure[apicontract.FileTreeGetDocData](3, "")
}
if err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return contractFailure[apicontract.FileTreeGetDocData](ret)
+ return apicontract.Failure[apicontract.FileTreeGetDocData](1, err.Error())
}
// 判断是否正在同步中 https://github.com/siyuan-note/siyuan/issues/6290
@@ -1399,14 +1247,11 @@ func getDocContract(c *gin.Context, request apicontract.FileTreeGetDocRequest) a
var setPublishAccess = contractHandler(apicontract.SetPublishAccess, setPublishAccessContract)
func setPublishAccessContract(c *gin.Context, request apicontract.FileTreeSetPublishRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
publishAccess := model.GetPublishAccess()
ID := request.ID
if model.IsEncryptedPublishAccessTarget(ID) {
- ret.Code = -1
- ret.Msg = model.Conf.Language(394)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(394))
}
options, err := request.Options()
if err != nil {
@@ -1446,28 +1291,23 @@ func setPublishAccessContract(c *gin.Context, request apicontract.FileTreeSetPub
if updated {
err := model.SetPublishAccess(publishAccess)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
}
model.PurgePublishAccess()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
var getPublishAccess = contractHandler(apicontract.GetPublishAccess, getPublishAccessContract)
func getPublishAccessContract(c *gin.Context, request apicontract.FileTreePublishIDsRequest) apicontract.Response[apicontract.FileTreePublishData] {
- ret := gulu.Ret.NewResult()
var IDs []string
for _, ID := range request.IDs {
id := ID
if model.IsEncryptedPublishAccessTarget(id) {
- ret.Code = -1
- ret.Msg = model.Conf.Language(394)
- return contractFailure[apicontract.FileTreePublishData](ret)
+ return apicontract.Failure[apicontract.FileTreePublishData](-1, model.Conf.Language(394))
}
IDs = append(IDs, id)
}
@@ -1499,18 +1339,15 @@ func getPublishAccessContract(c *gin.Context, request apicontract.FileTreePublis
var authFilePublishAccess = contractHandler(apicontract.AuthFilePublishAccess, authFilePublishAccessContract)
func authFilePublishAccessContract(c *gin.Context, request apicontract.FileTreeAuthPublishRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
ID := request.ID
- if util.InvalidIDPattern(ID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(ID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
password := request.Password
- ret.Code = -1
- ret.Msg = model.Conf.Language(285)
+ denied := apicontract.Reject(model.Conf.Language(285))
if model.IsEncryptedPublishRuntimeTarget(ID) {
- return contractFailure[apicontract.Null](ret)
+ return apicontract.FailureFrom[apicontract.Null](denied)
}
// 按来源 IP 对发布密码认证进行限流,防止无限次暴力破解密码 https://github.com/siyuan-note/siyuan/security/advisories/GHSA-v362-968x-gp2v
@@ -1519,8 +1356,8 @@ func authFilePublishAccessContract(c *gin.Context, request apicontract.FileTreeA
// 锁定期间持续记录失败,不断延长锁定时间
util.AuthThrottleFail(ip)
c.Header("Retry-After", strconv.Itoa(retryAfter))
- ret.Msg = model.Conf.Language(354)
- return apicontract.AuthFilePublishAccess.WithHTTPStatus(contractFailure[apicontract.Null](ret), http.StatusTooManyRequests)
+ return apicontract.AuthFilePublishAccess.WithHTTPStatus(
+ apicontract.Failure[apicontract.Null](-1, model.Conf.Language(354)), http.StatusTooManyRequests)
}
publishAccess := model.GetPublishAccess()
@@ -1531,16 +1368,14 @@ func authFilePublishAccessContract(c *gin.Context, request apicontract.FileTreeA
if item.Disable || item.Password == "" || !util.AuthCodeEquals(item.Password, password) {
// 恒定时间比较,避免通过响应时间差异猜测密码
util.AuthThrottleFail(ip)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.FailureFrom[apicontract.Null](denied)
}
util.AuthThrottleReset(ip)
model.SetPublishAuthCookie(c, ID, password)
- ret.Code = 0
- ret.Msg = ""
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](0, "")
}
// 目标 ID 不在发布配置中,同样记录失败以限制尝试次数
util.AuthThrottleFail(ip)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.FailureFrom[apicontract.Null](denied)
}
diff --git a/kernel/api/format.go b/kernel/api/format.go
index c67a002b7f..7f785d5ff4 100644
--- a/kernel/api/format.go
+++ b/kernel/api/format.go
@@ -19,49 +19,39 @@ package api
import (
"github.com/siyuan-note/siyuan/kernel/apicontract"
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/model"
)
var netAssets2LocalAssets = contractHandler(apicontract.NetAssets2LocalAssets, func(c *gin.Context, request apicontract.TrimmedIDRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
id := request.ID
err := model.NetAssets2LocalAssets(id, false, "")
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 5000)
}
return apicontract.Success(apicontract.Null{})
})
var netImg2LocalAssets = contractHandler(apicontract.NetImg2LocalAssets, func(c *gin.Context, request apicontract.NetImageAssetsRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
id := request.ID
url := request.URL
err := model.NetAssets2LocalAssets(id, true, url)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 5000)
}
return apicontract.Success(apicontract.Null{})
})
var autoSpace = contractHandler(apicontract.AutoSpace, func(c *gin.Context, request apicontract.TrimmedIDRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
id := request.ID
err := model.AutoSpace(id)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 5000)
}
return apicontract.Success(apicontract.Null{})
diff --git a/kernel/api/history.go b/kernel/api/history.go
index 9b7df65376..1fcd6923ab 100644
--- a/kernel/api/history.go
+++ b/kernel/api/history.go
@@ -21,7 +21,6 @@ import (
"sort"
"time"
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/apicontract"
"github.com/siyuan-note/siyuan/kernel/model"
@@ -94,14 +93,13 @@ var clearWorkspaceHistory = contractHandler(apicontract.ClearWorkspaceHistory, f
})
var getDocHistoryContent = contractHandler(apicontract.GetDocHistoryContent, func(c *gin.Context, request apicontract.DocHistoryContentRequest) apicontract.Response[apicontract.DocHistoryContentData] {
- ret := gulu.Ret.NewResult()
historyPath, keyword := request.HistoryPath, request.K
highlight := true
if request.Highlight != nil {
highlight = *request.Highlight
}
- if !holdHistoryRequest(c, historyPath, ret) {
- return contractFailure[apicontract.DocHistoryContentData](ret)
+ if err := holdHistoryRequest(c, historyPath); err != nil {
+ return apicontract.FailureFrom[apicontract.DocHistoryContentData](err)
}
id, rootID, content, isLargeDoc, err := model.GetDocHistoryContent(historyPath, keyword, highlight)
if err != nil {
@@ -141,9 +139,8 @@ var diffDocVersions = contractHandler(apicontract.DiffDocVersions, func(c *gin.C
})
var rollbackDocHistory = contractHandler(apicontract.RollbackDocHistory, func(c *gin.Context, request apicontract.HistoryPathRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
- if !holdHistoryRequest(c, request.HistoryPath, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := holdHistoryRequest(c, request.HistoryPath); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
if err := model.RollbackDocHistory(request.HistoryPath); err != nil {
return apicontract.Failure[apicontract.Null](-1, err.Error())
@@ -152,9 +149,8 @@ var rollbackDocHistory = contractHandler(apicontract.RollbackDocHistory, func(c
})
var rollbackAssetsHistory = contractHandler(apicontract.RollbackAssetsHistory, func(c *gin.Context, request apicontract.HistoryPathRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
- if !holdHistoryRequest(c, request.HistoryPath, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := holdHistoryRequest(c, request.HistoryPath); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
if err := model.RollbackAssetsHistory(request.HistoryPath); err != nil {
return apicontract.Failure[apicontract.Null](-1, err.Error())
@@ -170,9 +166,8 @@ var rollbackNotebookHistory = contractHandler(apicontract.RollbackNotebookHistor
})
var rollbackAttributeViewHistory = contractHandler(apicontract.RollbackAttributeViewHistory, func(c *gin.Context, request apicontract.HistoryPathRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
- if !holdHistoryRequest(c, request.HistoryPath, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := holdHistoryRequest(c, request.HistoryPath); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
if err := model.RollbackAttributeViewHistory(request.HistoryPath); err != nil {
return apicontract.Failure[apicontract.Null](-1, err.Error())
@@ -180,15 +175,14 @@ var rollbackAttributeViewHistory = contractHandler(apicontract.RollbackAttribute
return apicontract.Success(apicontract.Null{})
})
-func holdHistoryRequest(c *gin.Context, historyPath string, ret *gulu.Result) bool {
+// holdHistoryRequest 在读取加密笔记本的历史前取得租约,返回 nil 表示可以继续。
+func holdHistoryRequest(c *gin.Context, historyPath string) error {
absolutePath := filepath.Join(util.WorkspaceDir, historyPath)
boxID := model.ExtractBoxIDFromHistoryPath(absolutePath)
if err := holdEncryptedBoxRequest(c, boxID); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return false
+ return apicontract.Reject(model.Conf.Language(314))
}
- return true
+ return nil
}
var createDocHistory = contractHandler(apicontract.CreateDocHistory, func(c *gin.Context, request apicontract.CreateDocHistoryRequest) apicontract.Response[apicontract.Null] {
diff --git a/kernel/api/import.go b/kernel/api/import.go
index 153e06cbcb..36df27ead9 100644
--- a/kernel/api/import.go
+++ b/kernel/api/import.go
@@ -491,9 +491,8 @@ var startObsidianVaultAnalysis = contractHandler(apicontract.StartObsidianVaultA
})
var getObsidianVaultTask = contractHandler(apicontract.GetObsidianVaultTask, func(c *gin.Context, request apicontract.ObsidianTaskRequest) apicontract.Response[*apicontract.ObsidianVaultTask] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.TaskID, ret) {
- return contractFailure[*apicontract.ObsidianVaultTask](ret)
+ if err := util.ValidateID(request.TaskID); err != nil {
+ return apicontract.FailureFrom[*apicontract.ObsidianVaultTask](err)
}
task, err := model.GetObsidianVaultTask(request.TaskID)
if err != nil {
@@ -503,9 +502,8 @@ var getObsidianVaultTask = contractHandler(apicontract.GetObsidianVaultTask, fun
})
var startObsidianVaultImport = contractHandler(apicontract.StartObsidianVaultImport, func(c *gin.Context, request apicontract.ObsidianImportRequest) apicontract.Response[*apicontract.ObsidianVaultTask] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.TaskID, ret) {
- return contractFailure[*apicontract.ObsidianVaultTask](ret)
+ if err := util.ValidateID(request.TaskID); err != nil {
+ return apicontract.FailureFrom[*apicontract.ObsidianVaultTask](err)
}
task, err := model.StartObsidianVaultImport(request.TaskID, request.NotebookName)
if err != nil {
@@ -515,9 +513,8 @@ var startObsidianVaultImport = contractHandler(apicontract.StartObsidianVaultImp
})
var cancelObsidianVaultTask = contractHandler(apicontract.CancelObsidianVaultTask, func(c *gin.Context, request apicontract.ObsidianTaskRequest) apicontract.Response[*apicontract.ObsidianVaultTask] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.TaskID, ret) {
- return contractFailure[*apicontract.ObsidianVaultTask](ret)
+ if err := util.ValidateID(request.TaskID); err != nil {
+ return apicontract.FailureFrom[*apicontract.ObsidianVaultTask](err)
}
task, err := model.CancelObsidianVaultTask(request.TaskID)
if err != nil {
diff --git a/kernel/api/inline_style.go b/kernel/api/inline_style.go
index ce49d4f2f2..19ddca63ca 100644
--- a/kernel/api/inline_style.go
+++ b/kernel/api/inline_style.go
@@ -19,26 +19,21 @@ package api
import (
"github.com/siyuan-note/siyuan/kernel/apicontract"
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/model"
"github.com/siyuan-note/siyuan/kernel/util"
)
var getInlineStyles = contractHandler(apicontract.GetInlineStyles, func(c *gin.Context, request apicontract.EmptyRequest) apicontract.Response[*apicontract.InlineStyles] {
- ret := gulu.Ret.NewResult()
styles, err := model.GetInlineStyles()
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[*apicontract.InlineStyles](ret)
+ return apicontract.Failure[*apicontract.InlineStyles](-1, err.Error())
}
return apicontract.Success(inlineStylesContract(styles))
})
var setInlineStyles = contractHandler(apicontract.SetInlineStyles, func(c *gin.Context, request apicontract.SetInlineStylesRequest) apicontract.Response[*apicontract.InlineStyles] {
- ret := gulu.Ret.NewResult()
app := request.App
input := inlineStylesModel(&apicontract.InlineStyles{Version: int(request.Version), Styles: request.Styles, Builtin: request.Builtin, Order: request.Order, AV: request.AV})
@@ -51,9 +46,7 @@ var setInlineStyles = contractHandler(apicontract.SetInlineStyles, func(c *gin.C
saved, changed, err = model.SetInlineStylesData(input)
}
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[*apicontract.InlineStyles](ret)
+ return apicontract.Failure[*apicontract.InlineStyles](-1, err.Error())
}
if changed {
evt := util.NewCmdResult("reloadInlineStyles", 0, util.PushModeBroadcastMainExcludeSelfApp)
@@ -66,15 +59,12 @@ var setInlineStyles = contractHandler(apicontract.SetInlineStyles, func(c *gin.C
})
var setWorkspaceAVPalette = contractHandler(apicontract.SetWorkspaceAVPalette, func(c *gin.Context, request apicontract.WorkspaceAVPaletteRequest) apicontract.Response[*apicontract.InlineStyles] {
- ret := gulu.Ret.NewResult()
app := request.App
update := workspaceAVPaletteUpdateModel(&apicontract.WorkspaceAVPaletteUpdate{Colors: request.Colors, Order: request.Order, BuiltinColors: request.BuiltinColors})
saved, changed, err := model.SetWorkspaceAVPalette(update)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[*apicontract.InlineStyles](ret)
+ return apicontract.Failure[*apicontract.InlineStyles](-1, err.Error())
}
if changed {
evt := util.NewCmdResult("reloadInlineStyles", 0, util.PushModeBroadcastMainExcludeSelfApp)
diff --git a/kernel/api/lute.go b/kernel/api/lute.go
index 0e41a8ba56..59dad1128d 100644
--- a/kernel/api/lute.go
+++ b/kernel/api/lute.go
@@ -457,14 +457,11 @@ func msWordCommentID(anchor *goquery.Selection, style string) string {
}
var spinBlockDOM = contractHandler(apicontract.SpinBlockDOM, func(c *gin.Context, request apicontract.DOMTextRequest) apicontract.Response[apicontract.DOMData] {
- ret := gulu.Ret.NewResult()
dom := request.DOM
if len(dom) > maxSpinBlockDOMBytes {
// 限制输入大小,避免解析超大 DOM 导致资源消耗
- ret.Code = http.StatusRequestEntityTooLarge
- ret.Msg = "dom input exceeds the maximum permitted size"
- return contractFailure[apicontract.DOMData](ret)
+ return apicontract.Failure[apicontract.DOMData](http.StatusRequestEntityTooLarge, "dom input exceeds the maximum permitted size")
}
luteEngine := model.NewLute()
@@ -474,7 +471,6 @@ var spinBlockDOM = contractHandler(apicontract.SpinBlockDOM, func(c *gin.Context
// md2HTML 将 Markdown 转换为 HTML。
var md2HTML = contractHandler(apicontract.Md2HTML, func(c *gin.Context, request apicontract.MarkdownHTMLRequest) apicontract.Response[apicontract.HTMLData] {
- ret := gulu.Ret.NewResult()
markdown, mode := request.Markdown, request.Mode
@@ -485,9 +481,7 @@ var md2HTML = contractHandler(apicontract.Md2HTML, func(c *gin.Context, request
case "":
html = model.MarkdownToMarkdownStrHTML(markdown)
default:
- ret.Code = -1
- ret.Msg = "unknown [mode]"
- return contractFailure[apicontract.HTMLData](ret)
+ return apicontract.Failure[apicontract.HTMLData](-1, "unknown [mode]")
}
return apicontract.Success(apicontract.HTMLData{HTML: html})
diff --git a/kernel/api/notebook.go b/kernel/api/notebook.go
index 1126c1037e..1ed6223b91 100644
--- a/kernel/api/notebook.go
+++ b/kernel/api/notebook.go
@@ -22,7 +22,6 @@ import (
"strings"
"time"
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/apicontract"
"github.com/siyuan-note/siyuan/kernel/documentaddressing"
@@ -32,27 +31,20 @@ import (
)
var getNotebookInfo = contractHandler(apicontract.GetNotebookInfo, func(c *gin.Context, request apicontract.NotebookIDRequest) apicontract.Response[apicontract.NotebookInfoData] {
- ret := gulu.Ret.NewResult()
boxID := request.Notebook
- if util.InvalidIDPattern(boxID, ret) {
- return contractFailure[apicontract.NotebookInfoData](ret)
+ if err := util.ValidateID(boxID); err != nil {
+ return apicontract.FailureFrom[apicontract.NotebookInfoData](err)
}
box := model.Conf.Box(boxID)
if nil == box {
- ret.Code = -1
- ret.Msg = "notebook [" + boxID + "] not found"
- return contractFailure[apicontract.NotebookInfoData](ret)
+ return apicontract.Failure[apicontract.NotebookInfoData](-1, "notebook ["+boxID+"] not found")
}
if model.IsReadOnlyRoleContext(c) && !isNotebookVisibleByPublishAccess(box, model.GetPublishAccess()) {
- ret.Code = -1
- ret.Msg = "notebook [" + boxID + "] not found"
- return contractFailure[apicontract.NotebookInfoData](ret)
+ return apicontract.Failure[apicontract.NotebookInfoData](-1, "notebook ["+boxID+"] not found")
}
if err := holdEncryptedBoxRequest(c, boxID); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.NotebookInfoData](ret)
+ return apicontract.Failure[apicontract.NotebookInfoData](-1, model.Conf.Language(314))
}
var boxInfo *model.BoxInfo
@@ -66,30 +58,24 @@ var getNotebookInfo = contractHandler(apicontract.GetNotebookInfo, func(c *gin.C
})
var setNotebookIcon = contractHandler(apicontract.SetNotebookIcon, func(c *gin.Context, request apicontract.SetNotebookIconRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
boxID, icon := request.Notebook, request.Icon
- if util.InvalidIDPattern(boxID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(boxID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
if err := holdEncryptedBoxRequest(c, boxID); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(314))
}
model.SetBoxIcon(boxID, icon)
return apicontract.Success(apicontract.Null{})
})
var changeSortNotebook = contractHandler(apicontract.ChangeSortNotebook, func(c *gin.Context, request apicontract.ChangeSortNotebookRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
ids := request.Notebooks
for _, id := range ids {
if err := holdEncryptedBoxRequest(c, id); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(314))
}
}
model.ChangeBoxSort(ids)
@@ -97,9 +83,8 @@ var changeSortNotebook = contractHandler(apicontract.ChangeSortNotebook, func(c
})
var reorderNotebooks = contractHandler(apicontract.ReorderNotebooks, func(c *gin.Context, request apicontract.ReorderNotebooksRequest) apicontract.Response[*apicontract.ReorderData] {
- ret := gulu.Ret.NewResult()
- if !validateReorderRequest(request.SourceIDs, request.TargetID, request.Position, ret) {
- return contractFailure[*apicontract.ReorderData](ret)
+ if err := validateReorderRequest(request.SourceIDs, request.TargetID, request.Position); err != nil {
+ return apicontract.FailureFrom[*apicontract.ReorderData](err)
}
result, err := model.ReorderNotebooks(request.SourceIDs, request.TargetID, request.Position)
@@ -114,22 +99,17 @@ var reorderNotebooks = contractHandler(apicontract.ReorderNotebooks, func(c *gin
})
var renameNotebook = contractHandler(apicontract.RenameNotebook, func(c *gin.Context, request apicontract.RenameNotebookRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
notebook, name := request.Notebook, request.Name
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(314))
}
err := model.RenameBox(notebook, name)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, err.Error(), 5000)
}
evt := util.NewCmdResult("renamenotebook", 0, util.PushModeBroadcast)
@@ -142,24 +122,19 @@ var renameNotebook = contractHandler(apicontract.RenameNotebook, func(c *gin.Con
})
var removeNotebook = contractHandler(apicontract.RemoveNotebook, func(c *gin.Context, request apicontract.NotebookIDRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
if util.ReadOnly && !model.IsUserGuide(notebook) {
- ret.Code = -1
- ret.Msg = model.Conf.Language(34)
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, model.Conf.Language(34), 5000)
}
err := model.RemoveBox(notebook)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
evt := util.NewCmdResult("removeBox", 0, util.PushModeBroadcast)
@@ -172,28 +147,21 @@ var removeNotebook = contractHandler(apicontract.RemoveNotebook, func(c *gin.Con
})
var createNotebook = contractHandler(apicontract.CreateNotebook, func(c *gin.Context, request apicontract.CreateNotebookRequest) apicontract.Response[apicontract.CreateNotebookData] {
- ret := gulu.Ret.NewResult()
name := request.Name
id, err := model.CreateBox(name)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.CreateNotebookData](ret)
+ return apicontract.Failure[apicontract.CreateNotebookData](-1, err.Error())
}
existed, err := model.Mount(id)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.CreateNotebookData](ret)
+ return apicontract.Failure[apicontract.CreateNotebookData](-1, err.Error())
}
box := model.Conf.Box(id)
if nil == box {
- ret.Code = -1
- ret.Msg = "opened notebook [" + id + "] not found"
- return contractFailure[apicontract.CreateNotebookData](ret)
+ return apicontract.Failure[apicontract.CreateNotebookData](-1, "opened notebook ["+id+"] not found")
}
evt := util.NewCmdResult("createnotebook", 0, util.PushModeBroadcast)
@@ -206,39 +174,30 @@ var createNotebook = contractHandler(apicontract.CreateNotebook, func(c *gin.Con
})
var openNotebook = contractHandler(apicontract.OpenNotebook, func(c *gin.Context, request apicontract.OpenNotebookRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
isUserGuide := model.IsUserGuide(notebook)
if util.ReadOnly && !isUserGuide {
- ret.Code = -1
- ret.Msg = model.Conf.Language(34)
- return apicontract.FailureWithTimeout[apicontract.Null](ret.Code, ret.Msg, 5000)
+ return apicontract.FailureWithTimeout[apicontract.Null](-1, model.Conf.Language(34), 5000)
}
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(314))
}
msgId := util.PushMsg(model.Conf.Language(45), 1000*60*15)
defer util.PushClearMsg(msgId)
existed, err := model.Mount(notebook)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
box := model.Conf.Box(notebook)
if nil == box {
- ret.Code = -1
- ret.Msg = "opened notebook [" + notebook + "] not found"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "opened notebook ["+notebook+"] not found")
}
evt := util.NewCmdResult("mount", 0, util.PushModeBroadcast)
@@ -276,40 +235,32 @@ var openNotebook = contractHandler(apicontract.OpenNotebook, func(c *gin.Context
})
var closeNotebook = contractHandler(apicontract.CloseNotebook, func(c *gin.Context, request apicontract.CloseNotebookRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
model.Unmount(notebook)
return apicontract.Success(apicontract.Null{})
})
var getNotebookConf = contractHandler(apicontract.GetNotebookConf, func(c *gin.Context, request apicontract.CloseNotebookRequest) apicontract.Response[apicontract.NotebookConfData] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.NotebookConfData](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.NotebookConfData](err)
}
box := model.Conf.GetBox(notebook)
if nil == box {
- ret.Code = -1
- ret.Msg = "notebook [" + notebook + "] not found"
- return contractFailure[apicontract.NotebookConfData](ret)
+ return apicontract.Failure[apicontract.NotebookConfData](-1, "notebook ["+notebook+"] not found")
}
if model.IsReadOnlyRoleContext(c) && !isNotebookVisibleByPublishAccess(box, model.GetPublishAccess()) {
- ret.Code = -1
- ret.Msg = "notebook [" + notebook + "] not found"
- return contractFailure[apicontract.NotebookConfData](ret)
+ return apicontract.Failure[apicontract.NotebookConfData](-1, "notebook ["+notebook+"] not found")
}
if model.IsBoxUnlocked(notebook) {
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.NotebookConfData](ret)
+ return apicontract.Failure[apicontract.NotebookConfData](-1, model.Conf.Language(314))
}
}
@@ -333,24 +284,19 @@ var getNotebookConf = contractHandler(apicontract.GetNotebookConf, func(c *gin.C
})
var setNotebookConf = contractHandler(apicontract.SetNotebookConf, func(c *gin.Context, request apicontract.SetNotebookConfRequest) apicontract.Response[*apicontract.NotebookConf] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[*apicontract.NotebookConf](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[*apicontract.NotebookConf](err)
}
box := model.Conf.GetBox(notebook)
if nil == box {
- ret.Code = -1
- ret.Msg = "notebook [" + notebook + "] not found"
- return contractFailure[*apicontract.NotebookConf](ret)
+ return apicontract.Failure[*apicontract.NotebookConf](-1, "notebook ["+notebook+"] not found")
}
if model.IsBoxUnlocked(notebook) {
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[*apicontract.NotebookConf](ret)
+ return apicontract.Failure[*apicontract.NotebookConf](-1, model.Conf.Language(314))
}
}
@@ -373,17 +319,13 @@ var setNotebookConf = contractHandler(apicontract.SetNotebookConf, func(c *gin.C
}
}
if "/" == boxConf.DailyNoteSavePath {
- ret.Code = -1
- ret.Msg = model.Conf.Language(49)
- return contractFailure[*apicontract.NotebookConf](ret)
+ return apicontract.Failure[*apicontract.NotebookConf](-1, model.Conf.Language(49))
}
boxConf.DailyNoteTemplatePath = util.NormalizeTemplatePath(boxConf.DailyNoteTemplatePath)
if err := box.SaveConfAndSync(boxConf); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[*apicontract.NotebookConf](ret)
+ return apicontract.Failure[*apicontract.NotebookConf](-1, err.Error())
}
if oldSortMode != boxConf.SortMode {
model.PushDocSortModeChanged("notebook", notebook, "", "/", &boxConf.SortMode)
@@ -392,7 +334,6 @@ var setNotebookConf = contractHandler(apicontract.SetNotebookConf, func(c *gin.C
})
var lsNotebooks = contractHandler(apicontract.ListNotebooks, func(c *gin.Context, request apicontract.ListNotebooksRequest) apicontract.Response[*apicontract.ListNotebooksData] {
- ret := gulu.Ret.NewResult()
flashcard := request.Flashcard
@@ -407,9 +348,7 @@ var lsNotebooks = contractHandler(apicontract.ListNotebooks, func(c *gin.Context
continue
}
if err := holdEncryptedBoxRequest(c, boxID); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[*apicontract.ListNotebooksData](ret)
+ return apicontract.Failure[*apicontract.ListNotebooksData](-1, model.Conf.Language(314))
}
}
var err error
@@ -482,24 +421,18 @@ func isNotebookVisibleByPublishAccess(notebook *model.Box, publishAccess model.P
// enableEncryptedNotebooks 先同步数据,再恢复既有配置或启用加密笔记本并设置主密码。
var enableEncryptedNotebooks = contractHandler(apicontract.EnableEncryptedNotebooks, func(c *gin.Context, request apicontract.NotebookPasswordRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
password := request.Password
if err := model.EnableEncryptedNotebookWithSync(password); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
// disableEncryptedNotebooks 关闭加密笔记本功能。前置:没有加密笔记本存在。
var disableEncryptedNotebooks = contractHandler(apicontract.DisableEncryptedNotebooks, func(c *gin.Context, request apicontract.EmptyRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
if err := model.DisableEncryptedNotebook(); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
@@ -507,19 +440,14 @@ var disableEncryptedNotebooks = contractHandler(apicontract.DisableEncryptedNote
// createEncryptedNotebook 创建一个新的加密笔记本。前置:加密功能已启用。
// 创建时需提供主密码(用于派生 KEK 包络 DEK)。创建成功后内核已原子完成挂载。
var createEncryptedNotebook = contractHandler(apicontract.CreateEncryptedNotebook, func(c *gin.Context, request apicontract.CreateEncryptedNotebookRequest) apicontract.Response[apicontract.CreateNotebookData] {
- ret := gulu.Ret.NewResult()
name, password := request.Name, request.Password
id, err := model.CreateEncryptedBox(name, password)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.CreateNotebookData](ret)
+ return apicontract.Failure[apicontract.CreateNotebookData](-1, err.Error())
}
if err = holdEncryptedBoxRequest(c, id); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.CreateNotebookData](ret)
+ return apicontract.Failure[apicontract.CreateNotebookData](-1, model.Conf.Language(314))
}
// 创建时 DEK 已缓存 + 加密 db 已打开,此处直接挂载;失败则锁定回滚,避免 DEK 残留
@@ -527,9 +455,7 @@ var createEncryptedNotebook = contractHandler(apicontract.CreateEncryptedNoteboo
if err != nil {
releaseEncryptedBoxRequest(c, id)
model.LockBox(id)
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.CreateNotebookData](ret)
+ return apicontract.Failure[apicontract.CreateNotebookData](-1, err.Error())
}
box := model.Conf.Box(id)
@@ -546,80 +472,60 @@ var createEncryptedNotebook = contractHandler(apicontract.CreateEncryptedNoteboo
// unlockNotebook 用主密码派生 KEK 并解出指定加密笔记本的 DEK,缓存到内存。
// 解锁后该笔记本即可被 Mount。每次调用跑一次 Argon2id(约 1 秒)。
var unlockNotebook = contractHandler(apicontract.UnlockNotebook, func(c *gin.Context, request apicontract.UnlockNotebookRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
notebook, password := request.Notebook, request.Password
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
boxCrypt, err := model.GetBoxEncryption(notebook)
if err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(318)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(318))
}
if boxCrypt == nil || len(boxCrypt.WrappedDEK) == 0 {
- ret.Code = -1
- ret.Msg = model.Conf.Language(319)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(319))
}
if err := model.UnlockBox(notebook, password, boxCrypt); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if err = holdEncryptedBoxRequest(c, notebook); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(314))
}
return apicontract.Success(apicontract.Null{})
})
// unlockAndOpenNotebook 原子化解锁并挂载加密笔记本,挂载失败时由模型层在同一转换锁内回滚本次解锁。
var unlockAndOpenNotebook = contractHandler(apicontract.UnlockAndOpenNotebook, func(c *gin.Context, request apicontract.UnlockNotebookRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
notebook, password := request.Notebook, request.Password
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
boxCrypt, err := model.GetBoxEncryption(notebook)
if err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(318)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(318))
}
if boxCrypt == nil || len(boxCrypt.WrappedDEK) == 0 {
- ret.Code = -1
- ret.Msg = model.Conf.Language(319)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(319))
}
msgId := util.PushMsg(model.Conf.Language(45), 1000*60*15)
defer util.PushClearMsg(msgId)
existed, err := model.UnlockAndMountBox(notebook, password, boxCrypt)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
if err = holdEncryptedBoxRequest(c, notebook); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(314))
}
box := model.Conf.Box(notebook)
if nil == box {
releaseEncryptedBoxRequest(c, notebook)
model.LockBox(notebook)
- ret.Code = -1
- ret.Msg = "opened notebook [" + notebook + "] not found"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "opened notebook ["+notebook+"] not found")
}
evt := util.NewCmdResult("mount", 0, util.PushModeBroadcast)
@@ -633,17 +539,14 @@ var unlockAndOpenNotebook = contractHandler(apicontract.UnlockAndOpenNotebook, f
// lockNotebook 锁定指定加密笔记本:清除其 DEK 缓存并 Unmount。
var lockNotebook = contractHandler(apicontract.LockNotebook, func(c *gin.Context, request apicontract.NotebookIDRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
notebook := request.Notebook
- if util.InvalidIDPattern(notebook, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(notebook); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
if !model.IsEncryptedBox(notebook) {
- ret.Code = -1
- ret.Msg = model.Conf.Language(319)
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, model.Conf.Language(319))
}
// Unmount 内部的 unmount0 会清 DEK + 关闭加密 db,无需单独 LockBox。
@@ -673,13 +576,10 @@ var touchEncryptedNotebooks = contractHandler(apicontract.TouchEncryptedNotebook
// 用旧密码校验后,用新密码派生新 KEK,重新加密 verifier 和所有加密笔记本的 WrappedDEK。
// 必须在所有加密笔记本都已锁定(DEK 不在内存)的状态下调用。
var changeMasterPassword = contractHandler(apicontract.ChangeMasterPassword, func(c *gin.Context, request apicontract.ChangeMasterPasswordRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
oldPassword, newPassword := request.OldPassword, request.NewPassword
if err := model.ChangeMasterPassword(oldPassword, newPassword); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
@@ -714,12 +614,9 @@ var getEncryptedNotebookStatus = contractHandler(apicontract.GetEncryptedNoteboo
// exportNotebookCryptoBackup 导出密钥备份文件到 export 目录供下载。
// 备份文件不含主密码(salt 不保密、verifier 是密文),用户主动保存作为同步之外的独立恢复途径。
var exportNotebookCryptoBackup = contractHandler(apicontract.ExportNotebookCryptoBackup, func(c *gin.Context, request apicontract.EmptyRequest) apicontract.Response[apicontract.NotebookCryptoBackupData] {
- ret := gulu.Ret.NewResult()
downloadPath, err := model.ExportNotebookCryptoBackup()
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.NotebookCryptoBackupData](ret)
+ return apicontract.Failure[apicontract.NotebookCryptoBackupData](-1, err.Error())
}
return apicontract.Success(apicontract.NotebookCryptoBackupData{File: downloadPath})
})
@@ -727,26 +624,19 @@ var exportNotebookCryptoBackup = contractHandler(apicontract.ExportNotebookCrypt
// importNotebookCryptoBackup 导入密钥备份文件,恢复加密配置。
// 用于新设备、重装或 RecoveryRequired 状态下手动恢复;完整且已启用的配置拒绝覆盖。
var importNotebookCryptoBackup = contractHandler(apicontract.ImportNotebookCryptoBackup, func(c *gin.Context, request apicontract.ImportNotebookCryptoBackupRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
fh := request.File
f, err := fh.Open()
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
defer f.Close()
data, err := io.ReadAll(f)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
password := request.Password
if err := model.ImportNotebookCryptoBackup(data, password); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
diff --git a/kernel/api/outline.go b/kernel/api/outline.go
index 2f0cc028d5..12a8279f4e 100644
--- a/kernel/api/outline.go
+++ b/kernel/api/outline.go
@@ -19,7 +19,6 @@ package api
import (
"github.com/siyuan-note/siyuan/kernel/apicontract"
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/model"
"github.com/siyuan-note/siyuan/kernel/treenode"
@@ -27,14 +26,13 @@ import (
)
var getDocOutline = contractHandler(apicontract.GetDocOutline, func(c *gin.Context, request apicontract.OutlineRequest) apicontract.Response[[]*apicontract.SearchPath] {
- ret := gulu.Ret.NewResult()
if request.ID == nil {
return apicontract.Success[[]*apicontract.SearchPath](nil)
}
rootID, preview := *request.ID, request.Preview
- if util.InvalidIDPattern(rootID, ret) {
- return contractFailure[[]*apicontract.SearchPath](ret)
+ if err := util.ValidateID(rootID); err != nil {
+ return apicontract.FailureFrom[[]*apicontract.SearchPath](err)
}
notebook := request.Notebook
@@ -42,9 +40,7 @@ var getDocOutline = contractHandler(apicontract.GetDocOutline, func(c *gin.Conte
return apicontract.Success([]*apicontract.SearchPath{})
}
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.SearchPath](ret)
+ return apicontract.Failure[[]*apicontract.SearchPath](1, err.Error())
}
var headings []*model.Path
var err error
@@ -54,9 +50,7 @@ var getDocOutline = contractHandler(apicontract.GetDocOutline, func(c *gin.Conte
headings, err = model.Outline(rootID, preview)
}
if err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.SearchPath](ret)
+ return apicontract.Failure[[]*apicontract.SearchPath](1, err.Error())
}
if model.IsReadOnlyRoleContext(c) {
publishAccess := model.GetPublishAccess()
@@ -76,23 +70,20 @@ var getDocOutline = contractHandler(apicontract.GetDocOutline, func(c *gin.Conte
})
var getDocHeadingNumbers = contractHandler(apicontract.GetDocHeadingNumbers, func(c *gin.Context, request apicontract.HeadingNumbersRequest) apicontract.Response[map[string]string] {
- ret := gulu.Ret.NewResult()
if request.ID == nil {
return apicontract.Success[map[string]string](nil)
}
rootID := *request.ID
- if util.InvalidIDPattern(rootID, ret) {
- return contractFailure[map[string]string](ret)
+ if err := util.ValidateID(rootID); err != nil {
+ return apicontract.FailureFrom[map[string]string](err)
}
notebook := request.Notebook
if isEncryptedNotebookDeniedForPublish(c, notebook) {
return apicontract.Success(map[string]string{})
}
if err := holdEncryptedBoxRequest(c, notebook); err != nil {
- ret.Code = 1
- ret.Msg = err.Error()
- return contractFailure[map[string]string](ret)
+ return apicontract.Failure[map[string]string](1, err.Error())
}
numbers := map[string]string{}
var err error
@@ -102,9 +93,7 @@ var getDocHeadingNumbers = contractHandler(apicontract.GetDocHeadingNumbers, fun
numbers, err = model.GetHeadingNumbers(rootID, "")
}
if nil != err {
- ret.Code = 1
- ret.Msg = err.Error()
- return contractFailure[map[string]string](ret)
+ return apicontract.Failure[map[string]string](1, err.Error())
}
if model.IsReadOnlyRoleContext(c) {
publishAccess := model.GetPublishAccess()
diff --git a/kernel/api/ref.go b/kernel/api/ref.go
index f661292d2b..f0b1f50315 100644
--- a/kernel/api/ref.go
+++ b/kernel/api/ref.go
@@ -20,7 +20,6 @@ import (
"encoding/json"
"strconv"
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/apicontract"
"github.com/siyuan-note/siyuan/kernel/model"
@@ -28,9 +27,8 @@ import (
)
var refreshBacklink = contractHandler(apicontract.RefreshBacklink, func(c *gin.Context, request apicontract.RefreshBacklinkRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.ID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(request.ID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
model.RefreshBacklink(request.ID)
model.FlushTxQueue()
diff --git a/kernel/api/repo.go b/kernel/api/repo.go
index 0b5f0279df..5d5c09b041 100644
--- a/kernel/api/repo.go
+++ b/kernel/api/repo.go
@@ -24,7 +24,6 @@ import (
"os"
"path/filepath"
- "github.com/88250/gulu"
"github.com/gabriel-vasile/mimetype"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/dejavu"
@@ -59,10 +58,9 @@ var setRetentionIndexesDaily = contractHandler(apicontract.SetRetentionIndexesDa
})
var getRepoFile = contractHandler(apicontract.GetRepoFile, func(c *gin.Context, request apicontract.GetRepoFileRequest) apicontract.Response[apicontract.BinaryContent] {
- ret := gulu.Ret.NewResult()
- if !holdRepoFileRequest(c, request.ID, ret) {
- return contractFailure[apicontract.BinaryContent](ret)
+ if err := holdRepoFileRequest(c, request.ID); err != nil {
+ return apicontract.FailureFrom[apicontract.BinaryContent](err)
}
data, p, err := model.GetRepoFile(request.ID)
if err != nil {
@@ -73,10 +71,9 @@ var getRepoFile = contractHandler(apicontract.GetRepoFile, func(c *gin.Context,
})
var rollbackRepoSnapshotFile = contractHandler(apicontract.RollbackRepoSnapshotFile, func(c *gin.Context, request apicontract.RollbackRepoSnapshotFileRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
- if !holdRepoFileRequest(c, request.ID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := holdRepoFileRequest(c, request.ID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
err := model.RollbackRepoSnapshotFile(request.ID)
@@ -88,10 +85,9 @@ var rollbackRepoSnapshotFile = contractHandler(apicontract.RollbackRepoSnapshotF
})
var openRepoSnapshotFile = contractHandler(apicontract.OpenRepoSnapshotFile, func(c *gin.Context, request apicontract.OpenRepoSnapshotFileRequest) apicontract.Response[apicontract.RepoOpenFileData] {
- ret := gulu.Ret.NewResult()
- if !holdRepoFileRequest(c, request.ID, ret) {
- return contractFailure[apicontract.RepoOpenFileData](ret)
+ if err := holdRepoFileRequest(c, request.ID); err != nil {
+ return apicontract.FailureFrom[apicontract.RepoOpenFileData](err)
}
title, content, displayInText, updated, err := model.OpenRepoSnapshotFile(request.ID)
@@ -126,11 +122,10 @@ var getCloudSpace = contractHandler(apicontract.GetCloudSpace, func(c *gin.Conte
})
var checkoutRepo = contractHandler(apicontract.CheckoutRepo, func(c *gin.Context, request apicontract.CheckoutRepoRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
if request.SessionID != "" {
- if util.InvalidIDPattern(request.SessionID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(request.SessionID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
markerDir := filepath.Join(util.TempDir, "ai", "agent")
os.MkdirAll(markerDir, 0755)
@@ -204,9 +199,8 @@ var searchRepoFile = contractHandler(apicontract.SearchRepoFile, func(c *gin.Con
})
var getRepoDocHistory = contractHandler(apicontract.GetRepoDocHistory, func(c *gin.Context, request apicontract.GetRepoDocHistoryRequest) apicontract.Response[apicontract.RepoDocHistoryData] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.ID, ret) {
- return contractFailure[apicontract.RepoDocHistoryData](ret)
+ if err := util.ValidateID(request.ID); err != nil {
+ return apicontract.FailureFrom[apicontract.RepoDocHistoryData](err)
}
if block := treenode.GetBlockTree(request.ID); block != nil {
@@ -224,10 +218,9 @@ var getRepoDocHistory = contractHandler(apicontract.GetRepoDocHistory, func(c *g
})
var exportRepoFile = contractHandler(apicontract.ExportRepoFile, func(c *gin.Context, request apicontract.ExportRepoFileRequest) apicontract.Response[apicontract.RepoExportData] {
- ret := gulu.Ret.NewResult()
- if !holdRepoFileRequest(c, request.ID, ret) {
- return contractFailure[apicontract.RepoExportData](ret)
+ if err := holdRepoFileRequest(c, request.ID); err != nil {
+ return apicontract.FailureFrom[apicontract.RepoExportData](err)
}
exportPath, err := model.ExportRepoFile(request.ID)
@@ -238,19 +231,16 @@ var exportRepoFile = contractHandler(apicontract.ExportRepoFile, func(c *gin.Con
return apicontract.Success(apicontract.RepoExportData{Path: exportPath})
})
-func holdRepoFileRequest(c *gin.Context, id string, ret *gulu.Result) bool {
+// holdRepoFileRequest 在读取仓库文件前取得所属笔记本的租约,返回 nil 表示可以继续。
+func holdRepoFileRequest(c *gin.Context, id string) error {
boxID, err := model.ResolveRepoFileBoxID(id)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return false
+ return apicontract.Reject(err.Error())
}
if err = holdEncryptedBoxRequest(c, boxID); err != nil {
- ret.Code = -1
- ret.Msg = model.Conf.Language(314)
- return false
+ return apicontract.Reject(model.Conf.Language(314))
}
- return true
+ return nil
}
var getCloudRepoSnapshots = contractHandler(apicontract.GetCloudRepoSnapshots, func(c *gin.Context, request apicontract.GetCloudRepoSnapshotsRequest) apicontract.Response[apicontract.RepoCloudSnapshotsData] {
diff --git a/kernel/api/riff.go b/kernel/api/riff.go
index 38e0989235..e299f3a3bc 100644
--- a/kernel/api/riff.go
+++ b/kernel/api/riff.go
@@ -17,7 +17,6 @@
package api
import (
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/riff"
"github.com/siyuan-note/siyuan/kernel/apicontract"
@@ -165,9 +164,8 @@ var renameRiffDeck = contractHandler(apicontract.RenameRiffDeck, func(c *gin.Con
})
var removeRiffDeck = contractHandler(apicontract.RemoveRiffDeck, func(c *gin.Context, request apicontract.RiffDeckRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
- if util.InvalidIDPattern(request.DeckID, ret) {
- return contractFailure[apicontract.Null](ret)
+ if err := util.ValidateID(request.DeckID); err != nil {
+ return apicontract.FailureFrom[apicontract.Null](err)
}
if err := model.RemoveDeck(request.DeckID); err != nil {
return apicontract.Failure[apicontract.Null](-1, err.Error())
diff --git a/kernel/api/setting.go b/kernel/api/setting.go
index a063a7b322..7734b1089a 100644
--- a/kernel/api/setting.go
+++ b/kernel/api/setting.go
@@ -501,16 +501,7 @@ var logoutCloudUser = contractHandler(apicontract.LogoutCloudUser, func(c *gin.C
})
var login2faCloudUser = contractHandler(apicontract.Login2faCloudUser, func(c *gin.Context, request apicontract.SettingLogin2faRequest) apicontract.Response[apicontract.Login2faEnvelope] {
- result := model.Login2fa(request.Token, request.Code)
- encoded, err := gulu.JSON.MarshalJSON(result)
- if err != nil {
- return apicontract.Failure[apicontract.Login2faEnvelope](-1, err.Error())
- }
- var envelope apicontract.Login2faEnvelope
- if err = gulu.JSON.UnmarshalJSON(encoded, &envelope); err != nil {
- return apicontract.Failure[apicontract.Login2faEnvelope](-1, err.Error())
- }
- return apicontract.SuccessDirectJSON(envelope)
+ return apicontract.SuccessDirectJSON(*model.Login2fa(request.Token, request.Code))
})
var setEmoji = contractHandler(apicontract.SetEmoji, func(c *gin.Context, request apicontract.SettingEmojiRequest) apicontract.Response[apicontract.Null] {
diff --git a/kernel/api/snippet.go b/kernel/api/snippet.go
index 4ba531da8b..4c80865dd9 100644
--- a/kernel/api/snippet.go
+++ b/kernel/api/snippet.go
@@ -20,7 +20,6 @@ import (
"errors"
"strings"
- "github.com/88250/gulu"
"github.com/88250/lute/ast"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/apicontract"
@@ -29,7 +28,6 @@ import (
)
var getSnippet = contractHandler(apicontract.GetSnippet, func(c *gin.Context, request apicontract.GetSnippetRequest) apicontract.Response[apicontract.SnippetsData] {
- ret := gulu.Ret.NewResult()
typ, enabledArg, keyword := request.Type, request.Enabled, request.Keyword
@@ -40,9 +38,7 @@ var getSnippet = contractHandler(apicontract.GetSnippet, func(c *gin.Context, re
confSnippets, err := model.LoadSnippets()
if err != nil {
- ret.Code = -1
- ret.Msg = "load snippets failed: " + err.Error()
- return contractFailure[apicontract.SnippetsData](ret)
+ return apicontract.Failure[apicontract.SnippetsData](-1, "load snippets failed: "+err.Error())
}
isPublish := model.IsReadOnlyRoleContext(c)
@@ -85,7 +81,6 @@ var getSnippet = contractHandler(apicontract.GetSnippet, func(c *gin.Context, re
})
var setSnippet = contractHandler(apicontract.SetSnippet, func(c *gin.Context, request apicontract.SetSnippetRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
var snippets []*conf.Snippet
for _, s := range request.Snippets {
@@ -95,9 +90,7 @@ var setSnippet = contractHandler(apicontract.SetSnippet, func(c *gin.Context, re
}
if "css" == snippet.Type {
if strings.Contains(strings.ToLower(snippet.Content), "</style") || strings.Contains(strings.ToLower(snippet.Content), "<script") {
- ret.Code = -1
- ret.Msg = "invalid css snippet content"
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, "invalid css snippet content")
}
}
snippets = append(snippets, snippet)
@@ -110,26 +103,22 @@ var setSnippet = contractHandler(apicontract.SetSnippet, func(c *gin.Context, re
err = model.SetSnippet(snippets, *request.Revision)
}
if err != nil {
- ret.Code = -1
- ret.Msg = "set snippet failed: " + err.Error()
+ msg := "set snippet failed: " + err.Error()
if errors.Is(err, model.ErrSnippetConflict) {
- ret.Msg = model.ErrSnippetConflict.Error()
+ msg = model.ErrSnippetConflict.Error()
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, msg)
}
return apicontract.Success(apicontract.Null{})
})
var removeSnippet = contractHandler(apicontract.RemoveSnippet, func(c *gin.Context, request apicontract.TrimmedIDRequest) apicontract.Response[*apicontract.Snippet] {
- ret := gulu.Ret.NewResult()
id := request.ID
snippet, err := model.RemoveSnippet(id)
if err != nil {
- ret.Code = -1
- ret.Msg = "remove snippet failed: " + err.Error()
- return contractFailure[*apicontract.Snippet](ret)
+ return apicontract.Failure[*apicontract.Snippet](-1, "remove snippet failed: "+err.Error())
}
return apicontract.Success(snippetContract(snippet))
})
diff --git a/kernel/api/storage.go b/kernel/api/storage.go
index f1a66fb0b4..5a8802990f 100644
--- a/kernel/api/storage.go
+++ b/kernel/api/storage.go
@@ -22,7 +22,6 @@ import (
"slices"
"strings"
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/model"
"github.com/siyuan-note/siyuan/kernel/util"
@@ -76,7 +75,6 @@ var getLocalStorageVals = contractHandler(apicontract.GetLocalStorageVals, func(
})
var setLocalStorageVal = contractHandler(apicontract.SetLocalStorageVal, func(c *gin.Context, request apicontract.StorageSetRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
key, app := request.Key, request.App
input, err := storageModelValues(map[string]apicontract.JSONValue{key: request.Val})
@@ -86,9 +84,7 @@ var setLocalStorageVal = contractHandler(apicontract.SetLocalStorageVal, func(c
val := input[key]
setKeyVals, err := model.SetLocalStorageVals(map[string]any{key: val})
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
evt := util.NewCmdResult("setLocalStorageVal", 0, util.PushModeBroadcastMainExcludeSelfApp)
@@ -100,7 +96,6 @@ var setLocalStorageVal = contractHandler(apicontract.SetLocalStorageVal, func(c
})
var setLocalStorageVals = contractHandler(apicontract.SetLocalStorageVals, func(c *gin.Context, request apicontract.StorageSetKeysRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
app := request.App
if len(request.KeyVals) == 0 {
@@ -112,9 +107,7 @@ var setLocalStorageVals = contractHandler(apicontract.SetLocalStorageVals, func(
}
setKeyVals, err := model.SetLocalStorageVals(keyVals)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
evtSet := util.NewCmdResult("setLocalStorageVals", 0, util.PushModeBroadcastMainExcludeSelfApp)
@@ -126,14 +119,11 @@ var setLocalStorageVals = contractHandler(apicontract.SetLocalStorageVals, func(
})
var removeLocalStorageVal = contractHandler(apicontract.RemoveLocalStorageVal, func(c *gin.Context, request apicontract.StorageRemoveRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
key, app := request.Key, request.App
err := model.RemoveLocalStorageVals([]string{key})
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
evt := util.NewCmdResult("removeLocalStorageVal", 0, util.PushModeBroadcastMainExcludeSelfApp)
@@ -145,7 +135,6 @@ var removeLocalStorageVal = contractHandler(apicontract.RemoveLocalStorageVal, f
})
var removeLocalStorageVals = contractHandler(apicontract.RemoveLocalStorageVals, func(c *gin.Context, request apicontract.StorageRemoveKeysRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
keys := request.Keys
if len(keys) == 0 {
@@ -157,9 +146,7 @@ var removeLocalStorageVals = contractHandler(apicontract.RemoveLocalStorageVals,
app := request.App
err := model.RemoveLocalStorageVals(keys)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
evt := util.NewCmdResult("removeLocalStorageVals", 0, util.PushModeBroadcastMainExcludeSelfApp)
@@ -181,7 +168,6 @@ var getCriteria = contractHandler(apicontract.GetCriteria, func(c *gin.Context,
})
var setCriterion = contractHandler(apicontract.SetCriterion, func(c *gin.Context, request apicontract.SetCriterionRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
if request.Criterion == nil {
return apicontract.Failure[apicontract.Null](-1, "Field [criterion] is required")
@@ -189,37 +175,29 @@ var setCriterion = contractHandler(apicontract.SetCriterion, func(c *gin.Context
criterion := criterionModel(*request.Criterion)
err := model.SetCriterion(criterion)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
var removeCriterion = contractHandler(apicontract.RemoveCriterion, func(c *gin.Context, request apicontract.RemoveCriterionRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
name := request.Name
err := model.RemoveCriterion(name)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
var getRecentDocs = contractHandler(apicontract.GetRecentDocs, func(c *gin.Context, request apicontract.RecentDocsRequest) apicontract.Response[[]*apicontract.RecentDoc] {
- ret := gulu.Ret.NewResult()
sortBy := request.SortBy
data, err := model.GetRecentDocs(sortBy)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[[]*apicontract.RecentDoc](ret)
+ return apicontract.Failure[[]*apicontract.RecentDoc](-1, err.Error())
}
if model.IsReadOnlyRoleContext(c) {
publishAccess := model.GetPublishAccess()
@@ -236,93 +214,73 @@ var clearRecentDocs = contractHandler(apicontract.ClearRecentDocs, func(c *gin.C
})
var updateRecentDocOpenTime = contractHandler(apicontract.UpdateRecentDocOpenTime, func(c *gin.Context, request apicontract.RecentDocUpdateRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
rootID := request.RootID
if "" == rootID {
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
err := model.UpdateRecentDocOpenTime(rootID)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
}, skipReadonlyStorageMutation)
var updateRecentDocViewTime = contractHandler(apicontract.UpdateRecentDocViewTime, func(c *gin.Context, request apicontract.RecentDocUpdateRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
rootID := request.RootID
if "" == rootID {
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
err := model.UpdateRecentDocViewTime(rootID)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
}, skipReadonlyStorageMutation)
var updateRecentDocCloseTime = contractHandler(apicontract.UpdateRecentDocCloseTime, func(c *gin.Context, request apicontract.RecentDocUpdateRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
rootID := request.RootID
if "" == rootID {
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
err := model.UpdateRecentDocCloseTime(rootID)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
}, skipReadonlyStorageMutation)
var batchUpdateRecentDocCloseTime = contractHandler(apicontract.BatchUpdateRecentDocCloseTime, func(c *gin.Context, request apicontract.RecentDocsUpdateRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
rootIDs := request.RootIDs
if 0 == len(rootIDs) {
- return contractFailure[apicontract.Null](ret)
+ return apicontract.SuccessWithoutData[apicontract.Null]()
}
err := model.BatchUpdateRecentDocCloseTime(rootIDs)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
}, skipReadonlyStorageMutation)
var getOutlineStorage = contractHandler(apicontract.GetOutlineStorage, func(c *gin.Context, request apicontract.OutlineStorageRequest) apicontract.Response[map[string]apicontract.JSONValue] {
- ret := gulu.Ret.NewResult()
docID := request.DocID
data, err := model.GetOutlineStorage(docID)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[map[string]apicontract.JSONValue](ret)
+ return apicontract.Failure[map[string]apicontract.JSONValue](-1, err.Error())
}
return storageContract(data)
})
var setOutlineStorage = contractHandler(apicontract.SetOutlineStorage, func(c *gin.Context, request apicontract.OutlineStorageSetRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
docID := request.DocID
val, err := storageModelValues(request.Val)
@@ -331,44 +289,35 @@ var setOutlineStorage = contractHandler(apicontract.SetOutlineStorage, func(c *g
}
err = model.SetOutlineStorage(docID, val)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
var removeOutlineStorage = contractHandler(apicontract.RemoveOutlineStorage, func(c *gin.Context, request apicontract.OutlineStorageRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
docID := request.DocID
err := model.RemoveOutlineStorage(docID)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
return apicontract.Success(apicontract.Null{})
})
var getViewState = contractHandler(apicontract.GetViewState, func(c *gin.Context, request apicontract.StorageKeyRequest) apicontract.Response[map[string]apicontract.JSONValue] {
- ret := gulu.Ret.NewResult()
key := request.Key
data, err := model.GetViewState(key)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[map[string]apicontract.JSONValue](ret)
+ return apicontract.Failure[map[string]apicontract.JSONValue](-1, err.Error())
}
return storageContract(data)
})
var patchViewState = contractHandler(apicontract.PatchViewState, func(c *gin.Context, request apicontract.ViewStatePatchRequest) apicontract.Response[map[string]apicontract.JSONValue] {
- ret := gulu.Ret.NewResult()
key, removeKeys := request.Key, request.RemoveKeys
for _, key := range removeKeys {
@@ -382,21 +331,16 @@ var patchViewState = contractHandler(apicontract.PatchViewState, func(c *gin.Con
}
data, err := model.PatchViewState(key, values, removeKeys)
if err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
- return contractFailure[map[string]apicontract.JSONValue](ret)
+ return apicontract.Failure[map[string]apicontract.JSONValue](-1, err.Error())
}
return storageContract(data)
})
var removeViewState = contractHandler(apicontract.RemoveViewState, func(c *gin.Context, request apicontract.StorageKeyRequest) apicontract.Response[apicontract.Null] {
- ret := gulu.Ret.NewResult()
-
key := request.Key
if err := model.RemoveViewState(key); err != nil {
- ret.Code = -1
- ret.Msg = err.Error()
+ return apicontract.Failure[apicontract.Null](-1, err.Error())
}
- return contractFailure[apicontract.Null](ret)
+ return apicontract.Success(apicontract.Null{})
})
diff --git a/kernel/api/template.go b/kernel/api/template.go
index 908923a7e5..969ad2c594 100644
--- a/kernel/api/template.go
+++ b/kernel/api/template.go
@@ -47,10 +47,9 @@ var docSaveAsTemplate = contractHandler(apicontract.DocSaveAsTemplate, func(c *g
})
var getDocSaveAsTemplateInfo = contractHandler(apicontract.GetDocSaveAsTemplateInfo, func(c *gin.Context, request apicontract.TemplateDocumentRequest) apicontract.Response[apicontract.TemplateDocumentInfo] {
- ret := gulu.Ret.NewResult()
id := request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.TemplateDocumentInfo](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.TemplateDocumentInfo](err)
}
info, err := model.GetDocSaveAsTemplateInfo(id)
if nil != err {
@@ -60,23 +59,18 @@ var getDocSaveAsTemplateInfo = contractHandler(apicontract.GetDocSaveAsTemplateI
})
var renderTemplate = contractHandler(apicontract.RenderTemplate, func(c *gin.Context, request apicontract.RenderTemplateRequest) apicontract.Response[apicontract.RenderTemplateData] {
- ret := gulu.Ret.NewResult()
p, id := request.Path, request.ID
- if util.InvalidIDPattern(id, ret) {
- return contractFailure[apicontract.RenderTemplateData](ret)
+ if err := util.ValidateID(id); err != nil {
+ return apicontract.FailureFrom[apicontract.RenderTemplateData](err)
}
if !util.IsAbsPathInWorkspace(p) {
- ret.Code = -1
- ret.Msg = "Path [" + p + "] is not in workspace"
- return contractFailure[apicontract.RenderTemplateData](ret)
+ return apicontract.Failure[apicontract.RenderTemplateData](-1, "Path ["+p+"] is not in workspace")
}
// 模板路径必须限定在 <data>/templates/ 目录内,防止通过工作空间内任意路径读取敏感文件(如 conf/conf.json)
if !isPathInTemplatesDir(p) {
- ret.Code = -1
- ret.Msg = "Path [" + p + "] is not in templates directory"
- return contractFailure[apicontract.RenderTemplateData](ret)
+ return apicontract.Failure[apicontract.RenderTemplateData](-1, "Path ["+p+"] is not in templates directory")
}
modeValue, modeErr := request.RenderMode()
@@ -98,9 +92,7 @@ var renderTemplate = contractHandler(apicontract.RenderTemplate, func(c *gin.Con
_, content, docTreePlan, err = model.RenderTemplateWithMode(p, id, mode)
}
if err != nil {
- ret.Code = -1
- ret.Msg = util.EscapeHTML(err.Error())
- return contractFailure[apicontract.RenderTemplateData](ret)
+ return apicontract.Failure[apicontract.RenderTemplateData](-1, util.EscapeHTML(err.Error()))
}
data := apicontract.RenderTemplateData{Path: p, Content: content}
diff --git a/kernel/api/workspace.go b/kernel/api/workspace.go
index 606634b76b..1eda6ea1b6 100644
--- a/kernel/api/workspace.go
+++ b/kernel/api/workspace.go
@@ -344,21 +344,15 @@ func isInvalidWorkspacePath(absPath string) bool {
return gulu.Str.Contains(toLower, []string{"conf", "home", "data", "temp"})
}
-func rejectMobileWorkspaceBaseDir(ret *gulu.Result, path string) bool {
- if !util.IsMobileWorkspaceBaseDir(path) {
- return false
- }
- ret.Code = -1
- ret.Msg = model.Conf.Language(274)
- ret.Data = map[string]any{"closeTimeout": 7000}
- return true
-}
+// mobileWorkspaceBaseDirTimeout 是拒绝移动端工作空间基准目录时提示的显示时长。
+const mobileWorkspaceBaseDirTimeout = 7000
+// rejectMobileWorkspaceBaseDirResponse 在路径落在移动端不允许的基准目录时返回提示,
+// 其余情况返回 nil 表示可以继续。
func rejectMobileWorkspaceBaseDirResponse[Data any](path string) *apicontract.Response[Data] {
- result := gulu.Ret.NewResult()
- if !rejectMobileWorkspaceBaseDir(result, path) {
+ if !util.IsMobileWorkspaceBaseDir(path) {
return nil
}
- response := apicontract.FailureWithTimeout[Data](result.Code, result.Msg, 7000)
+ response := apicontract.FailureWithTimeout[Data](-1, model.Conf.Language(274), mobileWorkspaceBaseDirTimeout)
return &response
}
diff --git a/kernel/api/workspace_test.go b/kernel/api/workspace_test.go
index 445235e4de..703474ce6f 100644
--- a/kernel/api/workspace_test.go
+++ b/kernel/api/workspace_test.go
@@ -26,21 +26,21 @@ import (
"strings"
"testing"
- "github.com/88250/gulu"
"github.com/gin-gonic/gin"
+ "github.com/siyuan-note/siyuan/kernel/apicontract"
"github.com/siyuan-note/siyuan/kernel/model"
"github.com/siyuan-note/siyuan/kernel/util"
)
func TestRejectMobileWorkspaceBaseDir(t *testing.T) {
_, workspaceBaseDir := prepareMobileWorkspaceBaseDirTest(t)
- ret := gulu.Ret.NewResult()
- if !rejectMobileWorkspaceBaseDir(ret, workspaceBaseDir) {
+ response := rejectMobileWorkspaceBaseDirResponse[apicontract.Null](workspaceBaseDir)
+ if response == nil {
t.Fatal("mobile workspace base dir should be rejected")
}
- if -1 != ret.Code {
- t.Fatalf("unexpected result code: got %d, want -1", ret.Code)
+ if got := response.Code(); -1 != got {
+ t.Fatalf("unexpected result code: got %d, want -1", got)
}
if !isInvalidWorkspacePath(workspaceBaseDir) {
t.Fatal("mobile workspace base dir should be excluded from workspace discovery")
diff --git a/kernel/apicontract/response.go b/kernel/apicontract/response.go
index 06a70357a0..b528e4f275 100644
--- a/kernel/apicontract/response.go
+++ b/kernel/apicontract/response.go
@@ -2,6 +2,7 @@ package apicontract
import (
"encoding/json"
+ "errors"
"fmt"
"mime"
"net/http"
@@ -185,6 +186,10 @@ func (e Endpoint[Request, Data]) WithHTTPStatus(response Response[Data], status
func Success[Data any](data Data) Response[Data] { return Response[Data]{data: data} }
+// SuccessWithoutData 返回不带数据的成功响应,data 序列化为 null。
+// 用于只做副作用、调用方不读取返回值的端点。
+func SuccessWithoutData[Data any]() Response[Data] { return Response[Data]{} }
+
// SuccessWithMessage 保留成功响应中的提示,例如批量上传中部分文件未完成。
func SuccessWithMessage[Data any](data Data, message string) Response[Data] {
return Response[Data]{data: data, msg: message}
@@ -205,6 +210,31 @@ func FailureWithTimeout[Data any](code int, msg string, milliseconds int) Respon
}{milliseconds}}
}
+// Rejection 是校验辅助函数产生的业务错误:线上错误码与消息。
+// 辅助函数返回它而不是往调用方持有的信封里写字段,校验只需判断,处理函数负责转成响应。
+type Rejection struct {
+ Code int
+ Msg string
+}
+
+func (r *Rejection) Error() string { return r.Msg }
+
+// Reject 构造一次默认错误码 -1 的校验失败。
+func Reject(msg string) *Rejection { return &Rejection{Code: -1, Msg: msg} }
+
+// RejectWith 构造一次指定错误码的校验失败,用于 HTTP 状态码等既有约定。
+func RejectWith(code int, msg string) *Rejection { return &Rejection{Code: code, Msg: msg} }
+
+// FailureFrom 把校验错误转成失败响应,保留 Rejection 携带的错误码;
+// 其他错误按业务失败处理,使用 -1。
+func FailureFrom[Data any](err error) Response[Data] {
+ var rejection *Rejection
+ if errors.As(err, &rejection) {
+ return Failure[Data](rejection.Code, rejection.Msg)
+ }
+ return Failure[Data](-1, err.Error())
+}
+
func (r Response[Data]) MarshalJSON() ([]byte, error) {
return r.MarshalWith(json.Marshal)
}
diff --git a/kernel/model/cloud_service.go b/kernel/model/cloud_service.go
index 8c1de09847..99702e7781 100644
--- a/kernel/model/cloud_service.go
+++ b/kernel/model/cloud_service.go
@@ -18,6 +18,7 @@ package model
import (
"encoding/hex"
+ "encoding/json"
"errors"
"fmt"
"net/http"
@@ -32,6 +33,7 @@ import (
"github.com/88250/lute/parse"
"github.com/siyuan-note/httpclient"
"github.com/siyuan-note/logging"
+ "github.com/siyuan-note/siyuan/kernel/apicontract"
"github.com/siyuan-note/siyuan/kernel/conf"
"github.com/siyuan-note/siyuan/kernel/task"
"github.com/siyuan-note/siyuan/kernel/util"
@@ -826,16 +828,15 @@ func CheckActivationcode(code string) (retCode int, msg string) {
return
}
-func Login(userName, password, captcha string, cloudRegion int) (ret *gulu.Result) {
+// Login 登录思源云端账号。code 沿用云端约定:0 成功,1 需要输入验证码,其他值为失败;
+// 请求本身失败时使用 -1 并给出本地提示。data 为对应的账号载荷,失败时为 nil。
+func Login(userName, password, captcha string, cloudRegion int) (data *apicontract.AccountLoginData, code int, msg string) {
release := lockAssetSourceChange()
defer release()
previousCloudRegion := util.CurrentCloudRegion
if Conf.Sync.Load().Provider == conf.ProviderSiYuan && previousCloudRegion != cloudRegion {
if err := requireCompleteAssetDownloads(); err != nil {
- ret = gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = err.Error()
- return
+ return nil, -1, err.Error()
}
}
cloudAccountMu.Lock()
@@ -856,35 +857,48 @@ func Login(userName, password, captcha string, cloudRegion int) (ret *gulu.Resul
Post(util.GetCloudServer() + "/apis/siyuan/login")
if err != nil {
logging.LogErrorf("login failed: %s", err)
- ret = gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = Conf.Language(18) + ": " + err.Error()
- return
+ return nil, -1, Conf.Language(18) + ": " + err.Error()
}
if http.StatusOK != resp.StatusCode {
logging.LogErrorf("login failed: %d", resp.StatusCode)
- ret = gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = Conf.Language(18)
- return
+ return nil, -1, Conf.Language(18)
}
- ret = &gulu.Result{
- Code: int(result["code"].(float64)),
- Msg: result["msg"].(string),
- Data: map[string]any{
- "userName": result["userName"],
- "token": result["token"],
- "needCaptcha": result["needCaptcha"], // 值为 user id
- },
+ cloudCode, codeOK := result["code"].(float64)
+ cloudMsg, msgOK := result["msg"].(string)
+ if !codeOK || !msgOK {
+ logging.LogErrorf("login failed: invalid cloud response")
+ return nil, -1, Conf.Language(18)
+ }
+
+ data = &apicontract.AccountLoginData{}
+ for key, target := range map[string]**string{
+ "userName": &data.UserName,
+ "token": &data.Token,
+ "needCaptcha": &data.NeedCaptcha,
+ } {
+ value, exists := result[key]
+ if !exists || nil == value {
+ continue
+ }
+ text, isString := value.(string)
+ if !isString {
+ logging.LogErrorf("login failed: invalid cloud response field [%s]", key)
+ return nil, -1, Conf.Language(18)
+ }
+ *target = &text
}
- if -1 == ret.Code {
- ret.Code = 1
+
+ code = int(cloudCode)
+ if -1 == code {
+ code = 1
}
- return
+ return data, code, cloudMsg
}
-func Login2fa(token, code string) (ret *gulu.Result) {
+// Login2fa 提交双因素认证码,返回直接输出的响应信封。
+// 云端结果的 code 会重映射:失败(-1)转为 1,以免与本地错误码混淆。
+func Login2fa(token, code string) *apicontract.Login2faEnvelope {
result := map[string]any{}
// 两步验证登录不是幂等操作,关闭自动重试以避免重复登录。
request := httpclient.NewCloudRequest30s().SetRetryCount(0)
@@ -895,46 +909,40 @@ func Login2fa(token, code string) (ret *gulu.Result) {
Post(util.GetCloudServer() + "/apis/siyuan/login/2fa")
if err != nil {
logging.LogErrorf("login 2fa failed: %s", err)
- return failedLogin2faResult()
+ return failedLogin2faEnvelope()
}
if http.StatusOK != resp.StatusCode {
logging.LogErrorf("login 2fa failed: %d", resp.StatusCode)
- return failedLogin2faResult()
+ return failedLogin2faEnvelope()
}
- ret, ok := parseLogin2faResult(result)
+ envelope, ok := parseLogin2faEnvelope(result)
if !ok {
logging.LogErrorf("login 2fa failed: invalid cloud response")
- return failedLogin2faResult()
+ return failedLogin2faEnvelope()
}
- return
+ return envelope
}
-func failedLogin2faResult() *gulu.Result {
- ret := gulu.Ret.NewResult()
- ret.Code = -1
- ret.Msg = Conf.Language(18)
- return ret
+func failedLogin2faEnvelope() *apicontract.Login2faEnvelope {
+ return &apicontract.Login2faEnvelope{Code: -1, Msg: Conf.Language(18)}
}
-func parseLogin2faResult(result map[string]any) (ret *gulu.Result, ok bool) {
- code, codeOK := result["code"].(float64)
- msg, msgOK := result["msg"].(string)
- if !codeOK || !msgOK {
+// parseLogin2faEnvelope 按契约声明校验云端结果,并把其余字段保留为协议扩展字段。
+func parseLogin2faEnvelope(result map[string]any) (envelope *apicontract.Login2faEnvelope, ok bool) {
+ raw, err := json.Marshal(result)
+ if err != nil {
return nil, false
}
- if 0 == code {
- token, tokenOK := result["token"].(string)
- if !tokenOK || "" == token {
- return nil, false
- }
+ data := &apicontract.CloudLogin2faData{}
+ if err = json.Unmarshal(raw, data); err != nil {
+ return nil, false
}
-
- ret = &gulu.Result{Code: int(code), Msg: msg, Data: result}
- if -1 == ret.Code {
- ret.Code = 1
+ code := int(data.Code)
+ if -1 == code {
+ code = 1
}
- return ret, true
+ return &apicontract.Login2faEnvelope{Code: code, Msg: data.Msg, Data: data}, true
}
func LogoutUser() {
diff --git a/kernel/model/cloud_service_asset_source_test.go b/kernel/model/cloud_service_asset_source_test.go
index 32b30692e0..3314ae42be 100644
--- a/kernel/model/cloud_service_asset_source_test.go
+++ b/kernel/model/cloud_service_asset_source_test.go
@@ -116,9 +116,9 @@ func testCloudAssetSourceAllowsOriginalAccountAfterLogout(t *testing.T, logout f
if err = checkAssetDownloadAccess(); err == nil {
t.Fatal("cloud asset downloads accepted without a cloud session")
}
- result := Login("different-owner", "unused-password", "", 1)
- if result.Code == 0 || Conf.CloudRegion != 0 || util.CurrentCloudRegion != 0 {
- t.Fatalf("cross-region login changed the source: result=%v, region=%d", result, util.CurrentCloudRegion)
+ _, code, _ := Login("different-owner", "unused-password", "", 1)
+ if code == 0 || Conf.CloudRegion != 0 || util.CurrentCloudRegion != 0 {
+ t.Fatalf("cross-region login changed the source: code=%d, region=%d", code, util.CurrentCloudRegion)
}
if err = DeactivateUser(); err == nil {
t.Fatal("account deactivation accepted despite undownloaded data")
@@ -129,9 +129,9 @@ func testCloudAssetSourceAllowsOriginalAccountAfterLogout(t *testing.T, logout f
if err = validateCloudUserAssetSource(owner); !IsCloudAssetSourceChange(err) {
t.Fatalf("missing asset state was accepted during authentication: %v", err)
}
- result = Login("different-owner", "unused-password", "", 1)
- if result.Code == 0 || Conf.CloudRegion != 0 || util.CurrentCloudRegion != 0 {
- t.Fatalf("cross-region login discarded a source with missing state: %v", result)
+ _, code, _ = Login("different-owner", "unused-password", "", 1)
+ if code == 0 || Conf.CloudRegion != 0 || util.CurrentCloudRegion != 0 {
+ t.Fatalf("cross-region login discarded a source with missing state: code=%d", code)
}
if _, err = os.Stat(filepath.Join(util.RepoDir, "asset-downloads-v1")); err != nil {
t.Fatalf("missing-state protection removed the repository marker: %v", err)
diff --git a/kernel/model/cloud_service_login_test.go b/kernel/model/cloud_service_login_test.go
index d17bd75ef7..8234587b64 100644
--- a/kernel/model/cloud_service_login_test.go
+++ b/kernel/model/cloud_service_login_test.go
@@ -17,13 +17,24 @@
package model
import (
+ "encoding/json"
"reflect"
"testing"
"github.com/siyuan-note/siyuan/kernel/conf"
)
-func TestParseLogin2faResult(t *testing.T) {
+// mustMarshal 把测试数据编码为 JSON,失败即终止用例。
+func mustMarshal(t *testing.T, value any) []byte {
+ t.Helper()
+ encoded, err := json.Marshal(value)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return encoded
+}
+
+func TestParseLogin2faEnvelope(t *testing.T) {
tests := []struct {
name string
result map[string]any
@@ -56,21 +67,33 @@ func TestParseLogin2faResult(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
- result, ok := parseLogin2faResult(test.result)
+ envelope, ok := parseLogin2faEnvelope(test.result)
if test.ok != ok {
t.Fatalf("unexpected parse status [expected=%t, actual=%t]", test.ok, ok)
}
if !test.ok {
- if nil != result {
- t.Fatalf("unexpected result [%+v]", result)
+ if nil != envelope {
+ t.Fatalf("unexpected envelope [%+v]", envelope)
}
return
}
- if test.expectedCode != result.Code {
- t.Fatalf("unexpected code [expected=%d, actual=%d]", test.expectedCode, result.Code)
+ if test.expectedCode != envelope.Code {
+ t.Fatalf("unexpected code [expected=%d, actual=%d]", test.expectedCode, envelope.Code)
+ }
+ // 载荷必须原样保留云端结果的全部字段(含协议扩展字段),以便直接输出。
+ encoded, err := json.Marshal(envelope.Data)
+ if err != nil {
+ t.Fatal(err)
+ }
+ var got, want map[string]any
+ if err = json.Unmarshal(encoded, &got); err != nil {
+ t.Fatal(err)
+ }
+ if err = json.Unmarshal(mustMarshal(t, test.result), &want); err != nil {
+ t.Fatal(err)
}
- if !reflect.DeepEqual(result.Data, test.result) {
- t.Fatalf("response data was not preserved")
+ if !reflect.DeepEqual(want, got) {
+ t.Fatalf("response data was not preserved: %s", encoded)
}
})
}
diff --git a/kernel/util/net.go b/kernel/util/net.go
index 610b6456b5..9a9b4ebee3 100644
--- a/kernel/util/net.go
+++ b/kernel/util/net.go
@@ -20,7 +20,6 @@ import (
"context"
"errors"
"fmt"
- "io"
"net"
"net/http"
"net/url"
@@ -31,7 +30,6 @@ import (
"syscall"
"time"
- "github.com/88250/gulu"
"github.com/88250/lute/ast"
"github.com/gin-gonic/gin"
"github.com/imroc/req/v3"
@@ -425,24 +423,6 @@ func GetRemoteAddr(req *http.Request) string {
return strings.Split(ret, ",")[0]
}
-func JsonArg(c *gin.Context, result *gulu.Result) (arg map[string]any, ok bool) {
- arg = map[string]any{}
- if err := c.ShouldBindJSON(&arg); err != nil {
- result.Code = -1
- var detail string
- if errors.Is(err, io.EOF) {
- detail = "the request body is empty or truncated (EOF)"
- } else {
- detail = err.Error()
- }
- result.Msg = fmt.Sprintf("Parses request [%s] failed: %s", c.Request.URL.Path, detail)
- return
- }
-
- ok = true
- return
-}
-
// GetRequestUrlStringParam extracts a string parameter from URL (path or query parameters).
func GetRequestUrlStringParam(c *gin.Context, key string) string {
// /path/:name
@@ -458,107 +438,25 @@ func GetRequestUrlStringParam(c *gin.Context, key string) string {
return ""
}
-// ParseJsonArg 使用泛型从 JSON 参数中提取指定键的值。
-// - 如果 required 为 true 但参数缺失,则会在 ret.Msg 中说明需要传入的键
-// - 如果 rejectEmpty 为 true 但参数值为空,则会在 ret.Msg 中说明该键必须不为空(字符串去空白后、空数组、无任何键的对象)
-// - 如果参数存在但类型不匹配,则会在 ret.Msg 中说明该键期望的类型
-// - 返回值 ok 为 false 时,表示提取失败、类型不匹配或不满足非空约束
-func ParseJsonArg[T any](key string, arg map[string]any, ret *gulu.Result, required, rejectEmpty bool) (value T, ok bool) {
- raw, exists := arg[key]
- if !exists || raw == nil {
- if required {
- ret.Code = -1
- ret.Msg = fmt.Sprintf("Field [%s] is required", key)
- } else {
- ok = true
- }
- return
- }
-
- value, ok = raw.(T)
- if !ok {
- var zero T
- ret.Code = -1
-
- // 返回对应的 JSON 类型
- jsonType := ""
- switch any(zero).(type) {
- case string:
- jsonType = "String"
- case float64:
- jsonType = "Number"
- case bool:
- jsonType = "Boolean"
- case []any:
- jsonType = "Array"
- case map[string]any:
- jsonType = "Object"
- default:
- jsonType = fmt.Sprintf("%T", zero)
- }
-
- ret.Msg = fmt.Sprintf("Field [%s] should be of type [%s]", key, jsonType)
- return
- }
+// ErrInvalidID 表示块或笔记本 ID 不是合法的 SiYuan ID 形态。
+var ErrInvalidID = errors.New("invalid ID argument")
- if rejectEmpty {
- var bad bool
- switch x := any(value).(type) {
- case string:
- if t := strings.TrimSpace(x); t == "" {
- bad = true
- } else {
- value = any(t).(T)
- }
- case []any:
- bad = len(x) == 0
- case map[string]any:
- bad = len(x) == 0
- }
- if bad {
- ret.Code = -1
- ret.Msg = fmt.Sprintf("Field [%s] must not be empty", key)
- ok = false
- }
- }
- return
-}
-
-// JsonArgParseFunc 为单次提取函数,用于 ParseJsonArgs 批量提取。
-type JsonArgParseFunc func(arg map[string]any, ret *gulu.Result) bool
-
-// BindJsonArg 创建一个提取函数:从 arg 取 key 并写入 dest,供 ParseJsonArgs 使用。
-func BindJsonArg[T any](key string, dest *T, required, rejectEmpty bool) JsonArgParseFunc {
- return func(arg map[string]any, ret *gulu.Result) bool {
- v, ok := ParseJsonArg[T](key, arg, ret, required, rejectEmpty)
- if !ok {
- return false
- }
- *dest = v
- return true
- }
-}
-
-// ParseJsonArgs 按顺序执行多个提取函数。
-// - 任一失败返回 false 并在 ret 中写入错误信息
-// - 全部成功返回 true
-func ParseJsonArgs(arg map[string]any, ret *gulu.Result, extractors ...JsonArgParseFunc) bool {
- for _, ext := range extractors {
- if !ext(arg, ret) {
- return false
- }
+// ValidateID 检查块或笔记本 ID 形态,不合法时返回 ErrInvalidID。
+// 返回错误而不是往调用方的信封里写字,让调用方决定用哪个错误码响应。
+func ValidateID(idArg string) error {
+ if ast.IsNodeIDPattern(idArg) {
+ return nil
}
- return true
+ return ErrInvalidID
}
-func InvalidIDPattern(idArg string, result *gulu.Result) bool {
- if ast.IsNodeIDPattern(idArg) {
- return false
+// ValidateOptionalID 与 ValidateID 相同,但把空字符串视为「未提供」而非非法值。
+// 用于可选的对端 ID 等参数,避免调用方各自重复判空。
+func ValidateOptionalID(idArg string) error {
+ if idArg == "" {
+ return nil
}
-
- result.Code = -1
- result.Msg = "invalid ID argument"
- return true
+ return ValidateID(idArg)
}
func initHttpClient() {