Warp/server/internal/clientapi/profile.go

package clientapi

import (
	"errors"
	"net/http"

	"github.com/dariuszjaniak/warp/server/internal/federation"
	"github.com/dariuszjaniak/warp/server/internal/httputil"
	"github.com/dariuszjaniak/warp/server/internal/storage"
	"github.com/dariuszjaniak/warp/server/internal/userapi"
)

// profileResponse is the body of GET /profile/{userId}. Both fields are
// omitted when unset: the spec distinguishes "no display name" from an empty
// one, and clients fall back to the localpart for the former.
type profileResponse struct {
	DisplayName string `json:"displayname,omitempty"`
	AvatarURL   string `json:"avatar_url,omitempty"`
}

// MaxDisplayNameLength and MaxAvatarURLLength bound the profile fields.
// The spec sets no limit; these are what keeps a member list from carrying a
// megabyte of display name per user once rooms exist.
const (
	MaxDisplayNameLength = 256
	MaxAvatarURLLength   = 1024
)

// handleGetProfile implements GET /_matrix/client/v3/profile/{userId}.
func (c *ClientAPI) handleGetProfile(w http.ResponseWriter, r *http.Request) error {
	account, err := c.lookupProfile(r)
	if err != nil {
		return err
	}
	httputil.WriteJSON(w, http.StatusOK, profileResponse{
		DisplayName: account.DisplayName,
		AvatarURL:   account.AvatarURL,
	})
	return nil
}

// handleGetDisplayName implements GET /profile/{userId}/displayname.
func (c *ClientAPI) handleGetDisplayName(w http.ResponseWriter, r *http.Request) error {
	account, err := c.lookupProfile(r)
	if err != nil {
		return err
	}
	httputil.WriteJSON(w, http.StatusOK, profileResponse{DisplayName: account.DisplayName})
	return nil
}

// handleGetAvatarURL implements GET /profile/{userId}/avatar_url.
func (c *ClientAPI) handleGetAvatarURL(w http.ResponseWriter, r *http.Request) error {
	account, err := c.lookupProfile(r)
	if err != nil {
		return err
	}
	httputil.WriteJSON(w, http.StatusOK, profileResponse{AvatarURL: account.AvatarURL})
	return nil
}

// lookupProfile resolves the user ID in the path to a local account.
//
// A user ID on another server is where the federation switch shows up in the
// Client-Server API: with federation off there is no way to answer and the
// spec's M_FORBIDDEN is the honest reply, as PLAN.md section 3 requires.
// With federation on, the lookup itself is Phase 5 work.
func (c *ClientAPI) lookupProfile(r *http.Request) (storage.Account, error) {
	userID := r.PathValue("userID")

	localpart, err := c.users.ParseLocalUserID(userID)
	switch {
	case errors.Is(err, userapi.ErrForeignServer):
		if !c.federation.Enabled() {
			return storage.Account{}, federation.RejectClientRequest(
				"looking up the profile of a user on another server")
		}
		return storage.Account{}, httputil.NotFound(
			"Profiles of users on other servers cannot be fetched yet")
	case err != nil:
		return storage.Account{}, httputil.InvalidParam("%s is not a valid user ID", userID)
	}

	account, err := c.users.Account(r.Context(), localpart)
	switch {
	case errors.Is(err, userapi.ErrNoSuchUser):
		return storage.Account{}, httputil.NotFound("Profile not found")
	case err != nil:
		return storage.Account{}, err
	}
	return account, nil
}

// putDisplayNameRequest is the body of PUT /profile/{userId}/displayname.
type putDisplayNameRequest struct {
	DisplayName string `json:"displayname"`
}

// putAvatarURLRequest is the body of PUT /profile/{userId}/avatar_url.
type putAvatarURLRequest struct {
	AvatarURL string `json:"avatar_url"`
}

// handlePutDisplayName implements PUT /profile/{userId}/displayname.
func (c *ClientAPI) handlePutDisplayName(w http.ResponseWriter, r *http.Request, auth userapi.Authenticated) error {
	localpart, err := c.requireSelf(auth, r.PathValue("userID"))
	if err != nil {
		return err
	}
	var req putDisplayNameRequest
	if err := httputil.DecodeJSON(w, r, &req); err != nil {
		return err
	}
	if len(req.DisplayName) > MaxDisplayNameLength {
		return httputil.NewError(http.StatusBadRequest, httputil.ErrCodeTooLarge,
			"Display names must be at most %d bytes", MaxDisplayNameLength)
	}

	if err := c.users.SetDisplayName(r.Context(), localpart, req.DisplayName); err != nil {
		return profileWriteError(err)
	}
	// Once rooms exist this also has to rewrite the m.room.member event in
	// every room the user is in; that belongs to the roomserver in Phase 3.
	httputil.WriteJSON(w, http.StatusOK, struct{}{})
	return nil
}

// handlePutAvatarURL implements PUT /profile/{userId}/avatar_url.
func (c *ClientAPI) handlePutAvatarURL(w http.ResponseWriter, r *http.Request, auth userapi.Authenticated) error {
	localpart, err := c.requireSelf(auth, r.PathValue("userID"))
	if err != nil {
		return err
	}
	var req putAvatarURLRequest
	if err := httputil.DecodeJSON(w, r, &req); err != nil {
		return err
	}
	if len(req.AvatarURL) > MaxAvatarURLLength {
		return httputil.NewError(http.StatusBadRequest, httputil.ErrCodeTooLarge,
			"Avatar URLs must be at most %d bytes", MaxAvatarURLLength)
	}

	if err := c.users.SetAvatarURL(r.Context(), localpart, req.AvatarURL); err != nil {
		return profileWriteError(err)
	}
	httputil.WriteJSON(w, http.StatusOK, struct{}{})
	return nil
}

// profileWriteError maps a failed profile update. An admin may write to
// another user's profile, so "no such user" is reachable here.
func profileWriteError(err error) error {
	if errors.Is(err, userapi.ErrNoSuchUser) {
		return httputil.NotFound("Profile not found")
	}
	return err
}