Skip to content

armgit / memos

Public Imported from GitHub
0

Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.

3.6 KB
Raw Blame
package api

import (
	"context"
	"maps"
	"slices"

	"github.com/pkg/errors"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	"github.com/usememos/memos/core/instancesetting"
	apipb "github.com/usememos/memos/proto/gen/api"
	storepb "github.com/usememos/memos/proto/gen/store"
	"github.com/usememos/memos/store"
)

// convertInstanceSettingResponse converts a stored setting for the API. Usage
// limits name users, so they need the store to turn IDs into user names.
func (s *APIService) convertInstanceSettingResponse(ctx context.Context, setting *storepb.InstanceSetting) (*apipb.InstanceSetting, error) {
	result := convertInstanceSettingFromStore(setting)
	if setting.Key == storepb.InstanceSettingKey_USAGE_LIMITS {
		usageLimits, err := s.convertUsageLimitsSettingFromStore(ctx, setting.GetUsageLimitsSetting())
		if err != nil {
			return nil, status.Errorf(codes.Internal, "failed to convert usage limits: %v", err)
		}
		result.Value = &apipb.InstanceSetting_UsageLimitsSetting_{UsageLimitsSetting: usageLimits}
	}
	return result, nil
}

// convertUsageLimitsSettingFromStore converts the stored usage limits for the
// API, naming users by username. Users that no longer exist are left out,
// because an entry naming only missing users never matches anyone.
func (s *APIService) convertUsageLimitsSettingFromStore(ctx context.Context, setting *storepb.InstanceUsageLimitsSetting) (*apipb.InstanceSetting_UsageLimitsSetting, error) {
	userIDs := []int32{}
	for _, limit := range setting.GetLimits() {
		userIDs = append(userIDs, limit.GetUserIds()...)
	}
	usernames, err := s.listUsernamesByID(ctx, userIDs)
	if err != nil {
		return nil, errors.Wrap(err, "failed to list users")
	}
	userNames := make(map[int32]string, len(usernames))
	for userID, username := range usernames {
		userNames[userID] = BuildUserName(username)
	}
	return instancesetting.UsageLimitsFromStore(setting, userNames), nil
}

// convertUsageLimitsSettingToStore converts usage limits from the API for the
// store, resolving usernames to IDs. It returns an InvalidArgument status for
// a malformed user name and a NotFound status for a user that does not exist.
// The store validates the list when it is written.
func (s *APIService) convertUsageLimitsSettingToStore(ctx context.Context, setting *apipb.InstanceSetting_UsageLimitsSetting) (*storepb.InstanceUsageLimitsSetting, error) {
	if setting == nil {
		return nil, status.Errorf(codes.InvalidArgument, "usage limits setting is required")
	}
	// Request user name to username, parsed once.
	usernameOf := map[string]string{}
	for _, limit := range setting.GetLimits() {
		for _, name := range limit.GetUsers() {
			username, err := parseUsernameFromName(name)
			if err != nil {
				return nil, status.Errorf(codes.InvalidArgument, "invalid user name %q: %v", name, err)
			}
			usernameOf[name] = username
		}
	}
	userIDs := map[string]int32{}
	if len(usernameOf) > 0 {
		users, err := s.Store.ListUsers(ctx, &store.FindUser{UsernameList: slices.Collect(maps.Values(usernameOf))})
		if err != nil {
			return nil, status.Errorf(codes.Internal, "failed to list users: %v", err)
		}
		for _, user := range users {
			userIDs[user.Username] = user.ID
		}
	}
	userIDOf := make(map[string]int32, len(usernameOf))
	for _, limit := range setting.GetLimits() {
		for _, name := range limit.GetUsers() {
			userID, ok := userIDs[usernameOf[name]]
			if !ok {
				return nil, status.Errorf(codes.NotFound, "user %q not found", name)
			}
			userIDOf[name] = userID
		}
	}
	result, err := instancesetting.UsageLimitsToStore(setting, userIDOf)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	return result, nil
}