website/pkg/models/photo.go

package models

import (
	"errors"
	"strings"
	"time"

	"code.nonshy.com/nonshy/website/pkg/log"
	"gorm.io/gorm"
)

// Photo table.
type Photo struct {
	ID              uint64 `gorm:"primaryKey"`
	UserID          uint64 `gorm:"index"`
	Filename        string
	CroppedFilename string // if cropped, e.g. for profile photo
	Filesize        int64
	Caption         string
	Flagged         bool // photo has been reported by the community
	Visibility      PhotoVisibility
	Gallery         bool // photo appears in the public gallery (if public)
	Explicit        bool // is an explicit photo
	CreatedAt       time.Time
	UpdatedAt       time.Time
}

// PhotoVisibility settings.
type PhotoVisibility string

const (
	PhotoPublic      PhotoVisibility = "public"  // on profile page and/or public gallery
	PhotoFriends                     = "friends" // only friends can see it
	PhotoPrivate                     = "private" // private
	PhotoInnerCircle                 = "circle"  // inner circle
)

// PhotoVisibility preset settings.
var (
	PhotoVisibilityAll = []PhotoVisibility{
		PhotoPublic,
		PhotoFriends,
		PhotoPrivate,
	}

	// "All" but also for Inner Circle members.
	PhotoVisibilityCircle = []PhotoVisibility{
		PhotoPublic,
		PhotoFriends,
		PhotoPrivate,
		PhotoInnerCircle,
	}

	// Site Gallery visibility for when your friends show up in the gallery.
	// Or: "Friends + Gallery" photos can appear to your friends in the Site Gallery.
	PhotoVisibilityFriends = []string{
		string(PhotoPublic),
		string(PhotoFriends),
	}
)

// CreatePhoto with most of the settings you want (not ID or timestamps) in the database.
func CreatePhoto(tmpl Photo) (*Photo, error) {
	if tmpl.UserID == 0 {
		return nil, errors.New("UserID required")
	}

	p := &Photo{
		UserID:          tmpl.UserID,
		Filename:        tmpl.Filename,
		CroppedFilename: tmpl.CroppedFilename,
		Filesize:        tmpl.Filesize,
		Caption:         tmpl.Caption,
		Visibility:      tmpl.Visibility,
		Gallery:         tmpl.Gallery,
		Explicit:        tmpl.Explicit,
	}

	result := DB.Create(p)
	return p, result.Error
}

// GetPhoto by ID.
func GetPhoto(id uint64) (*Photo, error) {
	p := &Photo{}
	result := DB.First(&p, id)
	return p, result.Error
}

// GetPhotos by an array of IDs, mapped to their IDs.
func GetPhotos(IDs []uint64) (map[uint64]*Photo, error) {
	var (
		mp = map[uint64]*Photo{}
		ps = []*Photo{}
	)

	result := DB.Model(&Photo{}).Where("id IN ?", IDs).Find(&ps)
	for _, row := range ps {
		mp[row.ID] = row
	}

	return mp, result.Error
}

/*
PaginateUserPhotos gets a page of photos belonging to a user ID.
*/
func PaginateUserPhotos(userID uint64, visibility []PhotoVisibility, explicitOK bool, pager *Pagination) ([]*Photo, error) {
	var p = []*Photo{}

	var explicit = []bool{false}
	if explicitOK {
		explicit = []bool{true, false}
	}

	query := DB.Where(
		"user_id = ? AND visibility IN ? AND explicit IN ?",
		userID,
		visibility,
		explicit,
	).Order(
		pager.Sort,
	)

	// Get the total count.
	query.Model(&Photo{}).Count(&pager.Total)

	result := query.Offset(
		pager.GetOffset(),
	).Limit(pager.PerPage).Find(&p)

	return p, result.Error
}

// CountPhotos returns the total number of photos on a user's account.
func CountPhotos(userID uint64) int64 {
	var count int64
	result := DB.Where(
		"user_id = ?",
		userID,
	).Model(&Photo{}).Count(&count)
	if result.Error != nil {
		log.Error("CountPhotos(%d): %s", userID, result.Error)
	}
	return count
}

// CountExplicitPhotos returns the number of explicit photos a user has (so non-explicit viewers can see some do exist)
func CountExplicitPhotos(userID uint64, visibility []PhotoVisibility) (int64, error) {
	query := DB.Where(
		"user_id = ? AND visibility IN ? AND explicit = ?",
		userID,
		visibility,
		true,
	)

	var count int64
	result := query.Model(&Photo{}).Count(&count)
	return count, result.Error
}

// CountPublicPhotos returns the number of public photos on a user's page (to control whether the "invite to circle" prompt can appear).
func CountPublicPhotos(userID uint64) int64 {
	query := DB.Where(
		"user_id = ? AND visibility = ?",
		userID,
		PhotoPublic,
	)

	var count int64
	result := query.Model(&Photo{}).Count(&count)
	if result.Error != nil {
		log.Error("CountPublicPhotos(%d): %s", userID, result.Error)
	}
	return count
}

// DistinctPhotoTypes returns types of photos the user has: a set of public, friends, or private.
//
// The result is cached on the User the first time it's queried.
func (u *User) DistinctPhotoTypes() (result map[PhotoVisibility]struct{}) {
	if u.cachePhotoTypes != nil {
		return u.cachePhotoTypes
	}

	result = map[PhotoVisibility]struct{}{}

	var results = []*Photo{}
	query := DB.Model(&Photo{}).
		Select("DISTINCT photos.visibility").
		Where("user_id = ?", u.ID).
		Group("photos.visibility").
		Find(&results)
	if query.Error != nil {
		log.Error("User.DistinctPhotoTypes(%s): %s", u.Username, query.Error)
		return
	}

	for _, row := range results {
		log.Warn("DistinctPhotoTypes(%s): got %+v", u.Username, row)
		result[row.Visibility] = struct{}{}
	}

	u.cachePhotoTypes = result
	return
}

// Gallery config for the main Gallery paginator.
type Gallery struct {
	Explicit   string // Explicit filter
	Visibility string // Visibility filter
	AdminView  bool   // Show all images
	ShyView    bool   // Current user is shy (self/friends only)
}

/*
PaginateGalleryPhotos gets a page of all public user photos for the site gallery.

Admin view returns ALL photos regardless of Gallery status.
*/
func PaginateGalleryPhotos(user *User, conf Gallery, pager *Pagination) ([]*Photo, error) {
	var (
		filterExplicit   = conf.Explicit
		filterVisibility = conf.Visibility
		adminView        = conf.AdminView
		isShy            = conf.ShyView
		p                = []*Photo{}
		query            *gorm.DB

		// Get the user ID and their preferences.
		userID     = user.ID
		explicitOK = user.Explicit // User opted-in for explicit content

		blocklist      = BlockedUserIDs(userID)
		friendIDs      = FriendIDs(userID)
		privateUserIDs = PrivateGrantedUserIDs(userID)
		wheres         = []string{}
		placeholders   = []interface{}{}
	)

	// Define "all photos visibilities"
	var photosAll = PhotoVisibilityAll
	if user.IsInnerCircle() {
		photosAll = PhotoVisibilityCircle
	}

	// Admins see everything on the site (only an admin user can get an admin view).
	adminView = user.IsAdmin && adminView

	// Include ourself in our friend IDs.
	friendIDs = append(friendIDs, userID)

	// Whose photos can you see on the Site Gallery?
	if isShy {
		// Shy users can only see their Friends photos (public or friends visibility)
		// and any Private photos to whom they were granted access.
		wheres = append(wheres,
			"((user_id IN ? AND visibility IN ?) OR "+
				"(user_id IN ? AND visibility IN ?))",
		)
		placeholders = append(placeholders,
			friendIDs, PhotoVisibilityFriends,
			privateUserIDs, photosAll,
		)
	} else {
		// You can see friends' Friend photos but only public for non-friends.
		wheres = append(wheres,
			"((user_id IN ? AND visibility IN ?) OR "+
				"(user_id IN ? AND visibility IN ?) OR "+
				"(user_id NOT IN ? AND visibility = ?))",
		)
		placeholders = append(placeholders,
			friendIDs, PhotoVisibilityFriends,
			privateUserIDs, photosAll,
			friendIDs, PhotoPublic,
		)
	}

	// Gallery photos only.
	wheres = append(wheres, "gallery = ?")
	placeholders = append(placeholders, true)

	// Filter blocked users.
	if len(blocklist) > 0 {
		wheres = append(wheres, "user_id NOT IN ?")
		placeholders = append(placeholders, blocklist)
	}

	// Non-explicit pics unless the user opted in. Allow explicit filter setting to override.
	if filterExplicit != "" {
		wheres = append(wheres, "explicit = ?")
		placeholders = append(placeholders, filterExplicit == "true")
	} else if !explicitOK {
		wheres = append(wheres, "explicit = ?")
		placeholders = append(placeholders, false)
	}

	// Is the user furthermore clamping the visibility filter?
	if filterVisibility != "" {
		wheres = append(wheres, "visibility = ?")
		placeholders = append(placeholders, filterVisibility)
	}

	// Only certified (and not banned) user photos.
	wheres = append(wheres,
		"EXISTS (SELECT 1 FROM users WHERE id = photos.user_id AND certified = true AND status='active')",
	)

	// Exclude private users' photos.
	wheres = append(wheres,
		"NOT EXISTS (SELECT 1 FROM users WHERE id = photos.user_id AND visibility = 'private')",
	)

	// Admin view: get ALL PHOTOS on the site, period.
	if adminView {
		query = DB

		// Admin may filter too.
		if filterVisibility != "" {
			query = query.Where("visibility = ?", filterVisibility)
		}
		if filterExplicit != "" {
			query = query.Where("explicit = ?", filterExplicit == "true")
		}
	} else {
		query = DB.Where(
			strings.Join(wheres, " AND "),
			placeholders...,
		)
	}

	query = query.Order(pager.Sort)

	query.Model(&Photo{}).Count(&pager.Total)
	result := query.Offset(pager.GetOffset()).Limit(pager.PerPage).Find(&p)
	return p, result.Error
}

// Save photo.
func (p *Photo) Save() error {
	result := DB.Save(p)
	return result.Error
}

// Delete photo.
func (p *Photo) Delete() error {
	result := DB.Delete(p)
	return result.Error
}