Finally Framework

internal/db/db.go

@@ -0,0 +1,153 @@
+package db
+
+import (
+	"path"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+	"gorm.io/driver/sqlite"
+    log "github.com/sirupsen/logrus"
+
+	"reichard.io/imagini/internal/config"
+	"reichard.io/imagini/internal/models"
+)
+
+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)
+    } else {
+        log.Fatal("Unsupported Database")
+    }
+
+    // Initialize database
+    dbm.db.AutoMigrate(&models.ServerSetting{})
+    dbm.db.AutoMigrate(&models.User{})
+    dbm.db.AutoMigrate(&models.MediaItem{})
+    dbm.db.AutoMigrate(&models.Tag{})
+    dbm.db.AutoMigrate(&models.Album{})
+
+    // Determine whether to bootstrap
+    var count int64
+    dbm.db.Model(&models.User{}).Count(&count)
+    if count == 0 {
+        dbm.bootstrapDatabase()
+    }
+
+    return dbm
+}
+
+func (dbm *DBManager) bootstrapDatabase() {
+    log.Info("[query] Bootstrapping database.")
+    err := dbm.CreateUser(models.User{
+        Username: "admin",
+        Password: "admin",
+        AuthType: "Local",
+    })
+
+    if err != nil {
+        log.Fatal("[query] Unable to bootstrap database.")
+    }
+}
+
+func (dbm *DBManager) ItemsFromAlbum(user models.User, album models.Album) []models.MediaItem {
+    var mediaItems []models.MediaItem
+    // db.Table("media_albums").
+    //     Select("media_item.*").
+    //     Joins("INNER JOIN media_items ON media_albums.ID = media_items.Albums").
+    //     Where("media_albums.album_id = ? AND media_items.User = ?", albumID, userID).
+
+
+    dbm.db.
+        //Where("album = ? AND user = ?", albumID, userID).
+        Find(&mediaItems)
+    return mediaItems
+
+    // db.Raw(`
+    //     SELECT
+    //         MediaItems.*
+    //     FROM
+    //         MediaAlbums
+    //     INNER JOIN MediaItems ON MediaAlbums.mediaID = MediaItems.mediaID
+    //     WHERE MediaAlbums.albumID = ? AND MediaItems.userID = ?`, albumID, userID)
+}
+
+// func ItemsFromTags(userID int, tagID int) []MediaItem {
+//     return nil
+// }
+// 
+// func IndexMediaItems(newItems []MediaItem) {
+// }
+
+// func PopulateTestData() {
+//     user1 := User{Username: "Evan", Email: "evan@reichard.io", FirstName: "Evan", LastName: "Reichard", AuthType: "LDAP", Salt: "1234", HashedPWSalt: "1234"}
+//     user2 := User{Username: "Ryan", Email: "ryan@example.com", FirstName: "Ryan", LastName: "Dunfrey", AuthType: "Local", Salt: "2345", HashedPWSalt: "2345"}
+//     user3 := User{Username: "Bill", Email: "bill@example.com", FirstName: "Bill", LastName: "Smith", AuthType: "LDAP", Salt: "3456", HashedPWSalt: "3456"}
+// 
+//     mi1 := MediaItem{
+//         User: user1,
+//         EXIFDate: time.Now(),
+//         Latitude: "1234",
+//         Longitude: "1234",
+//         RelPath: "./1234.jpg",
+//         Tags:   []Tag{
+//             {Name: "Tag1"},
+//             {Name: "Tag2"},
+//         },
+//         Albums:   []Album{
+//             {Name: "Album1"},
+//             {Name: "Album2"},
+//         },
+//     }
+// 
+//     mi2 := MediaItem{
+//         User: user2,
+//         EXIFDate: time.Now(),
+//         Latitude: "1234",
+//         Longitude: "1234",
+//         RelPath: "./1234.jpg",
+//         Tags:   []Tag{
+//             {Name: "Tag3"},
+//             {Name: "Tag4"},
+//         },
+//         Albums:   []Album{
+//             {Name: "Album3"},
+//             {Name: "Album4"},
+//         },
+//     }
+// 
+//     mi3 := MediaItem{
+//         User: user3,
+//         EXIFDate: time.Now(),
+//         Latitude: "1234",
+//         Longitude: "1234",
+//         RelPath: "./1234.jpg",
+//         Tags:   []Tag{
+//             {Name: "Tag4"},
+//             {Name: "Tag5"},
+//         },
+//         Albums:   []Album{
+//             {Name: "Album1"},
+//             {Name: "Album7"},
+//         },
+//     }
+// 
+//     // db.Create(&user1)
+//     // db.Create(&user2)
+//     // db.Create(&user3)
+//     db.Create(&mi1)
+//     db.Create(&mi2)
+//     db.Create(&mi3)
+// }

internal/db/errors.go

@@ -0,0 +1,7 @@
+package db
+
+import "errors"
+
+var (
+    ErrUserAlreadyExists = errors.New("user already exists")
+)

internal/db/users.go

@@ -0,0 +1,42 @@
+package db
+
+import (
+    "errors"
+	"gorm.io/gorm"
+    "golang.org/x/crypto/bcrypt"
+    log "github.com/sirupsen/logrus"
+
+	"reichard.io/imagini/internal/models"
+)
+
+func (dbm *DBManager) CreateUser(user models.User) error {
+    log.Info("[query] Creating user: ", user.Username)
+    _, err := dbm.User(user)
+    if !errors.Is(err, gorm.ErrRecordNotFound) {
+        log.Warn("[query] User already exists: ", user.Username)
+        return errors.New("User already exists")
+    }
+
+    hashedPassword, err := bcrypt.GenerateFromPassword([]byte(user.Password), bcrypt.DefaultCost)
+    if err != nil {
+        log.Error(err)
+        return err
+    }
+    user.Password = string(hashedPassword)
+    return dbm.db.Create(&user).Error
+}
+
+func (dbm *DBManager) User (user models.User) (models.User, error) {
+    var foundUser models.User
+    var count int64
+    err := dbm.db.Where(&user).First(&foundUser).Count(&count).Error
+    return foundUser, err
+}
+
+func (dbm *DBManager) DeleteUser (user models.User) error {
+    return nil
+}
+
+func (dbm *DBManager) UpdatePassword (user models.User, pw string) {
+
+}