YourSelfHosted/memos
1
0
Fork 0
mirror of https://github.com/usememos/memos.git synced 2025-06-05 22:09:59 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor: memo store (#1741)

Browse Source
This commit is contained in:
boojack
2023-05-25 21:50:37 +08:00
committed by GitHub
parent 43819b021e
commit ea728d232d
16 changed files with 528 additions and 543 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
api/memo.go
View File

@ -1,8 +1,5 @@
package api package api
// MaxContentLength means the max memo content bytes is 1MB.
const MaxContentLength = 1 << 30
// Visibility is the type of a visibility. // Visibility is the type of a visibility.
type Visibility string type Visibility string
@ -15,8 +12,8 @@ const (
Private Visibility = "PRIVATE" Private Visibility = "PRIVATE"
) )
func (e Visibility) String() string { func (v Visibility) String() string {
switch e { switch v {
case Public: case Public:
return "PUBLIC" return "PUBLIC"
case Protected: case Protected:
@ -27,7 +24,7 @@ func (e Visibility) String() string {
return "PRIVATE" return "PRIVATE"
} }
type Memo struct { type MemoResponse struct {
ID int `json:"id"` ID int `json:"id"`
// Standard fields // Standard fields
@ -42,12 +39,13 @@ type Memo struct {
Pinned bool `json:"pinned"` Pinned bool `json:"pinned"`
// Related fields // Related fields
CreatorName string `json:"creatorName"` CreatorName string `json:"creatorName"`
ResourceList []*Resource `json:"resourceList"` ResourceIDList []int
RelationList []*MemoRelation `json:"relationList"` ResourceList []*Resource `json:"resourceList"`
RelationList []*MemoRelation `json:"relationList"`
} }
type MemoCreate struct { type CreateMemoRequest struct {
// Standard fields // Standard fields
CreatorID int `json:"-"` CreatorID int `json:"-"`
CreatedTs *int64 `json:"createdTs"` CreatedTs *int64 `json:"createdTs"`
@ -61,7 +59,7 @@ type MemoCreate struct {
RelationList []*MemoRelationUpsert `json:"relationList"` RelationList []*MemoRelationUpsert `json:"relationList"`
} }
type MemoPatch struct { type PatchMemoRequest struct {
ID int `json:"-"` ID int `json:"-"`
// Standard fields // Standard fields
@ -78,7 +76,7 @@ type MemoPatch struct {
RelationList []*MemoRelationUpsert `json:"relationList"` RelationList []*MemoRelationUpsert `json:"relationList"`
} }
type MemoFind struct { type FindMemoRequest struct {
ID *int ID *int
// Standard fields // Standard fields
@ -94,7 +92,3 @@ type MemoFind struct {
Limit *int Limit *int
Offset *int Offset *int
} }
type MemoDelete struct {
ID int
}

336
server/memo.go
View File

@ -1,6 +1,7 @@
package server package server
import ( import (
"context"
"encoding/json" "encoding/json"
"fmt" "fmt"
"net/http" "net/http"
@ -16,6 +17,9 @@ import (
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
) )
// maxContentLength means the max memo content bytes is 1MB.
const maxContentLength = 1 << 30
func (s *Server) registerMemoRoutes(g *echo.Group) { func (s *Server) registerMemoRoutes(g *echo.Group) {
g.POST("/memo", func(c echo.Context) error { g.POST("/memo", func(c echo.Context) error {
ctx := c.Request().Context() ctx := c.Request().Context()
@ -24,12 +28,15 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
return echo.NewHTTPError(http.StatusUnauthorized, "Missing user in session") return echo.NewHTTPError(http.StatusUnauthorized, "Missing user in session")
} }
memoCreate := &api.MemoCreate{} createMemoRequest := &api.CreateMemoRequest{}
if err := json.NewDecoder(c.Request().Body).Decode(memoCreate); err != nil { if err := json.NewDecoder(c.Request().Body).Decode(createMemoRequest); err != nil {
return echo.NewHTTPError(http.StatusBadRequest, "Malformatted post memo request").SetInternal(err) return echo.NewHTTPError(http.StatusBadRequest, "Malformatted post memo request").SetInternal(err)
} }
if len(createMemoRequest.Content) > maxContentLength {
return echo.NewHTTPError(http.StatusBadRequest, "Content size overflow, up to 1MB")
}
if memoCreate.Visibility == "" { if createMemoRequest.Visibility == "" {
userMemoVisibilitySetting, err := s.Store.FindUserSetting(ctx, &api.UserSettingFind{ userMemoVisibilitySetting, err := s.Store.FindUserSetting(ctx, &api.UserSettingFind{
UserID: userID, UserID: userID,
Key: api.UserSettingMemoVisibilityKey, Key: api.UserSettingMemoVisibilityKey,
@ -44,14 +51,14 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to unmarshal user setting value").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to unmarshal user setting value").SetInternal(err)
} }
memoCreate.Visibility = memoVisibility createMemoRequest.Visibility = memoVisibility
} else { } else {
// Private is the default memo visibility. // Private is the default memo visibility.
memoCreate.Visibility = api.Private createMemoRequest.Visibility = api.Private
} }
} }
// Find system settings // Find disable public memos system setting.
disablePublicMemosSystemSetting, err := s.Store.FindSystemSetting(ctx, &api.SystemSettingFind{ disablePublicMemosSystemSetting, err := s.Store.FindSystemSetting(ctx, &api.SystemSettingFind{
Name: api.SystemSettingDisablePublicMemosName, Name: api.SystemSettingDisablePublicMemosName,
}) })
@ -65,46 +72,40 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to unmarshal system setting").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to unmarshal system setting").SetInternal(err)
} }
if disablePublicMemos { if disablePublicMemos {
// Allow if the user is an admin.
user, err := s.Store.FindUser(ctx, &api.UserFind{ user, err := s.Store.FindUser(ctx, &api.UserFind{
ID: &userID, ID: &userID,
}) })
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find user").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find user").SetInternal(err)
} }
// Only enforce private if you're a regular user. // Enforce normal user to create private memo if public memos are disabled.
// Admins should know what they're doing.
if user.Role == "USER" { if user.Role == "USER" {
memoCreate.Visibility = api.Private createMemoRequest.Visibility = api.Private
} }
} }
} }
if len(memoCreate.Content) > api.MaxContentLength { createMemoRequest.CreatorID = userID
return echo.NewHTTPError(http.StatusBadRequest, "Content size overflow, up to 1MB").SetInternal(err) memoMessage, err := s.Store.CreateMemo(ctx, convertCreateMemoRequestToMemoMessage(createMemoRequest))
}
memoCreate.CreatorID = userID
memo, err := s.Store.CreateMemo(ctx, memoCreate)
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create memo").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create memo").SetInternal(err)
} }
if err := s.createMemoCreateActivity(c, memo); err != nil { if err := s.createMemoCreateActivity(c, memoMessage); err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create activity").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create activity").SetInternal(err)
} }
for _, resourceID := range memoCreate.ResourceIDList { for _, resourceID := range createMemoRequest.ResourceIDList {
if _, err := s.Store.UpsertMemoResource(ctx, &api.MemoResourceUpsert{ if _, err := s.Store.UpsertMemoResource(ctx, &api.MemoResourceUpsert{
MemoID: memo.ID, MemoID: memoMessage.ID,
ResourceID: resourceID, ResourceID: resourceID,
}); err != nil { }); err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo resource").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo resource").SetInternal(err)
} }
} }
for _, memoRelationUpsert := range memoCreate.RelationList { for _, memoRelationUpsert := range createMemoRequest.RelationList {
if _, err := s.Store.UpsertMemoRelation(ctx, &store.MemoRelationMessage{ if _, err := s.Store.UpsertMemoRelation(ctx, &store.MemoRelationMessage{
MemoID: memo.ID, MemoID: memoMessage.ID,
RelatedMemoID: memoRelationUpsert.RelatedMemoID, RelatedMemoID: memoRelationUpsert.RelatedMemoID,
Type: store.MemoRelationType(memoRelationUpsert.Type), Type: store.MemoRelationType(memoRelationUpsert.Type),
}); err != nil { }); err != nil {
@ -112,11 +113,17 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
} }
} }
memo, err = s.Store.ComposeMemo(ctx, memo) memoMessage, err = s.Store.GetMemo(ctx, &store.FindMemoMessage{
ID: &memoMessage.ID,
})
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo").SetInternal(err)
} }
return c.JSON(http.StatusOK, composeResponse(memo)) memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
}
return c.JSON(http.StatusOK, composeResponse(memoResponse))
}) })
g.PATCH("/memo/:memoId", func(c echo.Context) error { g.PATCH("/memo/:memoId", func(c echo.Context) error {
@ -131,47 +138,58 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("ID is not a number: %s", c.Param("memoId"))).SetInternal(err) return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("ID is not a number: %s", c.Param("memoId"))).SetInternal(err)
} }
memo, err := s.Store.FindMemo(ctx, &api.MemoFind{ memoMessage, err := s.Store.GetMemo(ctx, &store.FindMemoMessage{
ID: &memoID, ID: &memoID,
}) })
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo").SetInternal(err)
} }
if memo.CreatorID != userID { if memoMessage.CreatorID != userID {
return echo.NewHTTPError(http.StatusUnauthorized, "Unauthorized") return echo.NewHTTPError(http.StatusUnauthorized, "Unauthorized")
} }
currentTs := time.Now().Unix() currentTs := time.Now().Unix()
memoPatch := &api.MemoPatch{ patchMemoRequest := &api.PatchMemoRequest{
ID: memoID, ID: memoID,
UpdatedTs: &currentTs, UpdatedTs: &currentTs,
} }
if err := json.NewDecoder(c.Request().Body).Decode(memoPatch); err != nil { if err := json.NewDecoder(c.Request().Body).Decode(patchMemoRequest); err != nil {
return echo.NewHTTPError(http.StatusBadRequest, "Malformatted patch memo request").SetInternal(err) return echo.NewHTTPError(http.StatusBadRequest, "Malformatted patch memo request").SetInternal(err)
} }
if memoPatch.Content != nil && len(*memoPatch.Content) > api.MaxContentLength { if patchMemoRequest.Content != nil && len(*patchMemoRequest.Content) > maxContentLength {
return echo.NewHTTPError(http.StatusBadRequest, "Content size overflow, up to 1MB").SetInternal(err) return echo.NewHTTPError(http.StatusBadRequest, "Content size overflow, up to 1MB").SetInternal(err)
} }
memo, err = s.Store.PatchMemo(ctx, memoPatch) updateMemoMessage := &store.UpdateMemoMessage{
ID: memoID,
CreatedTs: patchMemoRequest.CreatedTs,
UpdatedTs: patchMemoRequest.UpdatedTs,
Content: patchMemoRequest.Content,
}
if patchMemoRequest.RowStatus != nil {
rowStatus := store.RowStatus(patchMemoRequest.RowStatus.String())
updateMemoMessage.RowStatus = &rowStatus
}
if patchMemoRequest.Visibility != nil {
visibility := store.Visibility(patchMemoRequest.Visibility.String())
updateMemoMessage.Visibility = &visibility
}
err = s.Store.UpdateMemo(ctx, updateMemoMessage)
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to patch memo").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to patch memo").SetInternal(err)
} }
memo, err = s.Store.ComposeMemo(ctx, memo) memoMessage, err = s.Store.GetMemo(ctx, &store.FindMemoMessage{ID: &memoID})
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo").SetInternal(err)
} }
if memoPatch.ResourceIDList != nil { if patchMemoRequest.ResourceIDList != nil {
resourceIDList := make([]int, 0) addedResourceIDList, removedResourceIDList := getIDListDiff(memoMessage.ResourceIDList, patchMemoRequest.ResourceIDList)
for _, resource := range memo.ResourceList {
resourceIDList = append(resourceIDList, resource.ID)
}
addedResourceIDList, removedResourceIDList := getIDListDiff(resourceIDList, memoPatch.ResourceIDList)
for _, resourceID := range addedResourceIDList { for _, resourceID := range addedResourceIDList {
if _, err := s.Store.UpsertMemoResource(ctx, &api.MemoResourceUpsert{ if _, err := s.Store.UpsertMemoResource(ctx, &api.MemoResourceUpsert{
MemoID: memo.ID, MemoID: memoMessage.ID,
ResourceID: resourceID, ResourceID: resourceID,
}); err != nil { }); err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo resource").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo resource").SetInternal(err)
@ -179,7 +197,7 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
} }
for _, resourceID := range removedResourceIDList { for _, resourceID := range removedResourceIDList {
if err := s.Store.DeleteMemoResource(ctx, &api.MemoResourceDelete{ if err := s.Store.DeleteMemoResource(ctx, &api.MemoResourceDelete{
MemoID: &memo.ID, MemoID: &memoMessage.ID,
ResourceID: &resourceID, ResourceID: &resourceID,
}); err != nil { }); err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to delete memo resource").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to delete memo resource").SetInternal(err)
@ -187,100 +205,106 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
} }
} }
if memoPatch.RelationList != nil { if patchMemoRequest.RelationList != nil {
patchMemoRelationList := make([]*api.MemoRelation, 0) patchMemoRelationList := make([]*store.MemoRelationMessage, 0)
for _, memoRelationUpsert := range memoPatch.RelationList { for _, memoRelation := range patchMemoRequest.RelationList {
patchMemoRelationList = append(patchMemoRelationList, &api.MemoRelation{ patchMemoRelationList = append(patchMemoRelationList, &store.MemoRelationMessage{
MemoID: memo.ID, MemoID: memoMessage.ID,
RelatedMemoID: memoRelationUpsert.RelatedMemoID,
Type: memoRelationUpsert.Type,
})
}
addedMemoRelationList, removedMemoRelationList := getMemoRelationListDiff(memo.RelationList, patchMemoRelationList)
for _, memoRelation := range addedMemoRelationList {
if _, err := s.Store.UpsertMemoRelation(ctx, &store.MemoRelationMessage{
MemoID: memo.ID,
RelatedMemoID: memoRelation.RelatedMemoID, RelatedMemoID: memoRelation.RelatedMemoID,
Type: store.MemoRelationType(memoRelation.Type), Type: store.MemoRelationType(memoRelation.Type),
}); err != nil { })
}
addedMemoRelationList, removedMemoRelationList := getMemoRelationListDiff(memoMessage.RelationList, patchMemoRelationList)
for _, memoRelation := range addedMemoRelationList {
if _, err := s.Store.UpsertMemoRelation(ctx, memoRelation); err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo relation").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo relation").SetInternal(err)
} }
} }
for _, memoRelation := range removedMemoRelationList { for _, memoRelation := range removedMemoRelationList {
memoRelationType := store.MemoRelationType(memoRelation.Type)
if err := s.Store.DeleteMemoRelation(ctx, &store.DeleteMemoRelationMessage{ if err := s.Store.DeleteMemoRelation(ctx, &store.DeleteMemoRelationMessage{
MemoID: &memo.ID, MemoID: &memoMessage.ID,
RelatedMemoID: &memoRelation.RelatedMemoID, RelatedMemoID: &memoRelation.RelatedMemoID,
Type: &memoRelationType, Type: &memoRelation.Type,
}); err != nil { }); err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to delete memo relation").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to delete memo relation").SetInternal(err)
} }
} }
} }
// After patching memo resources and relations, we need to re-compose it to get the latest data. memoMessage, err = s.Store.GetMemo(ctx, &store.FindMemoMessage{ID: &memoID})
memo, err = s.Store.ComposeMemo(ctx, memo)
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo").SetInternal(err)
} }
return c.JSON(http.StatusOK, composeResponse(memo)) memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
}
return c.JSON(http.StatusOK, composeResponse(memoResponse))
}) })
g.GET("/memo", func(c echo.Context) error { g.GET("/memo", func(c echo.Context) error {
ctx := c.Request().Context() ctx := c.Request().Context()
memoFind := &api.MemoFind{} findMemoMessage := &store.FindMemoMessage{}
if userID, err := strconv.Atoi(c.QueryParam("creatorId")); err == nil { if userID, err := strconv.Atoi(c.QueryParam("creatorId")); err == nil {
memoFind.CreatorID = &userID findMemoMessage.CreatorID = &userID
} }
currentUserID, ok := c.Get(getUserIDContextKey()).(int) currentUserID, ok := c.Get(getUserIDContextKey()).(int)
if !ok { if !ok {
if memoFind.CreatorID == nil { if findMemoMessage.CreatorID == nil {
return echo.NewHTTPError(http.StatusBadRequest, "Missing user id to find memo") return echo.NewHTTPError(http.StatusBadRequest, "Missing user id to find memo")
} }
memoFind.VisibilityList = []api.Visibility{api.Public} findMemoMessage.VisibilityList = []store.Visibility{store.Public}
} else { } else {
if memoFind.CreatorID == nil { if findMemoMessage.CreatorID == nil {
memoFind.CreatorID = &currentUserID findMemoMessage.CreatorID = &currentUserID
} else { } else {
memoFind.VisibilityList = []api.Visibility{api.Public, api.Protected} findMemoMessage.VisibilityList = []store.Visibility{store.Public, store.Protected}
} }
} }
rowStatus := api.RowStatus(c.QueryParam("rowStatus")) rowStatus := store.RowStatus(c.QueryParam("rowStatus"))
if rowStatus != "" { if rowStatus != "" {
memoFind.RowStatus = &rowStatus findMemoMessage.RowStatus = &rowStatus
} }
pinnedStr := c.QueryParam("pinned") pinnedStr := c.QueryParam("pinned")
if pinnedStr != "" { if pinnedStr != "" {
pinned := pinnedStr == "true" pinned := pinnedStr == "true"
memoFind.Pinned = &pinned findMemoMessage.Pinned = &pinned
} }
tag := c.QueryParam("tag") tag := c.QueryParam("tag")
if tag != "" { if tag != "" {
contentSearch := "#" + tag contentSearch := "#" + tag
memoFind.ContentSearch = &contentSearch findMemoMessage.ContentSearch = &contentSearch
} }
visibilityListStr := c.QueryParam("visibility") visibilityListStr := c.QueryParam("visibility")
if visibilityListStr != "" { if visibilityListStr != "" {
visibilityList := []api.Visibility{} visibilityList := []store.Visibility{}
for _, visibility := range strings.Split(visibilityListStr, ",") { for _, visibility := range strings.Split(visibilityListStr, ",") {
visibilityList = append(visibilityList, api.Visibility(visibility)) visibilityList = append(visibilityList, store.Visibility(visibility))
} }
memoFind.VisibilityList = visibilityList findMemoMessage.VisibilityList = visibilityList
} }
if limit, err := strconv.Atoi(c.QueryParam("limit")); err == nil { if limit, err := strconv.Atoi(c.QueryParam("limit")); err == nil {
memoFind.Limit = &limit findMemoMessage.Limit = &limit
} }
if offset, err := strconv.Atoi(c.QueryParam("offset")); err == nil { if offset, err := strconv.Atoi(c.QueryParam("offset")); err == nil {
memoFind.Offset = &offset findMemoMessage.Offset = &offset
} }
list, err := s.Store.FindMemoList(ctx, memoFind) memoMessageList, err := s.Store.ListMemos(ctx, findMemoMessage)
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to fetch memo list").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to fetch memo list").SetInternal(err)
} }
return c.JSON(http.StatusOK, composeResponse(list)) memoResponseList := []*api.MemoResponse{}
for _, memoMessage := range memoMessageList {
memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
}
memoResponseList = append(memoResponseList, memoResponse)
}
return c.JSON(http.StatusOK, composeResponse(memoResponseList))
}) })
g.GET("/memo/:memoId", func(c echo.Context) error { g.GET("/memo/:memoId", func(c echo.Context) error {
@ -290,29 +314,31 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("ID is not a number: %s", c.Param("memoId"))).SetInternal(err) return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("ID is not a number: %s", c.Param("memoId"))).SetInternal(err)
} }
memoFind := &api.MemoFind{ memoMessage, err := s.Store.GetMemo(ctx, &store.FindMemoMessage{
ID: &memoID, ID: &memoID,
} })
memo, err := s.Store.FindMemo(ctx, memoFind)
if err != nil { if err != nil {
if common.ErrorCode(err) == common.NotFound { if common.ErrorCode(err) == common.NotFound {
return echo.NewHTTPError(http.StatusNotFound, fmt.Sprintf("Memo ID not found: %d", memoID)).SetInternal(err) return echo.NewHTTPError(http.StatusNotFound, fmt.Sprintf("Memo ID not found: %d", memoID)).SetInternal(err)
} }
return echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("Failed to find memo by ID: %v", memoID)).SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("Failed to find memo by ID: %v", memoID)).SetInternal(err)
} }
userID, ok := c.Get(getUserIDContextKey()).(int) userID, ok := c.Get(getUserIDContextKey()).(int)
if memo.Visibility == api.Private { if memoMessage.Visibility == store.Private {
if !ok || memo.CreatorID != userID { if !ok || memoMessage.CreatorID != userID {
return echo.NewHTTPError(http.StatusForbidden, "this memo is private only") return echo.NewHTTPError(http.StatusForbidden, "this memo is private only")
} }
} else if memo.Visibility == api.Protected { } else if memoMessage.Visibility == store.Protected {
if !ok { if !ok {
return echo.NewHTTPError(http.StatusForbidden, "this memo is protected, missing user in session") return echo.NewHTTPError(http.StatusForbidden, "this memo is protected, missing user in session")
} }
} }
return c.JSON(http.StatusOK, composeResponse(memo)) memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
}
return c.JSON(http.StatusOK, composeResponse(memoResponse))
}) })
g.POST("/memo/:memoId/organizer", func(c echo.Context) error { g.POST("/memo/:memoId/organizer", func(c echo.Context) error {
@ -338,46 +364,49 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo organizer").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo organizer").SetInternal(err)
} }
memo, err := s.Store.FindMemo(ctx, &api.MemoFind{ memoMessage, err := s.Store.GetMemo(ctx, &store.FindMemoMessage{
ID: &memoID, ID: &memoID,
}) })
if err != nil { if err != nil {
if common.ErrorCode(err) == common.NotFound { if common.ErrorCode(err) == common.NotFound {
return echo.NewHTTPError(http.StatusNotFound, fmt.Sprintf("Memo ID not found: %d", memoID)).SetInternal(err) return echo.NewHTTPError(http.StatusNotFound, fmt.Sprintf("Memo ID not found: %d", memoID)).SetInternal(err)
} }
return echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("Failed to find memo by ID: %v", memoID)).SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("Failed to find memo by ID: %v", memoID)).SetInternal(err)
} }
return c.JSON(http.StatusOK, composeResponse(memo)) memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
}
return c.JSON(http.StatusOK, composeResponse(memoResponse))
}) })
g.GET("/memo/stats", func(c echo.Context) error { g.GET("/memo/stats", func(c echo.Context) error {
ctx := c.Request().Context() ctx := c.Request().Context()
normalStatus := api.Normal normalStatus := store.Normal
memoFind := &api.MemoFind{ findMemoMessage := &store.FindMemoMessage{
RowStatus: &normalStatus, RowStatus: &normalStatus,
} }
if creatorID, err := strconv.Atoi(c.QueryParam("creatorId")); err == nil { if creatorID, err := strconv.Atoi(c.QueryParam("creatorId")); err == nil {
memoFind.CreatorID = &creatorID findMemoMessage.CreatorID = &creatorID
} }
if memoFind.CreatorID == nil { if findMemoMessage.CreatorID == nil {
return echo.NewHTTPError(http.StatusBadRequest, "Missing user id to find memo") return echo.NewHTTPError(http.StatusBadRequest, "Missing user id to find memo")
} }
currentUserID, ok := c.Get(getUserIDContextKey()).(int) currentUserID, ok := c.Get(getUserIDContextKey()).(int)
if !ok { if !ok {
memoFind.VisibilityList = []api.Visibility{api.Public} findMemoMessage.VisibilityList = []store.Visibility{store.Public}
} else { } else {
if *memoFind.CreatorID != currentUserID { if *findMemoMessage.CreatorID != currentUserID {
memoFind.VisibilityList = []api.Visibility{api.Public, api.Protected} findMemoMessage.VisibilityList = []store.Visibility{store.Public, store.Protected}
} else { } else {
memoFind.VisibilityList = []api.Visibility{api.Public, api.Protected, api.Private} findMemoMessage.VisibilityList = []store.Visibility{store.Public, store.Protected, store.Private}
} }
} }
list, err := s.Store.FindMemoList(ctx, memoFind) list, err := s.Store.ListMemos(ctx, findMemoMessage)
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to fetch memo list").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err)
} }
createdTsList := []int64{} createdTsList := []int64{}
@ -389,49 +418,56 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
g.GET("/memo/all", func(c echo.Context) error { g.GET("/memo/all", func(c echo.Context) error {
ctx := c.Request().Context() ctx := c.Request().Context()
memoFind := &api.MemoFind{} findMemoMessage := &store.FindMemoMessage{}
_, ok := c.Get(getUserIDContextKey()).(int) _, ok := c.Get(getUserIDContextKey()).(int)
if !ok { if !ok {
memoFind.VisibilityList = []api.Visibility{api.Public} findMemoMessage.VisibilityList = []store.Visibility{store.Public}
} else { } else {
memoFind.VisibilityList = []api.Visibility{api.Public, api.Protected} findMemoMessage.VisibilityList = []store.Visibility{store.Public, store.Protected}
} }
pinnedStr := c.QueryParam("pinned") pinnedStr := c.QueryParam("pinned")
if pinnedStr != "" { if pinnedStr != "" {
pinned := pinnedStr == "true" pinned := pinnedStr == "true"
memoFind.Pinned = &pinned findMemoMessage.Pinned = &pinned
} }
tag := c.QueryParam("tag") tag := c.QueryParam("tag")
if tag != "" { if tag != "" {
contentSearch := "#" + tag + " " contentSearch := "#" + tag + " "
memoFind.ContentSearch = &contentSearch findMemoMessage.ContentSearch = &contentSearch
} }
visibilityListStr := c.QueryParam("visibility") visibilityListStr := c.QueryParam("visibility")
if visibilityListStr != "" { if visibilityListStr != "" {
visibilityList := []api.Visibility{} visibilityList := []store.Visibility{}
for _, visibility := range strings.Split(visibilityListStr, ",") { for _, visibility := range strings.Split(visibilityListStr, ",") {
visibilityList = append(visibilityList, api.Visibility(visibility)) visibilityList = append(visibilityList, store.Visibility(visibility))
} }
memoFind.VisibilityList = visibilityList findMemoMessage.VisibilityList = visibilityList
} }
if limit, err := strconv.Atoi(c.QueryParam("limit")); err == nil { if limit, err := strconv.Atoi(c.QueryParam("limit")); err == nil {
memoFind.Limit = &limit findMemoMessage.Limit = &limit
} }
if offset, err := strconv.Atoi(c.QueryParam("offset")); err == nil { if offset, err := strconv.Atoi(c.QueryParam("offset")); err == nil {
memoFind.Offset = &offset findMemoMessage.Offset = &offset
} }
// Only fetch normal status memos. // Only fetch normal status memos.
normalStatus := api.Normal normalStatus := store.Normal
memoFind.RowStatus = &normalStatus findMemoMessage.RowStatus = &normalStatus
list, err := s.Store.FindMemoList(ctx, memoFind) memoMessageList, err := s.Store.ListMemos(ctx, findMemoMessage)
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to fetch all memo list").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to fetch all memo list").SetInternal(err)
} }
return c.JSON(http.StatusOK, composeResponse(list)) memoResponseList := []*api.MemoResponse{}
for _, memoMessage := range memoMessageList {
memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
}
memoResponseList = append(memoResponseList, memoResponse)
}
return c.JSON(http.StatusOK, composeResponse(memoResponseList))
}) })
g.DELETE("/memo/:memoId", func(c echo.Context) error { g.DELETE("/memo/:memoId", func(c echo.Context) error {
@ -445,7 +481,7 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("ID is not a number: %s", c.Param("memoId"))).SetInternal(err) return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("ID is not a number: %s", c.Param("memoId"))).SetInternal(err)
} }
memo, err := s.Store.FindMemo(ctx, &api.MemoFind{ memo, err := s.Store.GetMemo(ctx, &store.FindMemoMessage{
ID: &memoID, ID: &memoID,
}) })
if err != nil { if err != nil {
@ -455,10 +491,9 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
return echo.NewHTTPError(http.StatusUnauthorized, "Unauthorized") return echo.NewHTTPError(http.StatusUnauthorized, "Unauthorized")
} }
memoDelete := &api.MemoDelete{ if err := s.Store.DeleteMemo(ctx, &store.DeleteMemoMessage{
ID: memoID, ID: memoID,
} }); err != nil {
if err := s.Store.DeleteMemo(ctx, memoDelete); err != nil {
if common.ErrorCode(err) == common.NotFound { if common.ErrorCode(err) == common.NotFound {
return echo.NewHTTPError(http.StatusNotFound, fmt.Sprintf("Memo ID not found: %d", memoID)) return echo.NewHTTPError(http.StatusNotFound, fmt.Sprintf("Memo ID not found: %d", memoID))
} }
@ -468,7 +503,7 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
}) })
} }
func (s *Server) createMemoCreateActivity(c echo.Context, memo *api.Memo) error { func (s *Server) createMemoCreateActivity(c echo.Context, memo *store.MemoMessage) error {
ctx := c.Request().Context() ctx := c.Request().Context()
payload := api.ActivityMemoCreatePayload{ payload := api.ActivityMemoCreatePayload{
Content: memo.Content, Content: memo.Content,
@ -512,7 +547,7 @@ func getIDListDiff(oldList, newList []int) (addedList, removedList []int) {
return addedList, removedList return addedList, removedList
} }
func getMemoRelationListDiff(oldList, newList []*api.MemoRelation) (addedList, removedList []*api.MemoRelation) { func getMemoRelationListDiff(oldList, newList []*store.MemoRelationMessage) (addedList, removedList []*store.MemoRelationMessage) {
oldMap := map[string]bool{} oldMap := map[string]bool{}
for _, relation := range oldList { for _, relation := range oldList {
oldMap[fmt.Sprintf("%d-%s", relation.RelatedMemoID, relation.Type)] = true oldMap[fmt.Sprintf("%d-%s", relation.RelatedMemoID, relation.Type)] = true
@ -535,3 +570,64 @@ func getMemoRelationListDiff(oldList, newList []*api.MemoRelation) (addedList, r
} }
return addedList, removedList return addedList, removedList
} }
func convertCreateMemoRequestToMemoMessage(memoCreate *api.CreateMemoRequest) *store.MemoMessage {
createdTs := time.Now().Unix()
if memoCreate.CreatedTs != nil {
createdTs = *memoCreate.CreatedTs
}
return &store.MemoMessage{
CreatorID: memoCreate.CreatorID,
CreatedTs: createdTs,
Content: memoCreate.Content,
Visibility: store.Visibility(memoCreate.Visibility),
}
}
func convertMemoMessageToMemoResponse(memoMessage *store.MemoMessage) *api.MemoResponse {
relationList := []*api.MemoRelation{}
for _, relation := range memoMessage.RelationList {
relationList = append(relationList, convertMemoRelationMessageToMemoRelation(relation))
}
return &api.MemoResponse{
ID: memoMessage.ID,
RowStatus: api.RowStatus(memoMessage.RowStatus.String()),
CreatorID: memoMessage.CreatorID,
CreatedTs: memoMessage.CreatedTs,
UpdatedTs: memoMessage.UpdatedTs,
Content: memoMessage.Content,
Visibility: api.Visibility(memoMessage.Visibility.String()),
Pinned: memoMessage.Pinned,
ResourceIDList: memoMessage.ResourceIDList,
RelationList: relationList,
}
}
func (s *Server) ComposeMemoResponse(ctx context.Context, memoResponse *api.MemoResponse) (*api.MemoResponse, error) {
user, err := s.Store.FindUser(ctx, &api.UserFind{
ID: &memoResponse.CreatorID,
})
if err != nil {
return nil, err
}
if user.Nickname != "" {
memoResponse.CreatorName = user.Nickname
} else {
memoResponse.CreatorName = user.Username
}
memoResponse.ResourceList = []*api.Resource{}
for _, resourceID := range memoResponse.ResourceIDList {
resource, err := s.Store.FindResource(ctx, &api.ResourceFind{
ID: &resourceID,
})
if err != nil {
return nil, err
}
memoResponse.ResourceList = append(memoResponse.ResourceList, resource)
}
return memoResponse, nil
}

8
server/memo_relation.go
View File

@ -74,3 +74,11 @@ func (s *Server) registerMemoRelationRoutes(g *echo.Group) {
return c.JSON(http.StatusOK, true) return c.JSON(http.StatusOK, true)
}) })
} }
func convertMemoRelationMessageToMemoRelation(memoRelation *store.MemoRelationMessage) *api.MemoRelation {
return &api.MemoRelation{
MemoID: memoRelation.MemoID,
RelatedMemoID: memoRelation.RelatedMemoID,
Type: api.MemoRelationType(memoRelation.Type),
}
}

3
server/memo_resource.go
View File

@ -8,6 +8,7 @@ import (
"time" "time"
"github.com/usememos/memos/api" "github.com/usememos/memos/api"
"github.com/usememos/memos/store"
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
) )
@ -82,7 +83,7 @@ func (s *Server) registerMemoResourceRoutes(g *echo.Group) {
return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Resource ID is not a number: %s", c.Param("resourceId"))).SetInternal(err) return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Resource ID is not a number: %s", c.Param("resourceId"))).SetInternal(err)
} }
memo, err := s.Store.FindMemo(ctx, &api.MemoFind{ memo, err := s.Store.GetMemo(ctx, &store.FindMemoMessage{
ID: &memoID, ID: &memoID,
}) })
if err != nil { if err != nil {

35
server/rss.go
View File

@ -13,6 +13,7 @@ import (
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
"github.com/usememos/memos/api" "github.com/usememos/memos/api"
"github.com/usememos/memos/common" "github.com/usememos/memos/common"
"github.com/usememos/memos/store"
"github.com/yuin/goldmark" "github.com/yuin/goldmark"
) )
@ -24,12 +25,12 @@ func (s *Server) registerRSSRoutes(g *echo.Group) {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to get system customized profile").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to get system customized profile").SetInternal(err)
} }
normalStatus := api.Normal normalStatus := store.Normal
memoFind := api.MemoFind{ memoFind := store.FindMemoMessage{
RowStatus: &normalStatus, RowStatus: &normalStatus,
VisibilityList: []api.Visibility{api.Public}, VisibilityList: []store.Visibility{store.Public},
} }
memoList, err := s.Store.FindMemoList(ctx, &memoFind) memoList, err := s.Store.ListMemos(ctx, &memoFind)
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err)
} }
@ -55,13 +56,13 @@ func (s *Server) registerRSSRoutes(g *echo.Group) {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to get system customized profile").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to get system customized profile").SetInternal(err)
} }
normalStatus := api.Normal normalStatus := store.Normal
memoFind := api.MemoFind{ memoFind := store.FindMemoMessage{
CreatorID: &id, CreatorID: &id,
RowStatus: &normalStatus, RowStatus: &normalStatus,
VisibilityList: []api.Visibility{api.Public}, VisibilityList: []store.Visibility{store.Public},
} }
memoList, err := s.Store.FindMemoList(ctx, &memoFind) memoList, err := s.Store.ListMemos(ctx, &memoFind)
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err)
} }
@ -79,7 +80,7 @@ func (s *Server) registerRSSRoutes(g *echo.Group) {
const MaxRSSItemCount = 100 const MaxRSSItemCount = 100
const MaxRSSItemTitleLength = 100 const MaxRSSItemTitleLength = 100
func (s *Server) generateRSSFromMemoList(ctx context.Context, memoList []*api.Memo, baseURL string, profile *api.CustomizedProfile) (string, error) { func (s *Server) generateRSSFromMemoList(ctx context.Context, memoList []*store.MemoMessage, baseURL string, profile *api.CustomizedProfile) (string, error) {
feed := &feeds.Feed{ feed := &feeds.Feed{
Title: profile.Name, Title: profile.Name,
Link: &feeds.Link{Href: baseURL}, Link: &feeds.Link{Href: baseURL},
@ -98,15 +99,15 @@ func (s *Server) generateRSSFromMemoList(ctx context.Context, memoList []*api.Me
Created: time.Unix(memo.CreatedTs, 0), Created: time.Unix(memo.CreatedTs, 0),
Enclosure: &feeds.Enclosure{Url: baseURL + "/m/" + strconv.Itoa(memo.ID) + "/image"}, Enclosure: &feeds.Enclosure{Url: baseURL + "/m/" + strconv.Itoa(memo.ID) + "/image"},
} }
resourceList, err := s.Store.FindResourceList(ctx, &api.ResourceFind{ if len(memo.ResourceIDList) > 0 {
MemoID: &memo.ID, resourceID := memo.ResourceIDList[0]
}) resource, err := s.Store.FindResource(ctx, &api.ResourceFind{
if err != nil { ID: &resourceID,
return "", err })
} if err != nil {
if len(resourceList) > 0 { return "", err
}
enclosure := feeds.Enclosure{} enclosure := feeds.Enclosure{}
resource := resourceList[0]
if resource.ExternalLink != "" { if resource.ExternalLink != "" {
enclosure.Url = resource.ExternalLink enclosure.Url = resource.ExternalLink
} else { } else {

9
server/tag.go
View File

@ -10,6 +10,7 @@ import (
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/usememos/memos/api" "github.com/usememos/memos/api"
"github.com/usememos/memos/common" "github.com/usememos/memos/common"
"github.com/usememos/memos/store"
"golang.org/x/exp/slices" "golang.org/x/exp/slices"
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
@ -71,14 +72,14 @@ func (s *Server) registerTagRoutes(g *echo.Group) {
return echo.NewHTTPError(http.StatusBadRequest, "Missing user session") return echo.NewHTTPError(http.StatusBadRequest, "Missing user session")
} }
contentSearch := "#" contentSearch := "#"
normalRowStatus := api.Normal normalRowStatus := store.Normal
memoFind := api.MemoFind{ memoFind := &store.FindMemoMessage{
CreatorID: &userID, CreatorID: &userID,
ContentSearch: &contentSearch, ContentSearch: &contentSearch,
RowStatus: &normalRowStatus, RowStatus: &normalRowStatus,
} }
memoList, err := s.Store.FindMemoList(ctx, &memoFind) memoMessageList, err := s.Store.ListMemos(ctx, memoFind)
if err != nil { if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err) return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err)
} }
@ -96,7 +97,7 @@ func (s *Server) registerTagRoutes(g *echo.Group) {
} }
tagMapSet := make(map[string]bool) tagMapSet := make(map[string]bool)
for _, memo := range memoList { for _, memo := range memoMessageList {
for _, tag := range findTagListFromMemoContent(memo.Content) { for _, tag := range findTagListFromMemoContent(memo.Content) {
if !slices.Contains(tagNameList, tag) { if !slices.Contains(tagNameList, tag) {
tagMapSet[tag] = true tagMapSet[tag] = true

21
store/common.go Normal file
View File

@ -0,0 +1,21 @@
package store
// RowStatus is the status for a row.
type RowStatus string
const (
// Normal is the status for a normal row.
Normal RowStatus = "NORMAL"
// Archived is the status for an archived row.
Archived RowStatus = "ARCHIVED"
)
func (r RowStatus) String() string {
switch r {
case Normal:
return "NORMAL"
case Archived:
return "ARCHIVED"
}
return ""
}

460
store/memo.go
View File

@ -4,300 +4,221 @@ import (
"context" "context"
"database/sql" "database/sql"
"fmt" "fmt"
"strconv"
"strings" "strings"
"github.com/usememos/memos/api"
"github.com/usememos/memos/common" "github.com/usememos/memos/common"
) )
// memoRaw is the store model for an Memo. // Visibility is the type of a visibility.
// Fields have exactly the same meanings as Memo. type Visibility string
type memoRaw struct {
const (
// Public is the PUBLIC visibility.
Public Visibility = "PUBLIC"
// Protected is the PROTECTED visibility.
Protected Visibility = "PROTECTED"
// Private is the PRIVATE visibility.
Private Visibility = "PRIVATE"
)
func (v Visibility) String() string {
switch v {
case Public:
return "PUBLIC"
case Protected:
return "PROTECTED"
case Private:
return "PRIVATE"
}
return "PRIVATE"
}
type MemoMessage struct {
ID int ID int
// Standard fields // Standard fields
RowStatus api.RowStatus RowStatus RowStatus
CreatorID int CreatorID int
CreatedTs int64 CreatedTs int64
UpdatedTs int64 UpdatedTs int64
// Domain specific fields // Domain specific fields
Content string Content string
Visibility api.Visibility Visibility Visibility
Pinned bool
// Composed fields
Pinned bool
ResourceIDList []int
RelationList []*MemoRelationMessage
} }
// toMemo creates an instance of Memo based on the memoRaw. type FindMemoMessage struct {
// This is intended to be called when we need to compose an Memo relationship. ID *int
func (raw *memoRaw) toMemo() *api.Memo {
return &api.Memo{
ID: raw.ID,
// Standard fields // Standard fields
RowStatus: raw.RowStatus, RowStatus *RowStatus
CreatorID: raw.CreatorID, CreatorID *int
CreatedTs: raw.CreatedTs,
UpdatedTs: raw.UpdatedTs,
// Domain specific fields // Domain specific fields
Content: raw.Content, Pinned *bool
Visibility: raw.Visibility, ContentSearch *string
Pinned: raw.Pinned, VisibilityList []Visibility
ResourceList: []*api.Resource{},
RelationList: []*api.MemoRelation{}, // Pagination
} Limit *int
Offset *int
} }
func (s *Store) ComposeMemo(ctx context.Context, memo *api.Memo) (*api.Memo, error) { type UpdateMemoMessage struct {
if err := s.ComposeMemoCreator(ctx, memo); err != nil { ID int
return nil, err CreatedTs *int64
} UpdatedTs *int64
if err := s.ComposeMemoResourceList(ctx, memo); err != nil { RowStatus *RowStatus
return nil, err Content *string
} Visibility *Visibility
if err := s.ComposeMemoRelationList(ctx, memo); err != nil {
return nil, err
}
return memo, nil
} }
func (s *Store) CreateMemo(ctx context.Context, create *api.MemoCreate) (*api.Memo, error) { type DeleteMemoMessage struct {
ID int
}
func (s *Store) CreateMemo(ctx context.Context, create *MemoMessage) (*MemoMessage, error) {
tx, err := s.db.BeginTx(ctx, nil) tx, err := s.db.BeginTx(ctx, nil)
if err != nil { if err != nil {
return nil, FormatError(err) return nil, FormatError(err)
} }
defer tx.Rollback() defer tx.Rollback()
memoRaw, err := createMemoRaw(ctx, tx, create) query := `
if err != nil { INSERT INTO memo (
return nil, err creator_id,
created_ts,
content,
visibility
)
VALUES (?, ?, ?, ?)
RETURNING id, created_ts, updated_ts, row_status
`
if err := tx.QueryRowContext(
ctx,
query,
create.CreatorID,
create.CreatedTs,
create.Content,
create.Visibility,
).Scan(
&create.ID,
&create.CreatedTs,
&create.UpdatedTs,
&create.RowStatus,
); err != nil {
return nil, FormatError(err)
} }
if err := tx.Commit(); err != nil { if err := tx.Commit(); err != nil {
return nil, FormatError(err) return nil, FormatError(err)
} }
memoMessage := create
s.memoCache.Store(memoRaw.ID, memoRaw) return memoMessage, nil
memo, err := s.ComposeMemo(ctx, memoRaw.toMemo())
if err != nil {
return nil, err
}
return memo, nil
} }
func (s *Store) PatchMemo(ctx context.Context, patch *api.MemoPatch) (*api.Memo, error) { func (s *Store) ListMemos(ctx context.Context, find *FindMemoMessage) ([]*MemoMessage, error) {
tx, err := s.db.BeginTx(ctx, nil) tx, err := s.db.BeginTx(ctx, nil)
if err != nil { if err != nil {
return nil, FormatError(err) return nil, FormatError(err)
} }
defer tx.Rollback() defer tx.Rollback()
memoRaw, err := patchMemoRaw(ctx, tx, patch) list, err := listMemos(ctx, tx, find)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if err := tx.Commit(); err != nil {
return nil, FormatError(err)
}
s.memoCache.Store(memoRaw.ID, memoRaw)
memo, err := s.ComposeMemo(ctx, memoRaw.toMemo())
if err != nil {
return nil, err
}
return memo, nil
}
func (s *Store) FindMemoList(ctx context.Context, find *api.MemoFind) ([]*api.Memo, error) {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return nil, FormatError(err)
}
defer tx.Rollback()
memoRawList, err := findMemoRawList(ctx, tx, find)
if err != nil {
return nil, err
}
list := []*api.Memo{}
for _, raw := range memoRawList {
memo, err := s.ComposeMemo(ctx, raw.toMemo())
if err != nil {
return nil, err
}
list = append(list, memo)
}
return list, nil return list, nil
} }
func (s *Store) FindMemo(ctx context.Context, find *api.MemoFind) (*api.Memo, error) { func (s *Store) GetMemo(ctx context.Context, find *FindMemoMessage) (*MemoMessage, error) {
if find.ID != nil {
if memo, ok := s.memoCache.Load(*find.ID); ok {
memoRaw := memo.(*memoRaw)
memo, err := s.ComposeMemo(ctx, memoRaw.toMemo())
if err != nil {
return nil, err
}
return memo, nil
}
}
tx, err := s.db.BeginTx(ctx, nil) tx, err := s.db.BeginTx(ctx, nil)
if err != nil { if err != nil {
return nil, FormatError(err) return nil, FormatError(err)
} }
defer tx.Rollback() defer tx.Rollback()
list, err := findMemoRawList(ctx, tx, find) list, err := listMemos(ctx, tx, find)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if len(list) == 0 { if len(list) == 0 {
return nil, &common.Error{Code: common.NotFound, Err: fmt.Errorf("not found")} return nil, &common.Error{Code: common.NotFound, Err: fmt.Errorf("memo not found")}
} }
memoRaw := list[0] memoMessage := list[0]
s.memoCache.Store(memoRaw.ID, memoRaw) return memoMessage, nil
memo, err := s.ComposeMemo(ctx, memoRaw.toMemo())
if err != nil {
return nil, err
}
return memo, nil
} }
func (s *Store) DeleteMemo(ctx context.Context, delete *api.MemoDelete) error { func (s *Store) UpdateMemo(ctx context.Context, update *UpdateMemoMessage) error {
tx, err := s.db.BeginTx(ctx, nil) tx, err := s.db.BeginTx(ctx, nil)
if err != nil { if err != nil {
return FormatError(err)
}
defer tx.Rollback()
if err := deleteMemo(ctx, tx, delete); err != nil {
return FormatError(err)
}
if err := s.vacuumImpl(ctx, tx); err != nil {
return err return err
} }
defer tx.Rollback()
if err := tx.Commit(); err != nil {
return FormatError(err)
}
s.memoCache.Delete(delete.ID)
return nil
}
func createMemoRaw(ctx context.Context, tx *sql.Tx, create *api.MemoCreate) (*memoRaw, error) {
set := []string{"creator_id", "content", "visibility"}
args := []any{create.CreatorID, create.Content, create.Visibility}
placeholder := []string{"?", "?", "?"}
if v := create.CreatedTs; v != nil {
set, args, placeholder = append(set, "created_ts"), append(args, *v), append(placeholder, "?")
}
query := `
INSERT INTO memo (
` + strings.Join(set, ", ") + `
)
VALUES (` + strings.Join(placeholder, ",") + `)
RETURNING id, creator_id, created_ts, updated_ts, row_status, content, visibility
`
var memoRaw memoRaw
if err := tx.QueryRowContext(ctx, query, args...).Scan(
&memoRaw.ID,
&memoRaw.CreatorID,
&memoRaw.CreatedTs,
&memoRaw.UpdatedTs,
&memoRaw.RowStatus,
&memoRaw.Content,
&memoRaw.Visibility,
); err != nil {
return nil, FormatError(err)
}
return &memoRaw, nil
}
func patchMemoRaw(ctx context.Context, tx *sql.Tx, patch *api.MemoPatch) (*memoRaw, error) {
set, args := []string{}, []any{} set, args := []string{}, []any{}
if v := update.CreatedTs; v != nil {
if v := patch.CreatedTs; v != nil {
set, args = append(set, "created_ts = ?"), append(args, *v) set, args = append(set, "created_ts = ?"), append(args, *v)
} }
if v := patch.UpdatedTs; v != nil { if v := update.UpdatedTs; v != nil {
set, args = append(set, "updated_ts = ?"), append(args, *v) set, args = append(set, "updated_ts = ?"), append(args, *v)
} }
if v := patch.RowStatus; v != nil { if v := update.Content; v != nil {
set, args = append(set, "row_status = ?"), append(args, *v)
}
if v := patch.Content; v != nil {
set, args = append(set, "content = ?"), append(args, *v) set, args = append(set, "content = ?"), append(args, *v)
} }
if v := patch.Visibility; v != nil { if v := update.Visibility; v != nil {
set, args = append(set, "visibility = ?"), append(args, *v) set, args = append(set, "visibility = ?"), append(args, *v)
} }
args = append(args, update.ID)
args = append(args, patch.ID)
query := ` query := `
UPDATE memo UPDATE memo
SET ` + strings.Join(set, ", ") + ` SET ` + strings.Join(set, ", ") + `
WHERE id = ? WHERE id = ?
RETURNING id, creator_id, created_ts, updated_ts, row_status, content, visibility
` `
var memoRaw memoRaw if _, err := tx.ExecContext(ctx, query, args...); err != nil {
if err := tx.QueryRowContext(ctx, query, args...).Scan( return err
&memoRaw.ID,
&memoRaw.CreatorID,
&memoRaw.CreatedTs,
&memoRaw.UpdatedTs,
&memoRaw.RowStatus,
&memoRaw.Content,
&memoRaw.Visibility,
); err != nil {
return nil, FormatError(err)
} }
err = tx.Commit()
pinnedQuery := ` return err
SELECT
pinned
FROM memo_organizer
WHERE memo_id = ? AND user_id = ?
`
row, err := tx.QueryContext(ctx, pinnedQuery, patch.ID, memoRaw.CreatorID)
if err != nil {
return nil, FormatError(err)
}
defer row.Close()
if !row.Next() {
memoRaw.Pinned = false
} else {
if err := row.Scan(
&memoRaw.Pinned,
); err != nil {
return nil, FormatError(err)
}
}
if err := row.Err(); err != nil {
return nil, err
}
return &memoRaw, nil
} }
func findMemoRawList(ctx context.Context, tx *sql.Tx, find *api.MemoFind) ([]*memoRaw, error) { func (s *Store) DeleteMemo(ctx context.Context, delete *DeleteMemoMessage) error {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return FormatError(err)
}
defer tx.Rollback()
where, args := []string{"id = ?"}, []any{delete.ID}
stmt := `DELETE FROM memo WHERE ` + strings.Join(where, " AND ")
result, err := tx.ExecContext(ctx, stmt, args...)
if err != nil {
return FormatError(err)
}
rows, err := result.RowsAffected()
if err != nil {
return err
}
if rows == 0 {
return &common.Error{Code: common.NotFound, Err: fmt.Errorf("idp not found")}
}
if err := s.vacuumImpl(ctx, tx); err != nil {
return err
}
err = tx.Commit()
return err
}
func listMemos(ctx context.Context, tx *sql.Tx, find *FindMemoMessage) ([]*MemoMessage, error) {
where, args := []string{"1 = 1"}, []any{} where, args := []string{"1 = 1"}, []any{}
if v := find.ID; v != nil { if v := find.ID; v != nil {
@ -325,19 +246,35 @@ func findMemoRawList(ctx context.Context, tx *sql.Tx, find *api.MemoFind) ([]*me
} }
query := ` query := `
SELECT SELECT
memo.id, memo.id AS id,
memo.creator_id, memo.creator_id AS creator_id,
memo.created_ts, memo.created_ts AS created_ts,
memo.updated_ts, memo.updated_ts AS updated_ts,
memo.row_status, memo.row_status AS row_status,
memo.content, memo.content AS content,
memo.visibility, memo.visibility AS visibility,
IFNULL(memo_organizer.pinned, 0) AS pinned CASE WHEN memo_organizer.pinned = 1 THEN 1 ELSE 0 END AS pinned,
FROM memo GROUP_CONCAT(memo_resource.resource_id) AS resource_id_list,
LEFT JOIN memo_organizer ON memo_organizer.memo_id = memo.id AND memo_organizer.user_id = memo.creator_id (
WHERE ` + strings.Join(where, " AND ") + ` SELECT
ORDER BY pinned DESC, memo.created_ts DESC GROUP_CONCAT(related_memo_id || ':' || type)
FROM
memo_relation
WHERE
memo_relation.memo_id = memo.id
GROUP BY
memo_relation.memo_id
) AS relation_list
FROM
memo
LEFT JOIN
memo_organizer ON memo.id = memo_organizer.memo_id
LEFT JOIN
memo_resource ON memo.id = memo_resource.memo_id
WHERE ` + strings.Join(where, " AND ") + `
GROUP BY memo.id
ORDER BY pinned DESC, memo.created_ts DESC
` `
if find.Limit != nil { if find.Limit != nil {
query = fmt.Sprintf("%s LIMIT %d", query, *find.Limit) query = fmt.Sprintf("%s LIMIT %d", query, *find.Limit)
@ -352,51 +289,64 @@ func findMemoRawList(ctx context.Context, tx *sql.Tx, find *api.MemoFind) ([]*me
} }
defer rows.Close() defer rows.Close()
memoRawList := make([]*memoRaw, 0) memoMessageList := make([]*MemoMessage, 0)
for rows.Next() { for rows.Next() {
var memoRaw memoRaw var memoMessage MemoMessage
var pinned sql.NullBool var memoResourceIDList sql.NullString
var memoRelationList sql.NullString
if err := rows.Scan( if err := rows.Scan(
&memoRaw.ID, &memoMessage.ID,
&memoRaw.CreatorID, &memoMessage.CreatorID,
&memoRaw.CreatedTs, &memoMessage.CreatedTs,
&memoRaw.UpdatedTs, &memoMessage.UpdatedTs,
&memoRaw.RowStatus, &memoMessage.RowStatus,
&memoRaw.Content, &memoMessage.Content,
&memoRaw.Visibility, &memoMessage.Visibility,
&pinned, &memoMessage.Pinned,
&memoResourceIDList,
&memoRelationList,
); err != nil { ); err != nil {
return nil, FormatError(err) return nil, FormatError(err)
} }
if pinned.Valid { if memoResourceIDList.Valid {
memoRaw.Pinned = pinned.Bool idStringList := strings.Split(memoResourceIDList.String, ",")
memoMessage.ResourceIDList = make([]int, 0, len(idStringList))
for _, idString := range idStringList {
id, err := strconv.Atoi(idString)
if err != nil {
return nil, FormatError(err)
}
memoMessage.ResourceIDList = append(memoMessage.ResourceIDList, id)
}
} }
memoRawList = append(memoRawList, &memoRaw) if memoRelationList.Valid {
memoMessage.RelationList = make([]*MemoRelationMessage, 0)
relatedMemoTypeList := strings.Split(memoRelationList.String, ",")
for _, relatedMemoType := range relatedMemoTypeList {
relatedMemoTypeList := strings.Split(relatedMemoType, ":")
if len(relatedMemoTypeList) != 2 {
return nil, &common.Error{Code: common.Invalid, Err: fmt.Errorf("invalid relation format")}
}
relatedMemoID, err := strconv.Atoi(relatedMemoTypeList[0])
if err != nil {
return nil, FormatError(err)
}
memoMessage.RelationList = append(memoMessage.RelationList, &MemoRelationMessage{
MemoID: memoMessage.ID,
RelatedMemoID: relatedMemoID,
Type: MemoRelationType(relatedMemoTypeList[1]),
})
}
}
memoMessageList = append(memoMessageList, &memoMessage)
} }
if err := rows.Err(); err != nil { if err := rows.Err(); err != nil {
return nil, FormatError(err) return nil, FormatError(err)
} }
return memoRawList, nil return memoMessageList, nil
}
func deleteMemo(ctx context.Context, tx *sql.Tx, delete *api.MemoDelete) error {
where, args := []string{"id = ?"}, []any{delete.ID}
stmt := `DELETE FROM memo WHERE ` + strings.Join(where, " AND ")
result, err := tx.ExecContext(ctx, stmt, args...)
if err != nil {
return FormatError(err)
}
rows, _ := result.RowsAffected()
if rows == 0 {
return &common.Error{Code: common.NotFound, Err: fmt.Errorf("memo not found")}
}
return nil
} }
func vacuumMemo(ctx context.Context, tx *sql.Tx) error { func vacuumMemo(ctx context.Context, tx *sql.Tx) error {

21
store/memo_relation.go
View File

@ -6,30 +6,9 @@ import (
"fmt" "fmt"
"strings" "strings"
"github.com/usememos/memos/api"
"github.com/usememos/memos/common" "github.com/usememos/memos/common"
) )
func (s *Store) ComposeMemoRelationList(ctx context.Context, memo *api.Memo) error {
memoRelationList, err := s.ListMemoRelations(ctx, &FindMemoRelationMessage{
MemoID: &memo.ID,
})
if err != nil {
return err
}
memo.RelationList = []*api.MemoRelation{}
for _, memoRelation := range memoRelationList {
memo.RelationList = append(memo.RelationList, &api.MemoRelation{
MemoID: memoRelation.MemoID,
RelatedMemoID: memoRelation.RelatedMemoID,
Type: api.MemoRelationType(memoRelation.Type),
})
}
return nil
}
type MemoRelationType string type MemoRelationType string
const ( const (

35
store/resource.go
View File

@ -4,7 +4,6 @@ import (
"context" "context"
"database/sql" "database/sql"
"fmt" "fmt"
"sort"
"strings" "strings"
"github.com/usememos/memos/api" "github.com/usememos/memos/api"
@ -53,40 +52,6 @@ func (raw *resourceRaw) toResource() *api.Resource {
} }
} }
func (s *Store) ComposeMemoResourceList(ctx context.Context, memo *api.Memo) error {
resourceList, err := s.FindResourceList(ctx, &api.ResourceFind{
MemoID: &memo.ID,
})
if err != nil {
return err
}
for _, resource := range resourceList {
memoResource, err := s.FindMemoResource(ctx, &api.MemoResourceFind{
MemoID: &memo.ID,
ResourceID: &resource.ID,
})
if err != nil {
return err
}
resource.CreatedTs = memoResource.CreatedTs
resource.UpdatedTs = memoResource.UpdatedTs
}
sort.Slice(resourceList, func(i, j int) bool {
if resourceList[i].CreatedTs != resourceList[j].CreatedTs {
return resourceList[i].CreatedTs < resourceList[j].CreatedTs
}
return resourceList[i].ID < resourceList[j].ID
})
memo.ResourceList = resourceList
return nil
}
func (s *Store) CreateResource(ctx context.Context, create *api.ResourceCreate) (*api.Resource, error) { func (s *Store) CreateResource(ctx context.Context, create *api.ResourceCreate) (*api.Resource, error) {
tx, err := s.db.BeginTx(ctx, nil) tx, err := s.db.BeginTx(ctx, nil)
if err != nil { if err != nil {

1
store/store.go
View File

@ -15,7 +15,6 @@ type Store struct {
systemSettingCache sync.Map // map[string]*systemSettingRaw systemSettingCache sync.Map // map[string]*systemSettingRaw
userCache sync.Map // map[int]*userRaw userCache sync.Map // map[int]*userRaw
userSettingCache sync.Map // map[string]*userSettingRaw userSettingCache sync.Map // map[string]*userSettingRaw
memoCache sync.Map // map[int]*memoRaw
shortcutCache sync.Map // map[int]*shortcutRaw shortcutCache sync.Map // map[int]*shortcutRaw
idpCache sync.Map // map[int]*identityProviderMessage idpCache sync.Map // map[int]*identityProviderMessage
} }

38
store/user.go
View File

@ -11,34 +11,20 @@ import (
) )
func (s *Store) SeedDataForNewUser(ctx context.Context, user *api.User) error { func (s *Store) SeedDataForNewUser(ctx context.Context, user *api.User) error {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return FormatError(err)
}
defer tx.Rollback()
// Create a memo for the user. // Create a memo for the user.
_, err = createMemoRaw(ctx, tx, &api.MemoCreate{ _, err := s.CreateMemo(ctx, &MemoMessage{
CreatorID: user.ID, CreatorID: user.ID,
Content: "#inbox Welcome to Memos!", Content: "#inbox Welcome to Memos!",
Visibility: api.Private, Visibility: Private,
}) })
if err != nil { if err != nil {
return err return err
} }
_, err = upsertTag(ctx, tx, &api.TagUpsert{ _, err = s.UpsertTag(ctx, &api.TagUpsert{
CreatorID: user.ID, CreatorID: user.ID,
Name: "inbox", Name: "inbox",
}) })
if err != nil { return err
return err
}
if err := tx.Commit(); err != nil {
return FormatError(err)
}
return nil
} }
// userRaw is the store model for an User. // userRaw is the store model for an User.
@ -79,22 +65,6 @@ func (raw *userRaw) toUser() *api.User {
} }
} }
func (s *Store) ComposeMemoCreator(ctx context.Context, memo *api.Memo) error {
user, err := s.FindUser(ctx, &api.UserFind{
ID: &memo.CreatorID,
})
if err != nil {
return err
}
if user.Nickname != "" {
memo.CreatorName = user.Nickname
} else {
memo.CreatorName = user.Username
}
return nil
}
func (s *Store) CreateUser(ctx context.Context, create *api.UserCreate) (*api.User, error) { func (s *Store) CreateUser(ctx context.Context, create *api.UserCreate) (*api.User, error) {
tx, err := s.db.BeginTx(ctx, nil) tx, err := s.db.BeginTx(ctx, nil)
if err != nil { if err != nil {

4
test/server/memo_relation_test.go
View File

@ -28,12 +28,12 @@ func TestMemoRelationServer(t *testing.T) {
memoList, err := s.getMemoList() memoList, err := s.getMemoList()
require.NoError(t, err) require.NoError(t, err)
require.Len(t, memoList, 1) require.Len(t, memoList, 1)
memo, err := s.postMemoCreate(&api.MemoCreate{ memo, err := s.postMemoCreate(&api.CreateMemoRequest{
Content: "test memo", Content: "test memo",
}) })
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, "test memo", memo.Content) require.Equal(t, "test memo", memo.Content)
memo2, err := s.postMemoCreate(&api.MemoCreate{ memo2, err := s.postMemoCreate(&api.CreateMemoRequest{
Content: "test memo2", Content: "test memo2",
RelationList: []*api.MemoRelationUpsert{ RelationList: []*api.MemoRelationUpsert{
{ {

34
test/server/memo_test.go
View File

@ -28,7 +28,7 @@ func TestMemoServer(t *testing.T) {
memoList, err := s.getMemoList() memoList, err := s.getMemoList()
require.NoError(t, err) require.NoError(t, err)
require.Len(t, memoList, 1) require.Len(t, memoList, 1)
memo, err := s.postMemoCreate(&api.MemoCreate{ memo, err := s.postMemoCreate(&api.CreateMemoRequest{
Content: "test memo", Content: "test memo",
}) })
require.NoError(t, err) require.NoError(t, err)
@ -37,7 +37,7 @@ func TestMemoServer(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Len(t, memoList, 2) require.Len(t, memoList, 2)
updatedContent := "updated memo" updatedContent := "updated memo"
memo, err = s.patchMemo(&api.MemoPatch{ memo, err = s.patchMemo(&api.PatchMemoRequest{
ID: memo.ID, ID: memo.ID,
Content: &updatedContent, Content: &updatedContent,
}) })
@ -50,23 +50,21 @@ func TestMemoServer(t *testing.T) {
Pinned: true, Pinned: true,
}) })
require.NoError(t, err) require.NoError(t, err)
memo, err = s.patchMemo(&api.MemoPatch{ memo, err = s.patchMemo(&api.PatchMemoRequest{
ID: memo.ID, ID: memo.ID,
Content: &updatedContent, Content: &updatedContent,
}) })
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, updatedContent, memo.Content) require.Equal(t, updatedContent, memo.Content)
require.Equal(t, true, memo.Pinned) require.Equal(t, true, memo.Pinned)
err = s.deleteMemo(&api.MemoDelete{ err = s.deleteMemo(memo.ID)
ID: memo.ID,
})
require.NoError(t, err) require.NoError(t, err)
memoList, err = s.getMemoList() memoList, err = s.getMemoList()
require.NoError(t, err) require.NoError(t, err)
require.Len(t, memoList, 1) require.Len(t, memoList, 1)
} }
func (s *TestingServer) getMemo(memoID int) (*api.Memo, error) { func (s *TestingServer) getMemo(memoID int) (*api.MemoResponse, error) {
body, err := s.get(fmt.Sprintf("/api/memo/%d", memoID), nil) body, err := s.get(fmt.Sprintf("/api/memo/%d", memoID), nil)
if err != nil { if err != nil {
return nil, err return nil, err
@ -79,7 +77,7 @@ func (s *TestingServer) getMemo(memoID int) (*api.Memo, error) {
} }
type MemoCreateResponse struct { type MemoCreateResponse struct {
Data *api.Memo `json:"data"` Data *api.MemoResponse `json:"data"`
} }
res := new(MemoCreateResponse) res := new(MemoCreateResponse)
if err = json.Unmarshal(buf.Bytes(), res); err != nil { if err = json.Unmarshal(buf.Bytes(), res); err != nil {
@ -88,7 +86,7 @@ func (s *TestingServer) getMemo(memoID int) (*api.Memo, error) {
return res.Data, nil return res.Data, nil
} }
func (s *TestingServer) getMemoList() ([]*api.Memo, error) { func (s *TestingServer) getMemoList() ([]*api.MemoResponse, error) {
body, err := s.get("/api/memo", nil) body, err := s.get("/api/memo", nil)
if err != nil { if err != nil {
return nil, err return nil, err
@ -101,7 +99,7 @@ func (s *TestingServer) getMemoList() ([]*api.Memo, error) {
} }
type MemoCreateResponse struct { type MemoCreateResponse struct {
Data []*api.Memo `json:"data"` Data []*api.MemoResponse `json:"data"`
} }
res := new(MemoCreateResponse) res := new(MemoCreateResponse)
if err = json.Unmarshal(buf.Bytes(), res); err != nil { if err = json.Unmarshal(buf.Bytes(), res); err != nil {
@ -110,7 +108,7 @@ func (s *TestingServer) getMemoList() ([]*api.Memo, error) {
return res.Data, nil return res.Data, nil
} }
func (s *TestingServer) postMemoCreate(memoCreate *api.MemoCreate) (*api.Memo, error) { func (s *TestingServer) postMemoCreate(memoCreate *api.CreateMemoRequest) (*api.MemoResponse, error) {
rawData, err := json.Marshal(&memoCreate) rawData, err := json.Marshal(&memoCreate)
if err != nil { if err != nil {
return nil, errors.Wrap(err, "failed to marshal memo create") return nil, errors.Wrap(err, "failed to marshal memo create")
@ -128,7 +126,7 @@ func (s *TestingServer) postMemoCreate(memoCreate *api.MemoCreate) (*api.Memo, e
} }
type MemoCreateResponse struct { type MemoCreateResponse struct {
Data *api.Memo `json:"data"` Data *api.MemoResponse `json:"data"`
} }
res := new(MemoCreateResponse) res := new(MemoCreateResponse)
if err = json.Unmarshal(buf.Bytes(), res); err != nil { if err = json.Unmarshal(buf.Bytes(), res); err != nil {
@ -137,7 +135,7 @@ func (s *TestingServer) postMemoCreate(memoCreate *api.MemoCreate) (*api.Memo, e
return res.Data, nil return res.Data, nil
} }
func (s *TestingServer) patchMemo(memoPatch *api.MemoPatch) (*api.Memo, error) { func (s *TestingServer) patchMemo(memoPatch *api.PatchMemoRequest) (*api.MemoResponse, error) {
rawData, err := json.Marshal(&memoPatch) rawData, err := json.Marshal(&memoPatch)
if err != nil { if err != nil {
return nil, errors.Wrap(err, "failed to marshal memo patch") return nil, errors.Wrap(err, "failed to marshal memo patch")
@ -155,7 +153,7 @@ func (s *TestingServer) patchMemo(memoPatch *api.MemoPatch) (*api.Memo, error) {
} }
type MemoPatchResponse struct { type MemoPatchResponse struct {
Data *api.Memo `json:"data"` Data *api.MemoResponse `json:"data"`
} }
res := new(MemoPatchResponse) res := new(MemoPatchResponse)
if err = json.Unmarshal(buf.Bytes(), res); err != nil { if err = json.Unmarshal(buf.Bytes(), res); err != nil {
@ -164,12 +162,12 @@ func (s *TestingServer) patchMemo(memoPatch *api.MemoPatch) (*api.Memo, error) {
return res.Data, nil return res.Data, nil
} }
func (s *TestingServer) deleteMemo(memoDelete *api.MemoDelete) error { func (s *TestingServer) deleteMemo(memoID int) error {
_, err := s.delete(fmt.Sprintf("/api/memo/%d", memoDelete.ID), nil) _, err := s.delete(fmt.Sprintf("/api/memo/%d", memoID), nil)
return err return err
} }
func (s *TestingServer) postMemosOrganizer(memosOrganizer *api.MemoOrganizerUpsert) (*api.Memo, error) { func (s *TestingServer) postMemosOrganizer(memosOrganizer *api.MemoOrganizerUpsert) (*api.MemoResponse, error) {
rawData, err := json.Marshal(&memosOrganizer) rawData, err := json.Marshal(&memosOrganizer)
if err != nil { if err != nil {
return nil, errors.Wrap(err, "failed to marshal memos organizer") return nil, errors.Wrap(err, "failed to marshal memos organizer")
@ -187,7 +185,7 @@ func (s *TestingServer) postMemosOrganizer(memosOrganizer *api.MemoOrganizerUpse
} }
type MemoOrganizerResponse struct { type MemoOrganizerResponse struct {
Data *api.Memo `json:"data"` Data *api.MemoResponse `json:"data"`
} }
res := new(MemoOrganizerResponse) res := new(MemoOrganizerResponse)
if err = json.Unmarshal(buf.Bytes(), res); err != nil { if err = json.Unmarshal(buf.Bytes(), res); err != nil {

15
test/store/memo_relation_test.go
View File

@ -5,7 +5,6 @@ import (
"testing" "testing"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/usememos/memos/api"
"github.com/usememos/memos/store" "github.com/usememos/memos/store"
) )
@ -14,22 +13,22 @@ func TestMemoRelationStore(t *testing.T) {
ts := NewTestingStore(ctx, t) ts := NewTestingStore(ctx, t)
user, err := createTestingHostUser(ctx, ts) user, err := createTestingHostUser(ctx, ts)
require.NoError(t, err) require.NoError(t, err)
memoCreate := &api.MemoCreate{ memoCreate := &store.MemoMessage{
CreatorID: user.ID, CreatorID: user.ID,
Content: "test_content", Content: "test_content",
Visibility: api.Public, Visibility: store.Public,
} }
memo, err := ts.CreateMemo(ctx, memoCreate) memo, err := ts.CreateMemo(ctx, memoCreate)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, memoCreate.Content, memo.Content) require.Equal(t, memoCreate.Content, memo.Content)
memoCreate = &api.MemoCreate{ memo2Create := &store.MemoMessage{
CreatorID: user.ID, CreatorID: user.ID,
Content: "test_content_2", Content: "test_content_2",
Visibility: api.Public, Visibility: store.Public,
} }
memo2, err := ts.CreateMemo(ctx, memoCreate) memo2, err := ts.CreateMemo(ctx, memo2Create)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, memoCreate.Content, memo2.Content) require.Equal(t, memo2Create.Content, memo2.Content)
memoRelationMessage := &store.MemoRelationMessage{ memoRelationMessage := &store.MemoRelationMessage{
MemoID: memo.ID, MemoID: memo.ID,
RelatedMemoID: memo2.ID, RelatedMemoID: memo2.ID,
@ -45,7 +44,7 @@ func TestMemoRelationStore(t *testing.T) {
require.Equal(t, memo2.ID, memoRelation[0].RelatedMemoID) require.Equal(t, memo2.ID, memoRelation[0].RelatedMemoID)
require.Equal(t, memo.ID, memoRelation[0].MemoID) require.Equal(t, memo.ID, memoRelation[0].MemoID)
require.Equal(t, store.MemoRelationReference, memoRelation[0].Type) require.Equal(t, store.MemoRelationReference, memoRelation[0].Type)
err = ts.DeleteMemo(ctx, &api.MemoDelete{ err = ts.DeleteMemo(ctx, &store.DeleteMemoMessage{
ID: memo2.ID, ID: memo2.ID,
}) })
require.NoError(t, err) require.NoError(t, err)

25
test/store/memo_test.go
View File

@ -5,37 +5,40 @@ import (
"testing" "testing"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/usememos/memos/api" "github.com/usememos/memos/store"
) )
func TestMemoStore(t *testing.T) { func TestMemoStore(t *testing.T) {
ctx := context.Background() ctx := context.Background()
store := NewTestingStore(ctx, t) ts := NewTestingStore(ctx, t)
user, err := createTestingHostUser(ctx, store) user, err := createTestingHostUser(ctx, ts)
require.NoError(t, err) require.NoError(t, err)
memoCreate := &api.MemoCreate{ memoCreate := &store.MemoMessage{
CreatorID: user.ID, CreatorID: user.ID,
Content: "test_content", Content: "test_content",
Visibility: api.Public, Visibility: store.Public,
} }
memo, err := store.CreateMemo(ctx, memoCreate) memo, err := ts.CreateMemo(ctx, memoCreate)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, memoCreate.Content, memo.Content) require.Equal(t, memoCreate.Content, memo.Content)
memoPatchContent := "test_content_2" memoPatchContent := "test_content_2"
memoPatch := &api.MemoPatch{ memoPatch := &store.UpdateMemoMessage{
ID: memo.ID, ID: memo.ID,
Content: &memoPatchContent, Content: &memoPatchContent,
} }
memo, err = store.PatchMemo(ctx, memoPatch) err = ts.UpdateMemo(ctx, memoPatch)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, memoPatchContent, memo.Content) memo, err = ts.GetMemo(ctx, &store.FindMemoMessage{
memoList, err := store.FindMemoList(ctx, &api.MemoFind{ ID: &memo.ID,
})
require.NoError(t, err)
memoList, err := ts.ListMemos(ctx, &store.FindMemoMessage{
CreatorID: &user.ID, CreatorID: &user.ID,
}) })
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, 2, len(memoList)) require.Equal(t, 2, len(memoList))
require.Equal(t, memo, memoList[1]) require.Equal(t, memo, memoList[1])
err = store.DeleteMemo(ctx, &api.MemoDelete{ err = ts.DeleteMemo(ctx, &store.DeleteMemoMessage{
ID: memo.ID, ID: memo.ID,
}) })
require.NoError(t, err) require.NoError(t, err)