Initial Commit

2021-02-11 15:47:42 -05:00
commit fec590b16e
249 changed files with 42571 additions and 0 deletions
--- a/internal/db/albums.go
+++ b/internal/db/albums.go
@@ -0,0 +1,37 @@
+package db
+
+import (
+	log "github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+
+	"reichard.io/imagini/graph/model"
+)
+
+func (dbm *DBManager) CreateAlbum(album *model.Album) error {
+	log.Debug("[db] Creating album: ", album.Name)
+	err := dbm.db.Create(album).Error
+	return err
+}
+
+func (dbm *DBManager) Album(album *model.Album) (int64, error) {
+	var count int64
+	err := dbm.db.Where(album).First(album).Count(&count).Error
+	return count, err
+}
+
+func (dbm *DBManager) Albums(userID string, filters *model.AlbumFilter, page *model.Page, order *model.Order) ([]*model.Album, model.PageResponse, error) {
+	// Initial User Filter
+	tx := dbm.db.Session(&gorm.Session{}).Model(&model.Album{}).Where("user_id == ?", userID)
+
+	// Dynamically Generate Base Query
+	tx, pageResponse := dbm.generateBaseQuery(tx, filters, page, order)
+
+	// Acquire Results
+	var foundAlbums []*model.Album
+	err := tx.Find(&foundAlbums).Error
+	return foundAlbums, pageResponse, err
+}
+
+func (dbm *DBManager) DeleteAlbum(album *model.Album) error {
+	return nil
+}
--- a/internal/db/db.go
+++ b/internal/db/db.go
@@ -0,0 +1,155 @@
+package db
+
+import (
+	"fmt"
+	"path"
+	"reflect"
+
+	"github.com/iancoleman/strcase"
+	log "github.com/sirupsen/logrus"
+
+	// "gorm.io/gorm/logger"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+
+	"reichard.io/imagini/graph/model"
+	"reichard.io/imagini/internal/config"
+)
+
+type DBManager struct {
+	db *gorm.DB
+}
+
+func NewMgr(c *config.Config) *DBManager {
+	gormConfig := &gorm.Config{
+		PrepareStmt: true,
+		// Logger: logger.Default.LogMode(logger.Silent),
+	}
+
+	// Create manager
+	dbm := &DBManager{}
+
+	if c.DBType == "SQLite" {
+		dbLocation := path.Join(c.ConfigPath, "imagini.db")
+		dbm.db, _ = gorm.Open(sqlite.Open(dbLocation), gormConfig)
+		dbm.db = dbm.db.Debug()
+	} else {
+		log.Fatal("Unsupported Database")
+	}
+
+	// Initialize database
+	dbm.db.AutoMigrate(&model.Device{})
+	dbm.db.AutoMigrate(&model.User{})
+	dbm.db.AutoMigrate(&model.MediaItem{})
+	dbm.db.AutoMigrate(&model.Tag{})
+	dbm.db.AutoMigrate(&model.Album{})
+
+	// Determine whether to bootstrap
+	var count int64
+	dbm.db.Model(&model.User{}).Count(&count)
+	if count == 0 {
+		dbm.bootstrapDatabase()
+	}
+
+	return dbm
+}
+
+func (dbm *DBManager) bootstrapDatabase() {
+	log.Info("[query] Bootstrapping database.")
+
+	password := "admin"
+	user := &model.User{
+		Username: "admin",
+		AuthType: "Local",
+		Password: &password,
+		Role:     model.RoleAdmin,
+	}
+
+	err := dbm.CreateUser(user)
+
+	if err != nil {
+		log.Fatal("[query] Unable to bootstrap database.")
+	}
+}
+
+func (dbm *DBManager) generateBaseQuery(tx *gorm.DB, filter interface{}, page *model.Page, order *model.Order) (*gorm.DB, model.PageResponse) {
+	tx = dbm.generateFilter(tx, filter)
+	tx = dbm.generateOrder(tx, order, filter)
+	tx, pageResponse := dbm.generatePage(tx, page)
+	return tx, pageResponse
+}
+
+func (dbm *DBManager) generateOrder(tx *gorm.DB, order *model.Order, filter interface{}) *gorm.DB {
+	// Set Defaults
+	orderBy := "created_at"
+	orderDirection := model.OrderDirectionDesc
+
+	if order == nil {
+		order = &model.Order{
+			By:        &orderBy,
+			Direction: &orderDirection,
+		}
+	}
+
+	if order.By == nil {
+		order.By = &orderBy
+	}
+
+	if order.Direction == nil {
+		order.Direction = &orderDirection
+	}
+
+	// Get Possible Values
+	ptr := reflect.New(reflect.TypeOf(filter).Elem())
+	v := reflect.Indirect(ptr)
+
+	isValid := false
+	for i := 0; i < v.NumField(); i++ {
+		fieldName := v.Type().Field(i).Name
+		if strcase.ToSnake(*order.By) == strcase.ToSnake(fieldName) {
+			isValid = true
+			break
+		}
+	}
+
+	if isValid {
+		tx = tx.Order(fmt.Sprintf("%s %s", strcase.ToSnake(*order.By), order.Direction.String()))
+	}
+
+	return tx
+}
+
+func (dbm *DBManager) generatePage(tx *gorm.DB, page *model.Page) (*gorm.DB, model.PageResponse) {
+	// Set Defaults
+	var count int64
+	pageSize := 50
+	pageNum := 1
+
+	if page == nil {
+		page = &model.Page{
+			Size: &pageSize,
+			Page: &pageNum,
+		}
+	}
+
+	if page.Size == nil {
+		page.Size = &pageSize
+	}
+
+	if page.Page == nil {
+		page.Page = &pageNum
+	}
+
+	// Acquire Counts Before Pagination
+	tx.Count(&count)
+
+	// Calculate Offset
+	calculatedOffset := (*page.Page - 1) * *page.Size
+	tx = tx.Limit(*page.Size).Offset(calculatedOffset)
+
+	return tx, model.PageResponse{
+		Page:  *page.Page,
+		Size:  *page.Size,
+		Total: int(count),
+	}
+}
--- a/internal/db/devices.go
+++ b/internal/db/devices.go
@@ -0,0 +1,44 @@
+package db
+
+import (
+	"github.com/google/uuid"
+	log "github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+
+	"reichard.io/imagini/graph/model"
+)
+
+func (dbm *DBManager) CreateDevice(device *model.Device) error {
+	log.Debug("[db] Creating device: ", device.Name)
+	refreshKey := uuid.New().String()
+	device.RefreshKey = &refreshKey
+	err := dbm.db.Create(device).Error
+	return err
+}
+
+func (dbm *DBManager) Device(device *model.Device) (int64, error) {
+	var count int64
+	err := dbm.db.Where(device).First(device).Count(&count).Error
+	return count, err
+}
+
+func (dbm *DBManager) Devices(userID string, filters *model.DeviceFilter, page *model.Page, order *model.Order) ([]*model.Device, model.PageResponse, error) {
+	// Initial User Filter
+	tx := dbm.db.Session(&gorm.Session{}).Model(&model.Device{}).Where("user_id == ?", userID)
+
+	// Dynamically Generate Base Query
+	tx, pageResponse := dbm.generateBaseQuery(tx, filters, page, order)
+
+	// Acquire Results
+	var foundDevices []*model.Device
+	err := tx.Find(&foundDevices).Error
+	return foundDevices, pageResponse, err
+}
+
+func (dbm *DBManager) DeleteDevice(user *model.Device) error {
+	return nil
+}
+
+func (dbm *DBManager) UpdateRefreshToken(device *model.Device, refreshToken string) error {
+	return nil
+}
--- a/internal/db/filters.go
+++ b/internal/db/filters.go
@@ -0,0 +1,196 @@
+package db
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/iancoleman/strcase"
+	"gorm.io/gorm"
+	"reichard.io/imagini/graph/model"
+)
+
+// Generic function used to generate filters for the DB
+func (dbm *DBManager) generateFilter(tx *gorm.DB, filter interface{}) *gorm.DB {
+	ptr := reflect.ValueOf(filter)
+	v := reflect.Indirect(ptr)
+
+	if v == reflect.ValueOf(nil) {
+		return tx
+	}
+
+	for i := 0; i < v.NumField(); i++ {
+		fieldName := strcase.ToSnake(v.Type().Field(i).Name)
+		fieldVal := v.Field(i)
+
+		if fieldVal.IsNil() {
+			continue
+		}
+
+		switch valType := fieldVal.Type(); valType {
+		case reflect.TypeOf(&model.StringFilter{}):
+			tx = generateStringFilter(tx, fieldName, fieldVal.Interface().(*model.StringFilter))
+		case reflect.TypeOf(&model.BooleanFilter{}):
+			tx = generateBooleanFilter(tx, fieldName, fieldVal.Interface().(*model.BooleanFilter))
+		case reflect.TypeOf(&model.FloatFilter{}):
+			tx = generateFloatFilter(tx, fieldName, fieldVal.Interface().(*model.FloatFilter))
+		case reflect.TypeOf(&model.IntFilter{}):
+			tx = generateIntFilter(tx, fieldName, fieldVal.Interface().(*model.IntFilter))
+		case reflect.TypeOf(&model.IDFilter{}):
+			tx = generateIDFilter(tx, fieldName, fieldVal.Interface().(*model.IDFilter))
+		case reflect.TypeOf(&model.TimeFilter{}):
+			tx = generateTimeFilter(tx, fieldName, fieldVal.Interface().(*model.TimeFilter))
+		case reflect.TypeOf(&model.RoleFilter{}):
+			tx = generateRoleFilter(tx, fieldName, fieldVal.Interface().(*model.RoleFilter))
+		case reflect.TypeOf(&model.DeviceTypeFilter{}):
+			tx = generateDeviceTypeFilter(tx, fieldName, fieldVal.Interface().(*model.DeviceTypeFilter))
+		case reflect.TypeOf(&model.AuthTypeFilter{}):
+			tx = generateAuthTypeFilter(tx, fieldName, fieldVal.Interface().(*model.AuthTypeFilter))
+		}
+	}
+
+	return tx
+}
+
+func generateStringFilter(tx *gorm.DB, fieldName string, filter *model.StringFilter) *gorm.DB {
+	if filter.EqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s == ?", fieldName), *filter.EqualTo)
+	}
+	if filter.NotEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s != ?", fieldName), *filter.NotEqualTo)
+	}
+	if filter.StartsWith != nil {
+		tx = tx.Where(fmt.Sprintf("%s LIKE ?", fieldName), fmt.Sprintf("%s%%", *filter.StartsWith))
+	}
+	if filter.NotStartsWith != nil {
+		tx = tx.Where(fmt.Sprintf("%s NOT LIKE ?", fieldName), fmt.Sprintf("%s%%", *filter.NotStartsWith))
+	}
+	if filter.EndsWith != nil {
+		tx = tx.Where(fmt.Sprintf("%s LIKE ?", fieldName), fmt.Sprintf("%%%s", *filter.EndsWith))
+	}
+	if filter.NotEndsWith != nil {
+		tx = tx.Where(fmt.Sprintf("%s NOT LIKE ?", fieldName), fmt.Sprintf("%%%s", *filter.NotEndsWith))
+	}
+	if filter.Contains != nil {
+		tx = tx.Where(fmt.Sprintf("%s LIKE ?", fieldName), fmt.Sprintf("%%%s%%", *filter.Contains))
+	}
+	if filter.NotContains != nil {
+		tx = tx.Where(fmt.Sprintf("%s NOT LIKE ?", fieldName), fmt.Sprintf("%%%s%%", *filter.NotContains))
+	}
+	return tx
+}
+
+func generateBooleanFilter(tx *gorm.DB, fieldName string, filter *model.BooleanFilter) *gorm.DB {
+	if filter.EqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s == ?", fieldName), *filter.EqualTo)
+	}
+	if filter.NotEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s != ?", fieldName), *filter.NotEqualTo)
+	}
+	return tx
+}
+
+func generateFloatFilter(tx *gorm.DB, fieldName string, filter *model.FloatFilter) *gorm.DB {
+	if filter.EqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s == ?", fieldName), *filter.EqualTo)
+	}
+	if filter.NotEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s != ?", fieldName), *filter.NotEqualTo)
+	}
+	if filter.GreaterThan != nil {
+		tx = tx.Where(fmt.Sprintf("%s > ?", fieldName), *filter.GreaterThan)
+	}
+	if filter.GreaterThanOrEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s >= ?", fieldName), *filter.GreaterThanOrEqualTo)
+	}
+	if filter.LessThan != nil {
+		tx = tx.Where(fmt.Sprintf("%s < ?", fieldName), *filter.LessThan)
+	}
+	if filter.LessThanOrEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s <= ?", fieldName), *filter.LessThanOrEqualTo)
+	}
+	return tx
+}
+
+func generateIntFilter(tx *gorm.DB, fieldName string, filter *model.IntFilter) *gorm.DB {
+	if filter.EqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s == ?", fieldName), *filter.EqualTo)
+	}
+	if filter.NotEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s != ?", fieldName), *filter.NotEqualTo)
+	}
+	if filter.GreaterThan != nil {
+		tx = tx.Where(fmt.Sprintf("%s > ?", fieldName), *filter.GreaterThan)
+	}
+	if filter.GreaterThanOrEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s >= ?", fieldName), *filter.GreaterThanOrEqualTo)
+	}
+	if filter.LessThan != nil {
+		tx = tx.Where(fmt.Sprintf("%s < ?", fieldName), *filter.LessThan)
+	}
+	if filter.LessThanOrEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s <= ?", fieldName), *filter.LessThanOrEqualTo)
+	}
+	return tx
+}
+
+func generateIDFilter(tx *gorm.DB, fieldName string, filter *model.IDFilter) *gorm.DB {
+	if filter.EqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s == ?", fieldName), *filter.EqualTo)
+	}
+	if filter.NotEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s != ?", fieldName), *filter.NotEqualTo)
+	}
+	return tx
+}
+
+func generateTimeFilter(tx *gorm.DB, fieldName string, filter *model.TimeFilter) *gorm.DB {
+	if filter.EqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s == ?", fieldName), *filter.EqualTo)
+	}
+	if filter.NotEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s != ?", fieldName), *filter.NotEqualTo)
+	}
+	if filter.GreaterThan != nil {
+		tx = tx.Where(fmt.Sprintf("%s > ?", fieldName), *filter.GreaterThan)
+	}
+	if filter.GreaterThanOrEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s >= ?", fieldName), *filter.GreaterThanOrEqualTo)
+	}
+	if filter.LessThan != nil {
+		tx = tx.Where(fmt.Sprintf("%s < ?", fieldName), *filter.LessThan)
+	}
+	if filter.LessThanOrEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s <= ?", fieldName), *filter.LessThanOrEqualTo)
+	}
+	return tx
+}
+
+func generateRoleFilter(tx *gorm.DB, fieldName string, filter *model.RoleFilter) *gorm.DB {
+	if filter.EqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s == ?", fieldName), *filter.EqualTo)
+	}
+	if filter.NotEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s != ?", fieldName), *filter.NotEqualTo)
+	}
+	return tx
+}
+
+func generateDeviceTypeFilter(tx *gorm.DB, fieldName string, filter *model.DeviceTypeFilter) *gorm.DB {
+	if filter.EqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s == ?", fieldName), *filter.EqualTo)
+	}
+	if filter.NotEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s != ?", fieldName), *filter.NotEqualTo)
+	}
+	return tx
+}
+
+func generateAuthTypeFilter(tx *gorm.DB, fieldName string, filter *model.AuthTypeFilter) *gorm.DB {
+	if filter.EqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s == ?", fieldName), *filter.EqualTo)
+	}
+	if filter.NotEqualTo != nil {
+		tx = tx.Where(fmt.Sprintf("%s != ?", fieldName), *filter.NotEqualTo)
+	}
+	return tx
+}
--- a/internal/db/media_items.go
+++ b/internal/db/media_items.go
@@ -0,0 +1,34 @@
+package db
+
+import (
+	log "github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+
+	"reichard.io/imagini/graph/model"
+)
+
+func (dbm *DBManager) CreateMediaItem(mediaItem *model.MediaItem) error {
+	log.Debug("[db] Creating media item: ", mediaItem.FileName)
+	err := dbm.db.Create(mediaItem).Error
+	return err
+}
+
+func (dbm *DBManager) MediaItem(mediaItem *model.MediaItem) (int64, error) {
+	var count int64
+	err := dbm.db.Where(mediaItem).First(mediaItem).Count(&count).Error
+	return count, err
+}
+
+// UserID, Filters, Sort, Page, Delete
+func (dbm *DBManager) MediaItems(userID string, filters *model.MediaItemFilter, page *model.Page, order *model.Order) ([]*model.MediaItem, model.PageResponse, error) {
+	// Initial User Filter
+	tx := dbm.db.Session(&gorm.Session{}).Model(&model.MediaItem{}).Where("user_id == ?", userID)
+
+	// Dynamically Generate Base Query
+	tx, pageResponse := dbm.generateBaseQuery(tx, filters, page, order)
+
+	// Acquire Results
+	var mediaItems []*model.MediaItem
+	err := tx.Find(&mediaItems).Error
+	return mediaItems, pageResponse, err
+}
--- a/internal/db/tags.go
+++ b/internal/db/tags.go
@@ -0,0 +1,37 @@
+package db
+
+import (
+	log "github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+
+	"reichard.io/imagini/graph/model"
+)
+
+func (dbm *DBManager) CreateTag(tag *model.Tag) error {
+	log.Debug("[db] Creating tag: ", tag.Name)
+	err := dbm.db.Create(tag).Error
+	return err
+}
+
+func (dbm *DBManager) Tag(tag *model.Tag) (int64, error) {
+	var count int64
+	err := dbm.db.Where(tag).First(tag).Count(&count).Error
+	return count, err
+}
+
+func (dbm *DBManager) Tags(userID string, filters *model.TagFilter, page *model.Page, order *model.Order) ([]*model.Tag, model.PageResponse, error) {
+	// Initial User Filter
+	tx := dbm.db.Session(&gorm.Session{}).Model(&model.Tag{}).Where("user_id == ?", userID)
+
+	// Dynamically Generate Base Query
+	tx, pageResponse := dbm.generateBaseQuery(tx, filters, page, order)
+
+	// Acquire Results
+	var foundTags []*model.Tag
+	err := tx.Find(&foundTags).Error
+	return foundTags, pageResponse, err
+}
+
+func (dbm *DBManager) DeleteTag(tag *model.Tag) error {
+	return nil
+}
--- a/internal/db/users.go
+++ b/internal/db/users.go
@@ -0,0 +1,48 @@
+package db
+
+import (
+	log "github.com/sirupsen/logrus"
+	"golang.org/x/crypto/bcrypt"
+	"gorm.io/gorm"
+
+	"reichard.io/imagini/graph/model"
+)
+
+func (dbm *DBManager) CreateUser(user *model.User) error {
+	log.Info("[db] Creating user: ", user.Username)
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(*user.Password), bcrypt.DefaultCost)
+	if err != nil {
+		log.Error(err)
+		return err
+	}
+	stringHashedPassword := string(hashedPassword)
+	user.Password = &stringHashedPassword
+	return dbm.db.Create(user).Error
+}
+
+func (dbm *DBManager) User(user *model.User) (int64, error) {
+	var count int64
+	err := dbm.db.Where(user).First(user).Count(&count).Error
+	return count, err
+}
+
+func (dbm *DBManager) Users(filters *model.UserFilter, page *model.Page, order *model.Order) ([]*model.User, model.PageResponse, error) {
+	// Initial User Filter
+	tx := dbm.db.Session(&gorm.Session{}).Model(&model.Tag{})
+
+	// Dynamically Generate Base Query
+	tx, pageResponse := dbm.generateBaseQuery(tx, filters, page, order)
+
+	// Acquire Results
+	var foundUsers []*model.User
+	err := tx.Find(&foundUsers).Error
+	return foundUsers, pageResponse, err
+}
+
+func (dbm *DBManager) DeleteUser(user model.User) error {
+	return nil
+}
+
+func (dbm *DBManager) UpdatePassword(user model.User, pw string) {
+
+}