Implements the database

album_database.go

@@ -1,27 +1,112 @@
 package main
 
-import "github.com/peterbourgon/diskv"
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+
+	"github.com/peterbourgon/diskv"
+)
 
 type AlbumDatabase struct {
-	db *diskv.Diskv
+	dv *diskv.Diskv
+
+	sorted     bool
+	sortedList []AlbumID
 }
 
-func OpenAlbumDatabase(basepath string) (*AlbumDatabase, error) {
-	return nil, notYetImplemented()
+func OpenAlbumDatabase(basepath string) *AlbumDatabase {
+
+	return &AlbumDatabase{
+		dv: diskv.New(diskv.Options{
+			BasePath:     basepath,
+			CacheSizeMax: 100 * 1024 * 1024, // 100 MB
+			Compression:  diskv.NewGzipCompression(),
+		}),
+		sorted:     false,
+		sortedList: make([]AlbumID, 0, 10),
+	}
 }
 
-func (db *AlbumDatabase) AddOrUpdate(*Album) error {
-	return notYetImplemented()
+func (db *AlbumDatabase) AddOrUpdate(a *Album) error {
+	data, err := json.Marshal(a)
+	if err != nil {
+		return err
+	}
+	aInDb, err := db.Get(a.ID)
+	dbNewSorted := false
+	if err == nil {
+		dbNewSorted = (a.PurchaseDate != aInDb.PurchaseDate)
+	}
+
+	err = db.dv.Write(AlbumIDString(a.ID), data)
+	if err == nil {
+		db.sorted = dbNewSorted
+	}
+
+	return err
 }
 
-func (db *AlbumDatabase) Delete(AlbumID) error {
-	return notYetImplemented()
+func (db *AlbumDatabase) Delete(ID AlbumID) error {
+	if db.dv.Has(AlbumIDString(ID)) == false {
+		return fmt.Errorf("Album %d not found", ID)
+	}
+	return db.dv.Erase(AlbumIDString(ID))
 }
 
-func (db *AlbumDatabase) Get(AlbumID) (*Album, error) {
-	return nil, notYetImplemented()
+func (db *AlbumDatabase) get(ID string) (*Album, error) {
+	res := &Album{}
+
+	r, err := db.dv.ReadStream(ID, false)
+	if err != nil {
+		return nil, fmt.Errorf("Album %s not found: %s", ID, err)
+	}
+	dec := json.NewDecoder(r)
+	defer closeOrPanic(r, "db record "+ID)
+	return res, dec.Decode(res)
+}
+
+func (db *AlbumDatabase) Get(ID AlbumID) (*Album, error) {
+	return db.get(AlbumIDString(ID))
+}
+
+func (db *AlbumDatabase) GetJSON(ID AlbumID) ([]byte, error) {
+	return db.dv.Read(AlbumIDString(ID))
+}
+
+type ListOfAlbum []*Album
+
+func (l ListOfAlbum) Len() int {
+	return len(l)
+}
+
+func (l ListOfAlbum) Less(i, j int) bool {
+	return l[i].PurchaseDate.Before(l[j].PurchaseDate)
+}
+
+func (l ListOfAlbum) Swap(i, j int) {
+	l[i], l[j] = l[j], l[i]
 }
 
 func (db *AlbumDatabase) ByPurchaseDate() ([]AlbumID, error) {
-	return nil, notYetImplemented()
+	if db.sorted == false {
+		allAlbums := []*Album{}
+		for aIDStr := range db.dv.Keys(nil) {
+			a, err := db.get(aIDStr)
+			if err != nil {
+				return nil, err
+			}
+			allAlbums = append(allAlbums, a)
+		}
+
+		sort.Sort(sort.Reverse(ListOfAlbum(allAlbums)))
+
+		db.sortedList = make([]AlbumID, 0, len(allAlbums))
+		for _, a := range allAlbums {
+			db.sortedList = append(db.sortedList, a.ID)
+		}
+		db.sorted = true
+	}
+
+	return db.sortedList, nil
 }