2023-07-02 13:56:25 +03:00
|
|
|
package v1
|
2022-06-21 16:58:33 +03:00
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
2022-12-21 18:59:03 +03:00
|
|
|
"fmt"
|
2022-06-21 16:58:33 +03:00
|
|
|
"net/http"
|
|
|
|
"regexp"
|
2022-07-02 10:01:59 +03:00
|
|
|
"sort"
|
2022-06-21 16:58:33 +03:00
|
|
|
|
2023-07-02 13:56:25 +03:00
|
|
|
"github.com/labstack/echo/v4"
|
2023-01-02 18:18:12 +03:00
|
|
|
"github.com/pkg/errors"
|
2023-05-25 16:50:37 +03:00
|
|
|
"github.com/usememos/memos/store"
|
2023-01-13 17:37:30 +03:00
|
|
|
"golang.org/x/exp/slices"
|
2022-06-21 16:58:33 +03:00
|
|
|
)
|
|
|
|
|
2023-07-02 13:56:25 +03:00
|
|
|
type Tag struct {
|
|
|
|
Name string
|
2023-08-04 16:55:07 +03:00
|
|
|
CreatorID int32
|
2023-07-02 13:56:25 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
type UpsertTagRequest struct {
|
|
|
|
Name string `json:"name"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type DeleteTagRequest struct {
|
|
|
|
Name string `json:"name"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *APIV1Service) registerTagRoutes(g *echo.Group) {
|
2023-08-09 17:30:27 +03:00
|
|
|
g.GET("/tag", s.GetTagList)
|
|
|
|
g.POST("/tag", s.CreateTag)
|
|
|
|
g.GET("/tag/suggestion", s.GetTagSuggestion)
|
|
|
|
g.POST("/tag/delete", s.DeleteTag)
|
2023-08-09 16:53:06 +03:00
|
|
|
}
|
2022-12-21 18:59:03 +03:00
|
|
|
|
2023-08-09 17:30:27 +03:00
|
|
|
// GetTagList godoc
|
2023-08-09 16:53:06 +03:00
|
|
|
//
|
|
|
|
// @Summary Get a list of tags
|
|
|
|
// @Tags tag
|
|
|
|
// @Produce json
|
|
|
|
// @Success 200 {object} []string "Tag list"
|
|
|
|
// @Failure 400 {object} nil "Missing user id to find tag"
|
|
|
|
// @Failure 500 {object} nil "Failed to find tag list"
|
|
|
|
// @Security ApiKeyAuth
|
|
|
|
// @Router /api/v1/tag [GET]
|
2023-08-09 17:30:27 +03:00
|
|
|
func (s *APIV1Service) GetTagList(c echo.Context) error {
|
2023-08-09 16:53:06 +03:00
|
|
|
ctx := c.Request().Context()
|
2023-09-14 15:16:17 +03:00
|
|
|
userID, ok := c.Get(userIDContextKey).(int32)
|
2023-08-09 16:53:06 +03:00
|
|
|
if !ok {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, "Missing user id to find tag")
|
|
|
|
}
|
2022-12-21 18:59:03 +03:00
|
|
|
|
2023-08-09 16:53:06 +03:00
|
|
|
list, err := s.Store.ListTags(ctx, &store.FindTag{
|
|
|
|
CreatorID: userID,
|
2022-12-21 18:59:03 +03:00
|
|
|
})
|
2023-08-09 16:53:06 +03:00
|
|
|
if err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find tag list").SetInternal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
tagNameList := []string{}
|
|
|
|
for _, tag := range list {
|
|
|
|
tagNameList = append(tagNameList, tag.Name)
|
|
|
|
}
|
|
|
|
return c.JSON(http.StatusOK, tagNameList)
|
|
|
|
}
|
2022-12-21 18:59:03 +03:00
|
|
|
|
2023-08-09 17:30:27 +03:00
|
|
|
// CreateTag godoc
|
2023-08-09 16:53:06 +03:00
|
|
|
//
|
|
|
|
// @Summary Create a tag
|
|
|
|
// @Tags tag
|
|
|
|
// @Accept json
|
|
|
|
// @Produce json
|
|
|
|
// @Param body body UpsertTagRequest true "Request object."
|
|
|
|
// @Success 200 {object} string "Created tag name"
|
|
|
|
// @Failure 400 {object} nil "Malformatted post tag request | Tag name shouldn't be empty"
|
|
|
|
// @Failure 401 {object} nil "Missing user in session"
|
|
|
|
// @Failure 500 {object} nil "Failed to upsert tag | Failed to create activity"
|
|
|
|
// @Security ApiKeyAuth
|
|
|
|
// @Router /api/v1/tag [POST]
|
2023-08-09 17:30:27 +03:00
|
|
|
func (s *APIV1Service) CreateTag(c echo.Context) error {
|
2023-08-09 16:53:06 +03:00
|
|
|
ctx := c.Request().Context()
|
2023-09-14 15:16:17 +03:00
|
|
|
userID, ok := c.Get(userIDContextKey).(int32)
|
2023-08-09 16:53:06 +03:00
|
|
|
if !ok {
|
|
|
|
return echo.NewHTTPError(http.StatusUnauthorized, "Missing user in session")
|
|
|
|
}
|
|
|
|
|
|
|
|
tagUpsert := &UpsertTagRequest{}
|
|
|
|
if err := json.NewDecoder(c.Request().Body).Decode(tagUpsert); err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, "Malformatted post tag request").SetInternal(err)
|
|
|
|
}
|
|
|
|
if tagUpsert.Name == "" {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, "Tag name shouldn't be empty")
|
|
|
|
}
|
|
|
|
|
|
|
|
tag, err := s.Store.UpsertTag(ctx, &store.Tag{
|
|
|
|
Name: tagUpsert.Name,
|
|
|
|
CreatorID: userID,
|
2022-12-21 18:59:03 +03:00
|
|
|
})
|
2023-08-09 16:53:06 +03:00
|
|
|
if err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert tag").SetInternal(err)
|
|
|
|
}
|
|
|
|
tagMessage := convertTagFromStore(tag)
|
|
|
|
if err := s.createTagCreateActivity(c, tagMessage); err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create activity").SetInternal(err)
|
|
|
|
}
|
|
|
|
return c.JSON(http.StatusOK, tagMessage.Name)
|
|
|
|
}
|
2022-12-21 18:59:03 +03:00
|
|
|
|
2023-08-09 17:30:27 +03:00
|
|
|
// DeleteTag godoc
|
2023-08-09 16:53:06 +03:00
|
|
|
//
|
|
|
|
// @Summary Delete a tag
|
|
|
|
// @Tags tag
|
|
|
|
// @Accept json
|
|
|
|
// @Produce json
|
|
|
|
// @Param body body DeleteTagRequest true "Request object."
|
|
|
|
// @Success 200 {boolean} true "Tag deleted"
|
|
|
|
// @Failure 400 {object} nil "Malformatted post tag request | Tag name shouldn't be empty"
|
|
|
|
// @Failure 401 {object} nil "Missing user in session"
|
|
|
|
// @Failure 500 {object} nil "Failed to delete tag name: %v"
|
|
|
|
// @Security ApiKeyAuth
|
|
|
|
// @Router /api/v1/tag/delete [POST]
|
2023-08-09 17:30:27 +03:00
|
|
|
func (s *APIV1Service) DeleteTag(c echo.Context) error {
|
2023-08-09 16:53:06 +03:00
|
|
|
ctx := c.Request().Context()
|
2023-09-14 15:16:17 +03:00
|
|
|
userID, ok := c.Get(userIDContextKey).(int32)
|
2023-08-09 16:53:06 +03:00
|
|
|
if !ok {
|
|
|
|
return echo.NewHTTPError(http.StatusUnauthorized, "Missing user in session")
|
|
|
|
}
|
|
|
|
|
|
|
|
tagDelete := &DeleteTagRequest{}
|
|
|
|
if err := json.NewDecoder(c.Request().Body).Decode(tagDelete); err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, "Malformatted post tag request").SetInternal(err)
|
|
|
|
}
|
|
|
|
if tagDelete.Name == "" {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, "Tag name shouldn't be empty")
|
|
|
|
}
|
|
|
|
|
|
|
|
err := s.Store.DeleteTag(ctx, &store.DeleteTag{
|
|
|
|
Name: tagDelete.Name,
|
|
|
|
CreatorID: userID,
|
2022-06-21 16:58:33 +03:00
|
|
|
})
|
2023-08-09 16:53:06 +03:00
|
|
|
if err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("Failed to delete tag name: %v", tagDelete.Name)).SetInternal(err)
|
|
|
|
}
|
|
|
|
return c.JSON(http.StatusOK, true)
|
|
|
|
}
|
2022-12-21 18:59:03 +03:00
|
|
|
|
2023-08-09 17:30:27 +03:00
|
|
|
// GetTagSuggestion godoc
|
2023-08-09 16:53:06 +03:00
|
|
|
//
|
|
|
|
// @Summary Get a list of tags suggested from other memos contents
|
|
|
|
// @Tags tag
|
|
|
|
// @Produce json
|
|
|
|
// @Success 200 {object} []string "Tag list"
|
|
|
|
// @Failure 400 {object} nil "Missing user session"
|
|
|
|
// @Failure 500 {object} nil "Failed to find memo list | Failed to find tag list"
|
|
|
|
// @Security ApiKeyAuth
|
|
|
|
// @Router /api/v1/tag/suggestion [GET]
|
2023-08-09 17:30:27 +03:00
|
|
|
func (s *APIV1Service) GetTagSuggestion(c echo.Context) error {
|
2023-08-09 16:53:06 +03:00
|
|
|
ctx := c.Request().Context()
|
2023-09-14 15:16:17 +03:00
|
|
|
userID, ok := c.Get(userIDContextKey).(int32)
|
2023-08-09 16:53:06 +03:00
|
|
|
if !ok {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, "Missing user session")
|
|
|
|
}
|
|
|
|
normalRowStatus := store.Normal
|
|
|
|
memoFind := &store.FindMemo{
|
|
|
|
CreatorID: &userID,
|
|
|
|
ContentSearch: []string{"#"},
|
|
|
|
RowStatus: &normalRowStatus,
|
|
|
|
}
|
|
|
|
|
|
|
|
memoMessageList, err := s.Store.ListMemos(ctx, memoFind)
|
|
|
|
if err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
list, err := s.Store.ListTags(ctx, &store.FindTag{
|
|
|
|
CreatorID: userID,
|
2022-12-21 18:59:03 +03:00
|
|
|
})
|
2023-08-09 16:53:06 +03:00
|
|
|
if err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find tag list").SetInternal(err)
|
|
|
|
}
|
|
|
|
tagNameList := []string{}
|
|
|
|
for _, tag := range list {
|
|
|
|
tagNameList = append(tagNameList, tag.Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
tagMapSet := make(map[string]bool)
|
|
|
|
for _, memo := range memoMessageList {
|
|
|
|
for _, tag := range findTagListFromMemoContent(memo.Content) {
|
|
|
|
if !slices.Contains(tagNameList, tag) {
|
|
|
|
tagMapSet[tag] = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tagList := []string{}
|
|
|
|
for tag := range tagMapSet {
|
|
|
|
tagList = append(tagList, tag)
|
|
|
|
}
|
|
|
|
sort.Strings(tagList)
|
|
|
|
return c.JSON(http.StatusOK, tagList)
|
2022-06-21 16:58:33 +03:00
|
|
|
}
|
2022-11-12 04:02:44 +03:00
|
|
|
|
2023-07-02 13:56:25 +03:00
|
|
|
func (s *APIV1Service) createTagCreateActivity(c echo.Context, tag *Tag) error {
|
|
|
|
ctx := c.Request().Context()
|
|
|
|
payload := ActivityTagCreatePayload{
|
|
|
|
TagName: tag.Name,
|
|
|
|
}
|
|
|
|
payloadBytes, err := json.Marshal(payload)
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "failed to marshal activity payload")
|
|
|
|
}
|
2023-07-06 16:56:42 +03:00
|
|
|
activity, err := s.Store.CreateActivity(ctx, &store.Activity{
|
2023-07-02 13:56:25 +03:00
|
|
|
CreatorID: tag.CreatorID,
|
|
|
|
Type: ActivityTagCreate.String(),
|
|
|
|
Level: ActivityInfo.String(),
|
|
|
|
Payload: string(payloadBytes),
|
|
|
|
})
|
|
|
|
if err != nil || activity == nil {
|
|
|
|
return errors.Wrap(err, "failed to create activity")
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
func convertTagFromStore(tag *store.Tag) *Tag {
|
|
|
|
return &Tag{
|
|
|
|
Name: tag.Name,
|
|
|
|
CreatorID: tag.CreatorID,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-26 16:11:13 +03:00
|
|
|
var tagRegexp = regexp.MustCompile(`#([^\s#,]+)`)
|
2022-12-21 18:59:03 +03:00
|
|
|
|
2022-11-12 04:02:44 +03:00
|
|
|
func findTagListFromMemoContent(memoContent string) []string {
|
|
|
|
tagMapSet := make(map[string]bool)
|
2022-12-21 18:59:03 +03:00
|
|
|
matches := tagRegexp.FindAllStringSubmatch(memoContent, -1)
|
|
|
|
for _, v := range matches {
|
|
|
|
tagName := v[1]
|
|
|
|
tagMapSet[tagName] = true
|
2022-11-12 04:02:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
tagList := []string{}
|
|
|
|
for tag := range tagMapSet {
|
|
|
|
tagList = append(tagList, tag)
|
|
|
|
}
|
|
|
|
sort.Strings(tagList)
|
|
|
|
return tagList
|
|
|
|
}
|