website/pkg/controller/photo/upload.go
2024-08-10 11:54:37 -07:00

251 lines
7.8 KiB
Go

package photo
import (
"bytes"
"fmt"
"io"
"net/http"
"os"
"path/filepath"
"strings"
"code.nonshy.com/nonshy/website/pkg/config"
"code.nonshy.com/nonshy/website/pkg/log"
"code.nonshy.com/nonshy/website/pkg/models"
"code.nonshy.com/nonshy/website/pkg/photo"
"code.nonshy.com/nonshy/website/pkg/session"
"code.nonshy.com/nonshy/website/pkg/templates"
)
// Upload photos controller.
func Upload() http.HandlerFunc {
tmpl := templates.Must("photo/upload.html")
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var vars = map[string]interface{}{
"Intent": r.FormValue("intent"),
"NeedsCrop": false,
}
// Query string parameters: what is the intent of this photo upload?
// - If profile picture, the user will crop their image before posting it.
// - If regular photo, user simply picks a picture and doesn't need to crop it.
if vars["Intent"] == "profile_pic" {
vars["NeedsCrop"] = true
}
user, err := session.CurrentUser(r)
if err != nil {
session.FlashError(w, r, "Unexpected error: couldn't get CurrentUser")
}
// Get the current user's quota.
var photoCount, photoQuota = photo.QuotaForUser(user)
vars["PhotoCount"] = photoCount
vars["PhotoQuota"] = photoQuota
// Is the user throttled from sharing a Site Gallery photo too frequently?
vars["SiteGalleryThrottled"] = models.IsSiteGalleryThrottled(user, nil)
vars["SiteGalleryThrottleLimit"] = config.SiteGalleryRateLimitMax
// If they do not have a profile picture currently set (and are not uploading one now),
// the front-end should point this out to them.
if (user.ProfilePhotoID == nil || *user.ProfilePhotoID == 0) && vars["Intent"] != "profile_pic" {
// If they have no photo at all, make the default intent to upload one.
if photoCount == 0 {
templates.Redirect(w, r.URL.Path+"?intent=profile_pic")
return
}
vars["NoProfilePicture"] = true
}
// Are they POSTing?
if r.Method == http.MethodPost {
var (
caption = strings.TrimSpace(r.PostFormValue("caption"))
altText = strings.TrimSpace(r.PostFormValue("alt_text"))
isExplicit = r.PostFormValue("explicit") == "true"
visibility = r.PostFormValue("visibility")
isGallery = r.PostFormValue("gallery") == "true"
isPinned = r.PostFormValue("pinned") == "true"
cropCoords = r.PostFormValue("crop")
confirm1 = r.PostFormValue("confirm1") == "true"
confirm2 = r.PostFormValue("confirm2") == "true"
)
// Enforce that they can not override the Site Gallery throttle.
if vars["SiteGalleryThrottled"].(bool) && isGallery {
isGallery = false
}
if len(altText) > config.AltTextMaxLength {
altText = altText[:config.AltTextMaxLength]
}
// Are they at quota already?
if photoCount >= photoQuota {
session.FlashError(w, r, "You have too many photos to upload a new one. Please delete a photo to make room for a new one.")
templates.Redirect(w, "/u/"+user.Username+"/photos")
return
}
// They checked both boxes. The browser shouldn't allow them to
// post but validate it here anyway...
if !confirm1 || !confirm2 {
session.FlashError(w, r, "You must agree to the terms to upload this picture.")
templates.Redirect(w, r.URL.Path)
return
}
// Parse and validate crop coordinates.
var crop []int
if vars["NeedsCrop"] == true {
crop = photo.ParseCropCoords(cropCoords)
}
log.Error("parsed crop coords: %+v", crop)
// Get their file upload.
file, header, err := r.FormFile("file")
if err != nil {
session.FlashError(w, r, "Error receiving your file: %s", err)
templates.Redirect(w, r.URL.Path)
return
}
// GIF can not be uploaded for a profile picture.
if filepath.Ext(header.Filename) == ".gif" && vars["Intent"] == "profile_pic" {
session.FlashError(w, r, "GIF images are not acceptable for your profile picture.")
templates.Redirect(w, r.URL.Path)
return
}
// Read the file contents.
log.Debug("Receiving uploaded file (%d bytes): %s", header.Size, header.Filename)
var buf bytes.Buffer
io.Copy(&buf, file)
filename, cropFilename, err := photo.UploadPhoto(photo.UploadConfig{
User: user,
Extension: filepath.Ext(header.Filename),
Data: buf.Bytes(),
Crop: crop,
})
if err != nil {
session.FlashError(w, r, "Error in UploadPhoto: %s", err)
templates.Redirect(w, r.URL.Path)
return
}
// Configuration for the DB entry.
ptmpl := models.Photo{
UserID: user.ID,
Filename: filename,
CroppedFilename: cropFilename,
Caption: caption,
AltText: altText,
Visibility: models.PhotoVisibility(visibility),
Gallery: isGallery,
Pinned: isPinned,
Explicit: isExplicit,
}
// Get the filesize.
if stat, err := os.Stat(photo.DiskPath(filename)); err == nil {
ptmpl.Filesize = stat.Size()
}
// Create it in DB!
p, err := models.CreatePhoto(ptmpl)
if err != nil {
session.FlashError(w, r, "Couldn't create Photo in DB: %s", err)
} else {
log.Info("New photo! %+v", p)
}
// Are we uploading a profile pic? If so, set the user's pic now.
if vars["Intent"] == "profile_pic" && cropFilename != "" {
log.Info("User %s is setting their profile picture", user.Username)
user.ProfilePhoto = *p
user.Save()
}
// ChangeLog entry.
models.LogCreated(user, "photos", p.ID, fmt.Sprintf(
"Uploaded a new photo.\n\n"+
"* Caption: %s\n"+
"* Visibility: %s\n"+
"* Gallery: %v\n"+
"* Explicit: %v",
p.Caption,
p.Visibility,
p.Gallery,
p.Explicit,
))
// Notify all of our friends that we posted a new picture.
go notifyFriendsNewPhoto(p, user)
session.Flash(w, r, "Your photo has been uploaded successfully.")
templates.Redirect(w, "/u/"+user.Username+"/photos")
return
}
if err := tmpl.Execute(w, r, vars); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
})
}
// Create a notification for all our Friends about a new photo.
// Run in a background goroutine in case it takes a while.
func notifyFriendsNewPhoto(photo *models.Photo, currentUser *models.User) {
var (
friendIDs []uint64
notifyUserIDs []uint64
)
// Get the user's literal list of friends (with explicit opt-ins).
if photo.Explicit {
friendIDs = models.FriendIDsAreExplicit(currentUser.ID)
} else {
friendIDs = models.FriendIDs(currentUser.ID)
}
// Who to notify about this upload?
if photo.Visibility == models.PhotoPrivate {
// Private grantees
if photo.Explicit {
notifyUserIDs = models.PrivateGranteeAreExplicitUserIDs(currentUser.ID)
log.Info("Notify %d EXPLICIT private grantees about the new photo by %s", len(notifyUserIDs), currentUser.Username)
} else {
notifyUserIDs = models.PrivateGranteeUserIDs(currentUser.ID)
log.Info("Notify %d private grantees about the new photo by %s", len(notifyUserIDs), currentUser.Username)
}
} else {
// Friends only: we will notify exactly the friends we selected above.
notifyUserIDs = friendIDs
}
// Filter down the notifyUserIDs to only include the user's friends.
// Example: someone unlocked private photos for you, but you are not their friend.
// You should not get notified about their new private photos.
notifyUserIDs = models.FilterFriendIDs(notifyUserIDs, friendIDs)
// Filter down the notifyUserIDs further to respect their notification opt-out preferences.
notifyUserIDs = models.FilterPhotoUploadNotificationUserIDs(photo, notifyUserIDs)
for _, fid := range notifyUserIDs {
notif := &models.Notification{
UserID: fid,
AboutUser: *currentUser,
Type: models.NotificationNewPhoto,
TableName: "photos",
TableID: photo.ID,
}
if err := models.CreateNotification(notif); err != nil {
log.Error("Couldn't notify user %d about %s's new photo: %s", fid, currentUser.Username, err)
}
}
}