π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
package controller
import (
"context"
"database/sql"
"errors"
"net/http"
"strings"
"github.com/ente/museum/ente"
"github.com/ente/museum/space/models"
"github.com/ente/museum/space/repo"
"github.com/ente/stacktrace"
)
type FriendsController struct {
FriendsRepo *repo.FriendsRepository
SpacesRepo *repo.SpacesRepository
ActivityNotifier SpaceActivityNotifier
}
func newSpaceFriendRequestUnavailableError(status int) *ente.ApiError {
return &ente.ApiError{
Code: ente.ErrorCode("SPACE_FRIEND_REQUEST_UNAVAILABLE"),
Message: "friend request is no longer available",
HttpStatusCode: status,
}
}
func (c *FriendsController) Add(ctx context.Context, requesterSpace *repo.SpaceRecord, req models.AddFriendPayload) (*models.FriendStatusResponse, error) {
if (strings.TrimSpace(req.TargetSpaceID) == "" && strings.TrimSpace(req.TargetUsername) == "") ||
strings.TrimSpace(req.RequesterFriendSealedSpaceKey) == "" ||
req.RequesterKeyVersion <= 0 {
return nil, ente.NewBadRequestWithMessage("targetSpaceId or targetUsername, requesterFriendSealedSpaceKey and requesterKeyVersion are required")
}
requesterFriendSealedSpaceKey, err := decodeEncodedSpaceField("requesterFriendSealedSpaceKey", req.RequesterFriendSealedSpaceKey, maxSpaceEncryptedKeyEncodedBytes, maxSpaceEncryptedKeyDecodedBytes)
if err != nil {
return nil, err
}
var targetSpace *repo.SpaceRecord
switch {
case strings.TrimSpace(req.TargetSpaceID) != "":
targetSpace, err = c.SpacesRepo.GetSpaceByID(ctx, strings.TrimSpace(req.TargetSpaceID))
case strings.TrimSpace(req.TargetUsername) != "":
targetSpace, err = c.SpacesRepo.GetSpaceBySlug(ctx, strings.TrimSpace(req.TargetUsername))
}
if err != nil {
return nil, err
}
request, created, becameFriends, err := c.FriendsRepo.CreateFriendRequest(
ctx,
requesterSpace.OwnerID,
requesterSpace.SpaceID,
targetSpace.SpaceID,
requesterFriendSealedSpaceKey,
req.RequesterKeyVersion,
)
if err != nil {
if errors.Is(stacktrace.RootCause(err), repo.ErrSelfFriendship) {
return nil, &ente.ApiError{
Code: ente.ErrorCode("SPACE_SELF_FRIENDSHIP"),
Message: "cannot add yourself as a friend",
HttpStatusCode: http.StatusBadRequest,
}
}
if errors.Is(stacktrace.RootCause(err), repo.ErrAlreadyFriends) {
return &models.FriendStatusResponse{Status: "friend"}, nil
}
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
return nil, ente.NewBadRequestWithMessage("space key version is stale")
}
if errors.Is(stacktrace.RootCause(err), repo.ErrSpaceSentFriendRequestLimitReached) {
return nil, &ente.ApiError{
Code: ente.ErrorCode("SPACE_SENT_FRIEND_REQUEST_LIMIT_REACHED"),
Message: "space sent friend request limit reached",
HttpStatusCode: http.StatusConflict,
}
}
if errors.Is(stacktrace.RootCause(err), repo.ErrSpaceFriendRequestLimitReached) {
return nil, &ente.ApiError{
Code: ente.ErrorCode("SPACE_FRIEND_REQUEST_LIMIT_REACHED"),
Message: "space friend request limit reached",
HttpStatusCode: http.StatusConflict,
}
}
return nil, err
}
if becameFriends {
go c.ActivityNotifier.OnSpaceFriendAdded(spaceActivityActor(requesterSpace), request.RequesterID)
return &models.FriendStatusResponse{Status: "friend"}, nil
}
if created {
go c.ActivityNotifier.OnSpaceFriendRequested(spaceActivityActor(requesterSpace), request.TargetID)
}
return &models.FriendStatusResponse{Status: "requested"}, nil
}
func (c *FriendsController) ListRequests(ctx context.Context, space *repo.SpaceRecord) ([]models.SpaceFriendRequestResponse, error) {
requests, err := c.FriendsRepo.ListFriendRequestsForSpace(ctx, space.SpaceID)
if err != nil {
return nil, err
}
resp := make([]models.SpaceFriendRequestResponse, 0, len(requests))
for _, request := range requests {
resp = append(resp, models.SpaceFriendRequestResponse{
RequestID: request.RequestID,
Requester: toActorResponse(request.Requester, true),
CreatedAt: formatMicros(request.CreatedAt),
})
}
return resp, nil
}
func (c *FriendsController) ListSentRequests(ctx context.Context, space *repo.SpaceRecord) ([]models.SpaceSentFriendRequestResponse, error) {
requests, err := c.FriendsRepo.ListSentFriendRequestsForSpace(ctx, space.SpaceID)
if err != nil {
return nil, err
}
resp := make([]models.SpaceSentFriendRequestResponse, 0, len(requests))
for _, request := range requests {
resp = append(resp, models.SpaceSentFriendRequestResponse{
RequestID: request.RequestID,
Target: toActorResponse(request.Target, true),
CreatedAt: formatMicros(request.CreatedAt),
})
}
return resp, nil
}
func (c *FriendsController) ConfirmRequest(ctx context.Context, targetSpace *repo.SpaceRecord, requestID int64, req models.ConfirmFriendRequestPayload) (*models.FriendStatusResponse, error) {
if strings.TrimSpace(req.TargetFriendSealedSpaceKey) == "" || req.TargetKeyVersion <= 0 {
return nil, ente.NewBadRequestWithMessage("targetFriendSealedSpaceKey and targetKeyVersion are required")
}
targetFriendSealedSpaceKey, err := decodeEncodedSpaceField("targetFriendSealedSpaceKey", req.TargetFriendSealedSpaceKey, maxSpaceEncryptedKeyEncodedBytes, maxSpaceEncryptedKeyDecodedBytes)
if err != nil {
return nil, err
}
requesterID, created, err := c.FriendsRepo.ConfirmFriendRequest(
ctx,
targetSpace.SpaceID,
requestID,
targetFriendSealedSpaceKey,
req.TargetKeyVersion,
)
if err != nil {
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
return nil, newSpaceFriendRequestUnavailableError(http.StatusBadRequest)
}
if errors.Is(stacktrace.RootCause(err), repo.ErrSpaceFriendRequestStale) {
return nil, ente.NewBadRequestWithMessage("space key version is stale")
}
return nil, err
}
if created {
go c.ActivityNotifier.OnSpaceFriendAdded(spaceActivityActor(targetSpace), requesterID)
}
return &models.FriendStatusResponse{Status: "friend"}, nil
}
func (c *FriendsController) DeleteRequest(ctx context.Context, space *repo.SpaceRecord, requestID int64) error {
if err := c.FriendsRepo.DeleteFriendRequest(ctx, space.SpaceID, requestID); err != nil {
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
return newSpaceFriendRequestUnavailableError(http.StatusNotFound)
}
return err
}
return nil
}
func (c *FriendsController) Unfriend(ctx context.Context, actorSpace *repo.SpaceRecord, req models.FriendTargetPayload) error {
var space *repo.SpaceRecord
var err error
switch {
case req.TargetSpaceID != nil && strings.TrimSpace(*req.TargetSpaceID) != "":
space, err = c.SpacesRepo.GetSpaceByID(ctx, strings.TrimSpace(*req.TargetSpaceID))
case req.TargetUsername != nil && strings.TrimSpace(*req.TargetUsername) != "":
space, err = c.SpacesRepo.GetSpaceBySlug(ctx, strings.TrimSpace(*req.TargetUsername))
default:
return ente.NewBadRequestWithMessage("targetUsername or targetSpaceId is required")
}
if err != nil {
return err
}
return c.FriendsRepo.DeleteFriendship(ctx, actorSpace.SpaceID, space.SpaceID)
}
func (c *FriendsController) ListFriends(ctx context.Context, space *repo.SpaceRecord) ([]models.SpaceFriendResponse, error) {
friends, err := c.FriendsRepo.ListFriendsForSpace(ctx, space.SpaceID)
if err != nil {
return nil, err
}
resp := make([]models.SpaceFriendResponse, 0, len(friends))
for _, friend := range friends {
resp = append(resp, models.SpaceFriendResponse{
Friend: toActorResponse(friend.Friend, true),
ShareKeyVersion: friend.ShareKeyVersion,
CreatedAt: formatMicros(friend.CreatedAt),
})
}
return resp, nil
}
func (c *FriendsController) Relationship(ctx context.Context, viewerSpace *repo.SpaceRecord, req models.FriendRelationshipRequest) (*models.FriendRelationshipResponse, error) {
targetSpaceID := strings.TrimSpace(req.TargetSpaceID)
if targetSpaceID == "" {
return nil, ente.NewBadRequestWithMessage("targetSpaceId is required")
}
targetSpace, err := c.SpacesRepo.GetSpaceByID(ctx, targetSpaceID)
if err != nil {
return nil, err
}
if viewerSpace.OwnerID == targetSpace.OwnerID {
return &models.FriendRelationshipResponse{Relationship: "self"}, nil
}
relationship, err := c.FriendsRepo.GetRelationship(ctx, viewerSpace.SpaceID, targetSpace.SpaceID)
if err != nil {
return nil, err
}
return &models.FriendRelationshipResponse{Relationship: relationship}, nil
}
func (c *FriendsController) RefreshShares(ctx context.Context, space *repo.SpaceRecord, req models.RefreshFriendSharesRequest) error {
if req.KeyVersion <= 0 {
return ente.NewBadRequestWithMessage("keyVersion is required")
}
if len(req.Shares) > maxSpaceFriendSharesPerRefresh {
return ente.NewBadRequestWithMessage("too many friend shares")
}
updates := make([]repo.SpaceShareUpdateRecord, 0, len(req.Shares))
for _, share := range req.Shares {
if strings.TrimSpace(share.FriendSpaceID) == "" || strings.TrimSpace(share.FriendSealedSpaceKey) == "" {
return ente.NewBadRequestWithMessage("friendSpaceId and friendSealedSpaceKey are required for each share")
}
friendSealedSpaceKey, err := decodeEncodedSpaceField("friendSealedSpaceKey", share.FriendSealedSpaceKey, maxSpaceEncryptedKeyEncodedBytes, maxSpaceEncryptedKeyDecodedBytes)
if err != nil {
return err
}
updates = append(updates, repo.SpaceShareUpdateRecord{
FriendSpaceID: strings.TrimSpace(share.FriendSpaceID),
FriendSealedSpaceKey: friendSealedSpaceKey,
})
}
if err := c.FriendsRepo.UpdateShares(ctx, space.SpaceID, updates, req.KeyVersion); err != nil {
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
return ente.NewBadRequestWithMessage("keyVersion does not match current space version or friend share does not exist")
}
return err
}
return nil
}
func (c *FriendsController) ListShares(ctx context.Context, space *repo.SpaceRecord) ([]models.FriendShareResponse, error) {
shares, err := c.FriendsRepo.ListSharesForFriendAndSpace(ctx, space.SpaceID)
if err != nil {
return nil, err
}
resp := make([]models.FriendShareResponse, 0, len(shares))
for _, share := range shares {
resp = append(resp, models.FriendShareResponse{
Friend: share.SpaceSlug,
SpaceID: share.SpaceID,
SpaceSlug: share.SpaceSlug,
FriendSealedSpaceKey: encodeSpaceField(share.FriendSealedSpaceKey),
KeyVersion: share.KeyVersion,
})
}
return resp, nil
}