Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

7.5 KB
Raw Blame
package api

import (
	"fmt"
	"net/http"
	"strconv"

	fileData "github.com/ente/museum/ente/filedata"
	"github.com/ente/museum/pkg/controller/collections"
	"github.com/ente/museum/pkg/controller/filedata"
	"github.com/ente/museum/pkg/controller/public"

	"github.com/ente/museum/pkg/controller/storagebonus"

	"github.com/ente/museum/ente"
	"github.com/ente/museum/pkg/controller"
	"github.com/ente/museum/pkg/utils/auth"
	"github.com/ente/museum/pkg/utils/handler"
	"github.com/ente/museum/pkg/utils/network"
	"github.com/ente/stacktrace"
	"github.com/gin-gonic/gin"
)

type PublicCollectionHandler struct {
	Controller             *public.CollectionLinkController
	FileCtrl               *controller.FileController
	CollectionCtrl         *collections.CollectionController
	FileDataCtrl           *filedata.Controller
	StorageBonusController *storagebonus.Controller
}

func (h *PublicCollectionHandler) GetThumbnail(c *gin.Context) {
	h.getFileForType(c, ente.THUMBNAIL)
}

func (h *PublicCollectionHandler) GetFile(c *gin.Context) {
	h.getFileForType(c, ente.FILE)
}

func (h *PublicCollectionHandler) GetThumbnailURLV3(c *gin.Context) {
	url, err := h.getFileURL(c, ente.THUMBNAIL)
	writeFileURLV3(c, url, err)
}

func (h *PublicCollectionHandler) GetFileURLV3(c *gin.Context) {
	url, err := h.getFileURL(c, ente.FILE)
	writeFileURLV3(c, url, err)
}

func (h *PublicCollectionHandler) GetPreviewURL(c *gin.Context) {
	var req fileData.GetPreviewURLRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		handler.Error(c, stacktrace.Propagate(ente.ErrBadRequest, "Request binding failed %s", err))
		return
	}
	collectionOwner, err := h.getCollectionOwnerAndVerifyAccess(c, req.FileID)
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	url, err := h.FileDataCtrl.GetPreviewUrl(c, *collectionOwner, req)
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"url": url,
	})
}

func (h *PublicCollectionHandler) GetFileData(c *gin.Context) {
	var req fileData.GetFileData
	if err := c.ShouldBindQuery(&req); err != nil {
		c.JSON(http.StatusBadRequest, ente.NewBadRequestWithMessage(err.Error()))
		return
	}
	if req.Type != ente.PreviewVideo {
		errorMessage := fmt.Sprintf("unsupported object type %s", req.Type)
		handler.Error(c, stacktrace.Propagate(ente.NewBadRequestWithMessage(errorMessage), ""))
		return
	}
	collectionOwner, err := h.getCollectionOwnerAndVerifyAccess(c, req.FileID)
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	resp, err := h.FileDataCtrl.GetFileData(c, *collectionOwner, req)
	if err != nil {
		handler.Error(c, err)
		return
	}
	if resp == nil {
		c.Status(http.StatusNoContent)
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"data": resp,
	})
}

func (h *PublicCollectionHandler) getCollectionOwnerAndVerifyAccess(c *gin.Context, fileID int64) (*int64, error) {
	accessContext := auth.MustGetPublicAccessContext(c)
	if accessErr := h.FileCtrl.DoesFileExistInCollection(c, fileID, accessContext.CollectionID); accessErr != nil {
		return nil, stacktrace.Propagate(accessErr, "")
	}
	collection, err := h.Controller.GetPublicCollection(c, false)
	if err != nil {
		return nil, stacktrace.Propagate(err, "")
	}
	return &collection.Owner.ID, nil
}

func (h *PublicCollectionHandler) GetCollection(c *gin.Context) {
	collection, err := h.Controller.GetPublicCollection(c, false)
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	referralCode, _ := h.StorageBonusController.GetOrCreateReferralCode(c, collection.Owner.ID)
	response := gin.H{
		"collection":   collection,
		"referralCode": referralCode,
	}
	if linkDeviceToken, ok := c.Get(auth.LinkDeviceTokenResponseKey); ok {
		if token, ok := linkDeviceToken.(string); ok && token != "" {
			c.Header(auth.LinkDeviceTokenResponseHeader, token)
		}
	}
	c.JSON(http.StatusOK, response)
}

func (h *PublicCollectionHandler) GetUploadURLV2(c *gin.Context) {
	enteApp := auth.GetApp(c)
	var req ente.UploadURLRequest
	if err := handler.BindJSON(c, &req); err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	collection, err := h.Controller.GetPublicCollection(c, true)
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	url, err := h.FileCtrl.GetUploadURLWithMetadata(c, collection.Owner.ID, req, enteApp, network.GetClientInfo(c))
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	c.JSON(http.StatusOK, url)
}

func (h *PublicCollectionHandler) GetMultipartUploadURLV2(c *gin.Context) {
	enteApp := auth.GetApp(c)
	var req ente.MultipartUploadURLRequest
	if err := handler.BindJSON(c, &req); err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	// TODO: Remove once deferred multipart checksums are enabled for public uploads.
	if len(req.PartMD5s) == 0 {
		handler.Error(c, ente.ErrBadRequest)
		return
	}
	collection, err := h.Controller.GetPublicCollection(c, true)
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	upload, err := h.FileCtrl.GetMultipartUploadURLWithMetadata(c, collection.Owner.ID, req, enteApp, network.GetClientInfo(c))
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	c.JSON(http.StatusOK, upload)
}

func (h *PublicCollectionHandler) CreateFile(c *gin.Context) {
	var file ente.File
	if err := handler.BindJSON(c, &file); err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}

	enteApp := auth.GetApp(c)
	accessContext := auth.MustGetPublicAccessContext(c)
	if file.CollectionID != accessContext.CollectionID {
		handler.Error(c, stacktrace.Propagate(ente.NewBadRequestWithMessage("can only update to associated collection"), ""))
		return
	}

	fileRes, err := h.Controller.CreateFile(c, file, enteApp)
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	c.JSON(http.StatusOK, fileRes)
}

func (h *PublicCollectionHandler) VerifyPassword(c *gin.Context) {
	var req ente.VerifyPasswordRequest
	if err := handler.BindJSON(c, &req); err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	resp, err := h.Controller.VerifyPassword(c, req)
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	c.JSON(http.StatusOK, resp)
}

func (h *PublicCollectionHandler) GetDiff(c *gin.Context) {
	sinceTime, err := strconv.ParseInt(c.Query("sinceTime"), 10, 64)
	if err != nil {
		errorMessage := fmt.Sprintf("invalid sinceTime val: %s", c.Query("sinceTime"))
		handler.Error(c, stacktrace.Propagate(ente.NewBadRequestWithMessage(errorMessage), "%v", err))
		return
	}
	files, hasMore, err := h.CollectionCtrl.GetPublicDiff(c, sinceTime)
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"diff":    files,
		"hasMore": hasMore,
	})
}

func (h *PublicCollectionHandler) getFileForType(c *gin.Context, objectType ente.ObjectType) {
	url, err := h.getFileURL(c, objectType)
	if err != nil {
		handler.Error(c, stacktrace.Propagate(err, ""))
		return
	}
	c.Redirect(http.StatusTemporaryRedirect, url)
}

func (h *PublicCollectionHandler) getFileURL(c *gin.Context, objectType ente.ObjectType) (string, error) {
	fileID, err := strconv.ParseInt(c.Param("fileID"), 10, 64)
	if err != nil {
		return "", stacktrace.Propagate(ente.ErrBadRequest, "")
	}
	accessContext := auth.MustGetPublicAccessContext(c)
	url, err := h.FileCtrl.GetPublicOrCastFileURL(c, fileID, objectType, accessContext.CollectionID)
	if err != nil {
		return "", stacktrace.Propagate(err, "")
	}
	return url, nil
}