feat: implement telegram bot plugin (#1740)

api/system_setting.go

@@ -34,6 +34,8 @@ const (
 	SystemSettingLocalStoragePathName SystemSettingName = "local-storage-path"
 	// SystemSettingOpenAIConfigName is the name of OpenAI config.
 	SystemSettingOpenAIConfigName SystemSettingName = "openai-config"
+	// SystemSettingTelegramRobotToken is the name of Telegram Robot Token.
+	SystemSettingTelegramRobotTokenName SystemSettingName = "telegram-robot-token"
 )
 
 // CustomizedProfile is the struct definition for SystemSettingCustomizedProfileName system setting item.
@@ -83,6 +85,8 @@ func (key SystemSettingName) String() string {
 		return "local-storage-path"
 	case SystemSettingOpenAIConfigName:
 		return "openai-config"
+	case SystemSettingTelegramRobotTokenName:
+		return "telegram-robot-token"
 	}
 	return ""
 }

api/user_setting.go

@@ -16,6 +16,8 @@ const (
 	UserSettingAppearanceKey UserSettingKey = "appearance"
 	// UserSettingMemoVisibilityKey is the key type for user preference memo default visibility.
 	UserSettingMemoVisibilityKey UserSettingKey = "memo-visibility"
+	// UserSettingTelegramUserID is the key type for telegram UserID of memos user.
+	UserSettingTelegramUserIDKey UserSettingKey = "telegram-user-id"
 )
 
 // String returns the string format of UserSettingKey type.
@@ -27,6 +29,8 @@ func (key UserSettingKey) String() string {
 		return "appearance"
 	case UserSettingMemoVisibilityKey:
 		return "memo-visibility"
+	case UserSettingTelegramUserIDKey:
+		return "telegram-user-id"
 	}
 	return ""
 }
@@ -96,6 +100,15 @@ func (upsert UserSettingUpsert) Validate() error {
 		if !slices.Contains(UserSettingMemoVisibilityValue, memoVisibilityValue) {
 			return fmt.Errorf("invalid user setting memo visibility value")
 		}
+	} else if upsert.Key == UserSettingTelegramUserIDKey {
+		telegramUserID := 0
+		err := json.Unmarshal([]byte(upsert.Value), &telegramUserID)
+		if err != nil {
+			return fmt.Errorf("failed to unmarshal user setting telegram userid value")
+		}
+		if telegramUserID <= 0 {
+			return fmt.Errorf("invalid user setting telegram userid value")
+		}
 	} else {
 		return fmt.Errorf("invalid user setting key")
 	}
@@ -104,7 +117,7 @@ func (upsert UserSettingUpsert) Validate() error {
 }
 
 type UserSettingFind struct {
-	UserID int
+	UserID *int
 
 	Key UserSettingKey `json:"key"`
 }

plugin/telegram/api_edit_message.go

+package telegram
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+)
+
+// EditMessage make an editMessageText api request.
+func (r *Robot) EditMessage(ctx context.Context, chatID, messageID int, text string) (*Message, error) {
+	formData := url.Values{
+		"message_id": {strconv.Itoa(messageID)},
+		"chat_id":    {strconv.Itoa(chatID)},
+		"text":       {text},
+	}
+
+	var result Message
+	err := r.postForm(ctx, "/editMessageText", formData, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return &result, nil
+}

plugin/telegram/api_get_file.go

+package telegram
+
+import (
+	"context"
+	"net/url"
+)
+
+// GetFile get download info of File by fileID from Telegram.
+func (r *Robot) GetFile(ctx context.Context, fileID string) (*File, error) {
+	formData := url.Values{
+		"file_id": {fileID},
+	}
+
+	var result File
+	err := r.postForm(ctx, "/getFile", formData, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return &result, nil
+}

plugin/telegram/api_get_updates.go

+package telegram
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+)
+
+// GetUpdates make a getUpdates api request.
+func (r *Robot) GetUpdates(ctx context.Context, offset int) ([]Update, error) {
+	formData := url.Values{
+		"timeout": {"60"},
+		"offset":  {strconv.Itoa(offset)},
+	}
+
+	var result []Update
+	err := r.postForm(ctx, "/getUpdates", formData, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}

plugin/telegram/api_send_message.go

+package telegram
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+)
+
+// SendReplyMessage make a sendMessage api request.
+func (r *Robot) SendReplyMessage(ctx context.Context, chatID, replyID int, text string) (*Message, error) {
+	formData := url.Values{
+		"reply_to_message_id": {strconv.Itoa(replyID)},
+		"chat_id":             {strconv.Itoa(chatID)},
+		"text":                {text},
+	}
+
+	var result Message
+	err := r.postForm(ctx, "/sendMessage", formData, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return &result, nil
+}

plugin/telegram/chat.go

+package telegram
+
+type Chat struct {
+	ID        int    `json:"id"`
+	Title     string `json:"title"`
+	Type      string `json:"type"`
+	FirstName string `json:"first_name"`
+	LastName  string `json:"last_name"`
+}

plugin/telegram/download.go

+package telegram
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+)
+
+// downloadFileId download file with fileID, return the filepath and blob.
+func (r *Robot) downloadFileID(ctx context.Context, fileID string) (string, []byte, error) {
+	file, err := r.GetFile(ctx, fileID)
+	if err != nil {
+		return "", nil, err
+	}
+	blob, err := r.downloadFilepath(ctx, file.FilePath)
+	if err != nil {
+		return "", nil, err
+	}
+
+	return file.FilePath, blob, nil
+}
+
+// downloadFilepath download file with filepath, you can get filepath by calling GetFile.
+func (r *Robot) downloadFilepath(ctx context.Context, filePath string) ([]byte, error) {
+	token := r.handler.RobotToken(ctx)
+	if token == "" {
+		return nil, ErrNoToken
+	}
+
+	uri := "https://api.telegram.org/file/bot" + token + "/" + filePath
+	resp, err := http.Get(uri)
+	if err != nil {
+		return nil, fmt.Errorf("fail to http.Get: %s", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("fail to io.ReadAll: %s", err)
+	}
+
+	return body, nil
+}

plugin/telegram/file.go

+package telegram
+
+type File struct {
+	FileID       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	FileSize     int64  `json:"file_size"`
+	FilePath     string `json:"file_path"`
+}

plugin/telegram/handle.go

+package telegram
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/usememos/memos/common/log"
+	"go.uber.org/zap"
+)
+
+// notice message send to telegram.
+const (
+	workingMessage = "Working on send your memo..."
+	successMessage = "Success"
+)
+
+// handleSingleMessage handle a message not belongs to group.
+func (r *Robot) handleSingleMessage(ctx context.Context, message Message) error {
+	reply, err := r.SendReplyMessage(ctx, message.Chat.ID, message.MessageID, workingMessage)
+	if err != nil {
+		return fmt.Errorf("fail to SendReplyMessage: %s", err)
+	}
+
+	var blobs map[string][]byte
+
+	// download blob if need
+	if len(message.Photo) > 0 {
+		filepath, blob, err := r.downloadFileID(ctx, message.GetMaxPhotoFileID())
+		if err != nil {
+			log.Error("fail to downloadFileID", zap.Error(err))
+			_, err = r.EditMessage(ctx, message.Chat.ID, reply.MessageID, err.Error())
+			if err != nil {
+				return fmt.Errorf("fail to EditMessage: %s", err)
+			}
+			return fmt.Errorf("fail to downloadFileID: %s", err)
+		}
+		blobs = map[string][]byte{filepath: blob}
+	}
+
+	err = r.handler.MessageHandle(ctx, message, blobs)
+	if err != nil {
+		if _, err := r.EditMessage(ctx, message.Chat.ID, reply.MessageID, err.Error()); err != nil {
+			return fmt.Errorf("fail to EditMessage: %s", err)
+		}
+		return fmt.Errorf("fail to MessageHandle: %s", err)
+	}
+
+	if _, err := r.EditMessage(ctx, message.Chat.ID, reply.MessageID, successMessage); err != nil {
+		return fmt.Errorf("fail to EditMessage: %s", err)
+	}
+
+	return nil
+}
+
+// handleGroupMessages handle a message belongs to group.
+func (r *Robot) handleGroupMessages(ctx context.Context, groupMessages []Message) error {
+	captions := make(map[string]string, len(groupMessages))
+	messages := make(map[string]Message, len(groupMessages))
+	blobs := make(map[string]map[string][]byte, len(groupMessages))
+
+	// Group all captions, blobs and messages
+	for _, message := range groupMessages {
+		groupID := *message.MediaGroupID
+
+		messages[groupID] = message
+
+		if message.Caption != nil {
+			captions[groupID] += *message.Caption
+		}
+
+		filepath, blob, err := r.downloadFileID(ctx, message.GetMaxPhotoFileID())
+		if err != nil {
+			return fmt.Errorf("fail to downloadFileID")
+		}
+		if _, found := blobs[groupID]; !found {
+			blobs[groupID] = make(map[string][]byte)
+		}
+		blobs[groupID][filepath] = blob
+	}
+
+	// Handle each group message
+	for groupID, message := range messages {
+		reply, err := r.SendReplyMessage(ctx, message.Chat.ID, message.MessageID, workingMessage)
+		if err != nil {
+			return fmt.Errorf("fail to SendReplyMessage: %s", err)
+		}
+
+		// replace Caption with all Caption in the group
+		caption := captions[groupID]
+		message.Caption = &caption
+		if err := r.handler.MessageHandle(ctx, message, blobs[groupID]); err != nil {
+			if _, err = r.EditMessage(ctx, message.Chat.ID, reply.MessageID, err.Error()); err != nil {
+				return fmt.Errorf("fail to EditMessage: %s", err)
+			}
+			return fmt.Errorf("fail to MessageHandle: %s", err)
+		}
+
+		if _, err := r.EditMessage(ctx, message.Chat.ID, reply.MessageID, successMessage); err != nil {
+			return fmt.Errorf("fail to EditMessage: %s", err)
+		}
+	}
+
+	return nil
+}

plugin/telegram/message.go

+package telegram
+
+type Message struct {
+	MessageID    int         `json:"message_id"`
+	From         User        `json:"from"`
+	Date         int         `json:"date"`
+	Text         *string     `json:"text"`
+	Chat         *Chat       `json:"chat"`
+	MediaGroupID *string     `json:"media_group_id"`
+	Photo        []PhotoSize `json:"photo"`
+	Caption      *string     `json:"caption"`
+}
+
+func (m Message) GetMaxPhotoFileID() string {
+	var fileSize int64
+	var photoSize PhotoSize
+	for _, p := range m.Photo {
+		if p.FileSize > fileSize {
+			photoSize = p
+		}
+	}
+
+	return photoSize.FileID
+}

plugin/telegram/photosize.go

+package telegram
+
+type PhotoSize struct {
+	FileID       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	FileSize     int64  `json:"file_size"`
+	Width        int    `json:"width"`
+	Height       int    `json:"height"`
+}

plugin/telegram/request.go

+package telegram
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+)
+
+var ErrNoToken = errors.New("token is empty")
+
+func (r *Robot) postForm(ctx context.Context, apiPath string, formData url.Values, result any) error {
+	token := r.handler.RobotToken(ctx)
+	if token == "" {
+		return ErrNoToken
+	}
+
+	uri := "https://api.telegram.org/bot" + token + apiPath
+	resp, err := http.PostForm(uri, formData)
+	if err != nil {
+		return fmt.Errorf("fail to http.PostForm: %s", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("fail to ioutil.ReadAll: %s", err)
+	}
+
+	var respInfo struct {
+		Ok          bool   `json:"ok"`
+		ErrorCode   int    `json:"error_code"`
+		Description string `json:"description"`
+		Result      any    `json:"result"`
+	}
+
+	respInfo.Result = result
+
+	err = json.Unmarshal(body, &respInfo)
+	if err != nil {
+		return fmt.Errorf("fail to json.Unmarshal: %s", err)
+	}
+
+	if !respInfo.Ok {
+		return fmt.Errorf("api error: [%d]%s", respInfo.ErrorCode, respInfo.Description)
+	}
+
+	return nil
+}

plugin/telegram/robot.go

+package telegram
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/usememos/memos/common/log"
+	"go.uber.org/zap"
+)
+
+type Handler interface {
+	RobotToken(ctx context.Context) string
+	MessageHandle(ctx context.Context, message Message, blobs map[string][]byte) error
+}
+
+type Robot struct {
+	handler Handler
+}
+
+// NewRobotWithHandler create a telegram robot with specified handler.
+func NewRobotWithHandler(h Handler) *Robot {
+	return &Robot{handler: h}
+}
+
+const noTokenWait = 30 * time.Second
+
+// Start start an infinity call of getUpdates from Telegram, call r.MessageHandle while get new message updates.
+func (r *Robot) Start(ctx context.Context) {
+	var offset int
+
+	for {
+		updates, err := r.GetUpdates(ctx, offset)
+		if err == ErrNoToken {
+			time.Sleep(noTokenWait)
+			continue
+		}
+		if err != nil {
+			log.Warn("fail to telegram.GetUpdates", zap.Error(err))
+			continue
+		}
+
+		groupMessages := make([]Message, 0, len(updates))
+
+		for _, update := range updates {
+			offset = update.UpdateID + 1
+			if update.Message == nil {
+				continue
+			}
+			message := *update.Message
+
+			// skip message other than text or photo
+			if message.Text == nil && message.Photo == nil {
+				_, err := r.SendReplyMessage(ctx, message.Chat.ID, message.MessageID, "Only text or photo message be supported")
+				if err != nil {
+					log.Error(fmt.Sprintf("fail to telegram.SendReplyMessage for messageID=%d", message.MessageID), zap.Error(err))
+				}
+				continue
+			}
+
+			// Group message need do more
+			if message.MediaGroupID != nil {
+				groupMessages = append(groupMessages, message)
+				continue
+			}
+
+			err = r.handleSingleMessage(ctx, message)
+			if err != nil {
+				log.Error(fmt.Sprintf("fail to handleSingleMessage for messageID=%d", message.MessageID), zap.Error(err))
+				continue
+			}
+		}
+
+		err = r.handleGroupMessages(ctx, groupMessages)
+		if err != nil {
+			log.Error("fail to handle plain text message", zap.Error(err))
+		}
+	}
+}

plugin/telegram/update.go

+package telegram
+
+type Update struct {
+	UpdateID int      `json:"update_id"`
+	Message  *Message `json:"message"`
+}

plugin/telegram/user.go

+package telegram
+
+type User struct {
+	ID int `json:"id"`
+}

server/memo.go

@@ -38,7 +38,7 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 
 		if createMemoRequest.Visibility == "" {
 			userMemoVisibilitySetting, err := s.Store.FindUserSetting(ctx, &api.UserSettingFind{
-				UserID: userID,
+				UserID: &userID,
 				Key:    api.UserSettingMemoVisibilityKey,
 			})
 			if err != nil {
@@ -90,7 +90,7 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create memo").SetInternal(err)
 		}
-		if err := s.createMemoCreateActivity(c, memoMessage); err != nil {
+		if err := createMemoCreateActivity(c.Request().Context(), s.Store, memoMessage); err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create activity").SetInternal(err)
 		}
 
@@ -503,8 +503,7 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 	})
 }
 
-func (s *Server) createMemoCreateActivity(c echo.Context, memo *store.MemoMessage) error {
-	ctx := c.Request().Context()
+func createMemoCreateActivity(ctx context.Context, store *store.Store, memo *store.MemoMessage) error {
 	payload := api.ActivityMemoCreatePayload{
 		Content:    memo.Content,
 		Visibility: memo.Visibility.String(),
@@ -513,7 +512,7 @@ func (s *Server) createMemoCreateActivity(c echo.Context, memo *store.MemoMessag
 	if err != nil {
 		return errors.Wrap(err, "failed to marshal activity payload")
 	}
-	activity, err := s.Store.CreateActivity(ctx, &api.ActivityCreate{
+	activity, err := store.CreateActivity(ctx, &api.ActivityCreate{
 		CreatorID: memo.CreatorID,
 		Type:      api.ActivityMemoCreate,
 		Level:     api.ActivityInfo,

server/resource.go

@@ -2,6 +2,7 @@ package server
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -23,6 +24,7 @@ import (
 	"github.com/usememos/memos/common"
 	"github.com/usememos/memos/common/log"
 	"github.com/usememos/memos/plugin/storage/s3"
+	"github.com/usememos/memos/store"
 	"go.uber.org/zap"
 )
 
@@ -62,7 +64,7 @@ func (s *Server) registerResourceRoutes(g *echo.Group) {
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create resource").SetInternal(err)
 		}
-		if err := s.createResourceCreateActivity(c, resource); err != nil {
+		if err := createResourceCreateActivity(c.Request().Context(), s.Store, resource); err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create activity").SetInternal(err)
 		}
 		return c.JSON(http.StatusOK, composeResponse(resource))
@@ -224,7 +226,7 @@ func (s *Server) registerResourceRoutes(g *echo.Group) {
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create resource").SetInternal(err)
 		}
-		if err := s.createResourceCreateActivity(c, resource); err != nil {
+		if err := createResourceCreateActivity(c.Request().Context(), s.Store, resource); err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create activity").SetInternal(err)
 		}
 		return c.JSON(http.StatusOK, composeResponse(resource))
@@ -454,8 +456,7 @@ func (s *Server) registerResourcePublicRoutes(g *echo.Group) {
 	})
 }
 
-func (s *Server) createResourceCreateActivity(c echo.Context, resource *api.Resource) error {
-	ctx := c.Request().Context()
+func createResourceCreateActivity(ctx context.Context, store *store.Store, resource *api.Resource) error {
 	payload := api.ActivityResourceCreatePayload{
 		Filename: resource.Filename,
 		Type:     resource.Type,
@@ -465,7 +466,7 @@ func (s *Server) createResourceCreateActivity(c echo.Context, resource *api.Reso
 	if err != nil {
 		return errors.Wrap(err, "failed to marshal activity payload")
 	}
-	activity, err := s.Store.CreateActivity(ctx, &api.ActivityCreate{
+	activity, err := store.CreateActivity(ctx, &api.ActivityCreate{
 		CreatorID: resource.CreatorID,
 		Type:      api.ActivityResourceCreate,
 		Level:     api.ActivityInfo,

server/server.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/usememos/memos/api"
+	"github.com/usememos/memos/plugin/telegram"
 	"github.com/usememos/memos/server/profile"
 	"github.com/usememos/memos/store"
 	"github.com/usememos/memos/store/db"
@@ -24,6 +25,8 @@ type Server struct {
 	ID      string
 	Profile *profile.Profile
 	Store   *store.Store
+
+	telegramRobot *telegram.Robot
 }
 
 func NewServer(ctx context.Context, profile *profile.Profile) (*Server, error) {
@@ -45,6 +48,9 @@ func NewServer(ctx context.Context, profile *profile.Profile) (*Server, error) {
 	storeInstance := store.New(db.DBInstance, profile)
 	s.Store = storeInstance
 
+	telegramRobotHandler := newTelegramHandler(storeInstance)
+	s.telegramRobot = telegram.NewRobotWithHandler(telegramRobotHandler)
+
 	e.Use(middleware.LoggerWithConfig(middleware.LoggerConfig{
 		Format: `{"time":"${time_rfc3339}",` +
 			`"method":"${method}","uri":"${uri}",` +
@@ -118,6 +124,9 @@ func (s *Server) Start(ctx context.Context) error {
 	if err := s.createServerStartActivity(ctx); err != nil {
 		return errors.Wrap(err, "failed to create activity")
 	}
+
+	go s.telegramRobot.Start(ctx)
+
 	return s.e.Start(fmt.Sprintf(":%d", s.Profile.Port))
 }
 

server/system.go

@@ -64,7 +64,7 @@ func (s *Server) registerSystemRoutes(g *echo.Group) {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find system setting list").SetInternal(err)
 		}
 		for _, systemSetting := range systemSettingList {
-			if systemSetting.Name == api.SystemSettingServerIDName || systemSetting.Name == api.SystemSettingSecretSessionName || systemSetting.Name == api.SystemSettingOpenAIConfigName {
+			if systemSetting.Name == api.SystemSettingServerIDName || systemSetting.Name == api.SystemSettingSecretSessionName || systemSetting.Name == api.SystemSettingOpenAIConfigName || systemSetting.Name == api.SystemSettingTelegramRobotTokenName {
 				continue
 			}
 

server/telegram.go

+package server
+
+import (
+	"context"
+	"fmt"
+	"path"
+	"strconv"
+
+	"github.com/usememos/memos/api"
+	"github.com/usememos/memos/common"
+	"github.com/usememos/memos/plugin/telegram"
+	"github.com/usememos/memos/store"
+)
+
+type telegramHandler struct {
+	store *store.Store
+}
+
+func newTelegramHandler(store *store.Store) *telegramHandler {
+	return &telegramHandler{store: store}
+}
+
+func (t *telegramHandler) RobotToken(ctx context.Context) string {
+	return t.store.GetSystemSettingValueOrDefault(&ctx, api.SystemSettingTelegramRobotTokenName, "")
+}
+
+func (t *telegramHandler) MessageHandle(ctx context.Context, message telegram.Message, blobs map[string][]byte) error {
+	var creatorID int
+	userSettingList, err := t.store.FindUserSettingList(ctx, &api.UserSettingFind{
+		Key: api.UserSettingTelegramUserIDKey,
+	})
+	if err != nil {
+		return fmt.Errorf("Fail to find memo user: %s", err)
+	}
+	for _, userSetting := range userSettingList {
+		if userSetting.Value == strconv.Itoa(message.From.ID) {
+			creatorID = userSetting.UserID
+		}
+	}
+
+	if creatorID == 0 {
+		return fmt.Errorf("Please set your telegram userid %d in UserSetting of Memos", message.From.ID)
+	}
+
+	// create memo
+	memoCreate := api.CreateMemoRequest{
+		CreatorID:  creatorID,
+		Visibility: api.Private,
+	}
+
+	if message.Text != nil {
+		memoCreate.Content = *message.Text
+	}
+	if blobs != nil && message.Caption != nil {
+		memoCreate.Content = *message.Caption
+	}
+
+	memoMessage, err := t.store.CreateMemo(ctx, convertCreateMemoRequestToMemoMessage(&memoCreate))
+	if err != nil {
+		return fmt.Errorf("failed to CreateMemo: %s", err)
+	}
+
+	if err := createMemoCreateActivity(ctx, t.store, memoMessage); err != nil {
+		return fmt.Errorf("failed to createMemoCreateActivity: %s", err)
+	}
+
+	// create resources
+	for filename, blob := range blobs {
+		// TODO support more
+		mime := "application/octet-stream"
+		switch path.Ext(filename) {
+		case ".jpg":
+			mime = "image/jpeg"
+		case ".png":
+			mime = "image/png"
+		}
+		resourceCreate := api.ResourceCreate{
+			CreatorID: creatorID,
+			Filename:  filename,
+			Type:      mime,
+			Size:      int64(len(blob)),
+			Blob:      blob,
+			PublicID:  common.GenUUID(),
+		}
+		resource, err := t.store.CreateResource(ctx, &resourceCreate)
+		if err != nil {
+			return fmt.Errorf("failed to CreateResource: %s", err)
+		}
+		if err := createResourceCreateActivity(ctx, t.store, resource); err != nil {
+			return fmt.Errorf("failed to createResourceCreateActivity: %s", err)
+		}
+
+		_, err = t.store.UpsertMemoResource(ctx, &api.MemoResourceUpsert{
+			MemoID:     memoMessage.ID,
+			ResourceID: resource.ID,
+		})
+		if err != nil {
+			return fmt.Errorf("failed to UpsertMemoResource: %s", err)
+		}
+	}
+	return nil
+}

server/user.go

@@ -116,7 +116,7 @@ func (s *Server) registerUserRoutes(g *echo.Group) {
 		}
 
 		userSettingList, err := s.Store.FindUserSettingList(ctx, &api.UserSettingFind{
-			UserID: userID,
+			UserID: &userID,
 		})
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find userSettingList").SetInternal(err)
@@ -203,7 +203,7 @@ func (s *Server) registerUserRoutes(g *echo.Group) {
 		}
 
 		userSettingList, err := s.Store.FindUserSettingList(ctx, &api.UserSettingFind{
-			UserID: userID,
+			UserID: &userID,
 		})
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find userSettingList").SetInternal(err)

store/user_setting.go

@@ -124,7 +124,9 @@ func findUserSettingList(ctx context.Context, tx *sql.Tx, find *api.UserSettingF
 		where, args = append(where, "key = ?"), append(args, v)
 	}
 
-	where, args = append(where, "user_id = ?"), append(args, find.UserID)
+	if v := find.UserID; v != nil {
+		where, args = append(where, "user_id = ?"), append(args, *find.UserID)
+	}
 
 	query := `
 		SELECT