New database squema

The collection new is removed, now the books have a field "active" set to true
if the book was aproved.

For update the database:
db.books.update({}, {$set: {active: true}}, true, true)

admin.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"labix.org/v2/mgo"
 	"labix.org/v2/mgo/bson"
 	"net/http"
 	"os"
@@ -10,8 +9,7 @@ import (
 	"strings"
 )
 
-func deleteHandler(coll *mgo.Collection, url string) func(http.ResponseWriter, *http.Request) {
+func deleteHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
 	sess := GetSession(r)
 	if sess.User == "" {
 		http.NotFound(w, r)
@@ -20,7 +18,7 @@ func deleteHandler(coll *mgo.Collection, url string) func(http.ResponseWriter, *
 
 	// cutre hack: /delete/ and /delnew/ have the same lenght:
 	id := bson.ObjectIdHex(r.URL.Path[len("/delete/"):])
-		books, _, err := GetBook(coll, bson.M{"_id": id})
+	books, _, err := db.GetBooks(bson.M{"_id": id})
 	if err != nil {
 		http.NotFound(w, r)
 		return
@@ -33,22 +31,20 @@ func deleteHandler(coll *mgo.Collection, url string) func(http.ResponseWriter, *
 		os.RemoveAll(book.CoverSmall[1:])
 	}
 	os.RemoveAll(book.Path)
-		coll.Remove(bson.M{"_id": id})
+	db.RemoveBook(id)
 	sess.Notify("Removed book!", "The book '"+book.Title+"' it's completly removed", "success")
 	sess.Save(w, r)
-		http.Redirect(w, r, url, 307)
+	http.Redirect(w, r, "/", 307) //FIXME: if new return to /new/
-	}
 }
 
-func editHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request) {
+func editHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
 	sess := GetSession(r)
 	if sess.User == "" {
 		http.NotFound(w, r)
 		return
 	}
 	id := bson.ObjectIdHex(r.URL.Path[len("/edit/"):])
-		books, _, err := GetBook(coll, bson.M{"_id": id})
+	books, _, err := db.GetBooks(bson.M{"_id": id})
 	if err != nil {
 		http.NotFound(w, r)
 		return
@@ -58,7 +54,6 @@ func editHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request)
 	data.Book = books[0]
 	data.S = GetStatus(w, r)
 	loadTemplate(w, "edit", data)
-	}
 }
 
 func cleanEmptyStr(s []string) []string {
@@ -71,8 +66,7 @@ func cleanEmptyStr(s []string) []string {
 	return res
 }
 
-func saveHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request) {
+func saveHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "POST" {
 		http.NotFound(w, r)
 		return
@@ -100,7 +94,7 @@ func saveHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request)
 		"subject":     subject,
 		"lang":        lang}
 	book["keywords"] = keywords(book)
-		err := coll.Update(bson.M{"_id": id}, bson.M{"$set": book})
+	err := db.UpdateBook(id, book)
 	if err != nil {
 		http.NotFound(w, r)
 		return
@@ -109,7 +103,6 @@ func saveHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request)
 	sess.Notify("Book Modified!", "", "success")
 	sess.Save(w, r)
 	http.Redirect(w, r, "/book/"+idStr, 307)
-	}
 }
 
 type newBook struct {
@@ -123,31 +116,29 @@ type newData struct {
 	Books []newBook
 }
 
-func newHandler(coll *mgo.Collection, booksColl *mgo.Collection) func(http.ResponseWriter, *http.Request) {
+func newHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if len(r.URL.Path) > len("/new/") {
-			http.ServeFile(w, r, r.URL.Path[1:])
-			return
-		}
-
 	sess := GetSession(r)
 	if sess.User == "" {
 		http.NotFound(w, r)
 		return
 	}
 
-		res, num, _ := GetBook(coll, bson.M{})
+	if len(r.URL.Path) > len("/new/") {
+		http.ServeFile(w, r, r.URL.Path[1:])
+		return
+	}
+
+	res, num, _ := db.GetNewBooks()
 	var data newData
 	data.S = GetStatus(w, r)
 	data.Found = num
 	data.Books = make([]newBook, num)
 	for i, b := range res {
 		data.Books[i].B = b
-			_, data.Books[i].TitleFound, _ = GetBook(booksColl, buildQuery("title:" + b.Title), 1)
+		_, data.Books[i].TitleFound, _ = db.GetBooks(buildQuery("title:" + b.Title), 1)
-			_, data.Books[i].AuthorFound, _ = GetBook(booksColl, buildQuery("author:" + strings.Join(b.Author, " author:")), 1)
+		_, data.Books[i].AuthorFound, _ = db.GetBooks(buildQuery("author:" + strings.Join(b.Author, " author:")), 1)
 	}
 	loadTemplate(w, "new", data)
-	}
 }
 
 func ValidFileName(path string, title string, extension string) string {
@@ -162,8 +153,7 @@ func ValidFileName(path string, title string, extension string) string {
 	return file
 }
 
-func storeHandler(newColl, coll *mgo.Collection) func(http.ResponseWriter, *http.Request) {
+func storeHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
 	sess := GetSession(r)
 	if sess.User == "" {
 		http.NotFound(w, r)
@@ -171,25 +161,22 @@ func storeHandler(newColl, coll *mgo.Collection) func(http.ResponseWriter, *http
 	}
 
 	id := bson.ObjectIdHex(r.URL.Path[len("/store/"):])
-		var book bson.M
+	books, _, err := db.GetBooks(bson.M{"_id": id})
-		err := newColl.Find(bson.M{"_id": id}).One(&book)
 	if err != nil {
 		http.NotFound(w, r)
 		return
 	}
+	book := books[0]
 
-		title, _ := book["title"].(string)
+	title := book.Title
 	path := ValidFileName(BOOKS_PATH + title[:1], title, ".epub")
 
-		oldPath, _ := book["path"].(string)
+	oldPath := book.Path
 	os.Mkdir(BOOKS_PATH+title[:1], os.ModePerm)
 	cmd := exec.Command("mv", oldPath, path)
 	cmd.Run()
-		book["path"] = path
+	db.UpdateBook(id, bson.M{"active": true, "path": path})
-		coll.Insert(book)
-		newColl.Remove(bson.M{"_id": id})
 	sess.Notify("Store book!", "The book '"+title+"' it's stored for public download", "success")
 	sess.Save(w, r)
 	http.Redirect(w, r, "/new/", 307)
-	}
 }

database.go

@@ -1,11 +1,15 @@
 package main
 
 import (
+	"crypto/md5"
 	"labix.org/v2/mgo"
 	"labix.org/v2/mgo/bson"
 	"sort"
 )
 
+var db *DB
+
+
 type Book struct {
 	Id          string `bson:"_id"`
 	Title       string
@@ -26,14 +30,60 @@ type Book struct {
 	Path        string
 	Cover       string
 	CoverSmall  string
+	Active      bool
 	Keywords    []string
 }
 
+type DB struct {
+	session *mgo.Session
+	books *mgo.Collection
+	user *mgo.Collection
+}
+
+func initDB() *DB {
+	var err error
+	d := new(DB)
+	d.session, err = mgo.Dial(DB_IP)
+	if err != nil {
+		panic(err)
+	}
+
+	d.books = d.session.DB(DB_NAME).C(BOOKS_COLL)
+	d.user = d.session.DB(DB_NAME).C(USERS_COLL)
+	return d
+}
+
+func (d *DB) Close() {
+	d.session.Close()
+}
+
+func (d *DB) UserValid(user string, pass string) bool {
+	h := md5.New()
+	hash := h.Sum(([]byte)(PASS_SALT + pass))
+	n, err := d.user.Find(bson.M{"user": user, "pass": hash}).Count()
+	if err != nil {
+		return false
+	}
+	return n != 0
+}
+
+func (d *DB) InsertBook(book interface{}) error {
+	return d.books.Insert(book)
+}
+
+func (d *DB) RemoveBook(id bson.ObjectId) error {
+	return d.books.Remove(bson.M{"_id": id})
+}
+
+func (d *DB) UpdateBook(id bson.ObjectId, book interface{}) error {
+	return d.books.Update(bson.M{"_id": id}, bson.M{"$set": book})
+}
+
 /* optional parameters: length and start index
  * 
  * Returns: list of books, number found and err
  */
-func GetBook(coll *mgo.Collection, query bson.M, r ...int) (books []Book, num int, err error) {
+func (d *DB) GetBooks(query bson.M, r ...int) (books []Book, num int, err error) {
 	var start, length int
 	if len(r) > 0 {
 		length = r[0]
@@ -41,7 +91,7 @@ func GetBook(coll *mgo.Collection, query bson.M, r ...int) (books []Book, num in
 			start = r[1]
 		}
 	}
-	q := coll.Find(query).Sort("-_id")
+	q := d.books.Find(query).Sort("-_id")
 	num, err = q.Count()
 	if err != nil {
 		return
@@ -58,7 +108,23 @@ func GetBook(coll *mgo.Collection, query bson.M, r ...int) (books []Book, num in
 		books[i].Id = bson.ObjectId(b.Id).Hex()
 	}
 	return
+}
 
+/* Returns: list of books, number found and err
+ */
+func (d *DB) GetNewBooks()(books []Book, num int, err error) {
+	var q *mgo.Query
+	q = d.books.Find(bson.M{"$nor": []bson.M{{"active": true}}}).Sort("-_id")
+	num, err = q.Count()
+	if err != nil {
+		return
+	}
+
+	err = q.All(&books)
+	for i, b := range books {
+		books[i].Id = bson.ObjectId(b.Id).Hex()
+	}
+	return
 }
 
 type tagsList []struct {
@@ -78,11 +144,11 @@ func (t tagsList) Swap(i, j int) {
 	t[j] = aux
 }
 
-func GetTags(coll *mgo.Collection) (tagsList, error) {
+func (d *DB) GetTags() (tagsList, error) {
 	// TODO: cache the tags
 	var mr mgo.MapReduce
 	mr.Map = "function() { " +
-		"this.subject.forEach(function(s) { emit(s, 1); });" +
+		"if (this.active) { this.subject.forEach(function(s) { emit(s, 1); }); }" +
 		"}"
 	mr.Reduce = "function(tag, vals) { " +
 		"var count = 0;" +
@@ -90,7 +156,7 @@ func GetTags(coll *mgo.Collection) (tagsList, error) {
 		"return count;" +
 		"}"
 	var result tagsList
-	_, err := coll.Find(nil).MapReduce(&mr, &result)
+	_, err := d.books.Find(nil).MapReduce(&mr, &result)
 	if err == nil {
 		sort.Sort(result)
 	}

reader.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"git.gitorious.org/go-pkg/epub.git"
-	"labix.org/v2/mgo"
 	"labix.org/v2/mgo/bson"
 	"net/http"
 	"regexp"
@@ -116,23 +115,27 @@ func chapterList(e *epub.Epub, file string, id string, base string) (string, str
 	return next, prev, chapters
 }
 
-func readHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request) {
+func readHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
 	base, id, file := parseUrl(r.URL.Path)
-		if base == "/readnew/" {
+	books, _, err := db.GetBooks(bson.M{"_id": bson.ObjectIdHex(id)})
+	if err != nil || len(books) == 0 {
+		http.NotFound(w, r)
+		return
+	}
+
+	var data readData
+	data.Book = books[0]
+	if ! data.Book.Active {
 		sess := GetSession(r)
 		if sess.User == "" {
 			http.NotFound(w, r)
 			return
 		}
+		data.Back = "/new/"
+	} else {
+		data.Back = "/book/" + id
 	}
-		books, _, err := GetBook(coll, bson.M{"_id": bson.ObjectIdHex(id)})
+	e, _ := epub.Open(data.Book.Path, 0)
-		if err != nil || len(books) == 0 {
-			http.NotFound(w, r)
-			return
-		}
-		book := books[0]
-		e, _ := epub.Open(book.Path, 0)
 	defer e.Close()
 	if file == "" {
 		it := e.Iterator(epub.EITERATOR_LINEAR)
@@ -141,40 +144,27 @@ func readHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request)
 		return
 	}
 
-		var data readData
 	data.S = GetStatus(w, r)
-		data.Book = book
 	data.Next, data.Prev, data.Chapters = chapterList(e, file, id, base)
-		if base == "/readnew/" {
+	data.Content = genLink(id, "/content/", file)
-			data.Back = "/new/"
-		} else {
-			data.Back = "/book/" + id
-		}
-		baseContent := "/content/"
-		if base == "/readnew/" {
-			baseContent = "/contentnew/"
-		}
-		data.Content = genLink(id, baseContent, file)
 	loadTemplate(w, "read", data)
-	}
 }
 
-func contentHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request) {
+func contentHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
+	_, id, file := parseUrl(r.URL.Path)
-		base, id, file := parseUrl(r.URL.Path)
+	books, _, err := db.GetBooks(bson.M{"_id": bson.ObjectIdHex(id)})
-		if base == "/contentnew/" {
+	if err != nil || len(books) == 0 {
+		http.NotFound(w, r)
+		return
+	}
+	book := books[0]
+	if ! book.Active {
 		sess := GetSession(r)
 		if sess.User == "" {
 			http.NotFound(w, r)
 			return
 		}
 	}
-		books, _, err := GetBook(coll, bson.M{"_id": bson.ObjectIdHex(id)})
-		if err != nil || len(books) == 0 {
-			http.NotFound(w, r)
-			return
-		}
-		book := books[0]
 	e, _ := epub.Open(book.Path, 0)
 	defer e.Close()
 	if file == "" {
@@ -183,5 +173,4 @@ func contentHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Reques
 	}
 
 	w.Write(e.Data(file))
-	}
 }

search.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"labix.org/v2/mgo"
 	"labix.org/v2/mgo/bson"
 	"net/http"
 	"strconv"
@@ -10,7 +9,7 @@ import (
 
 func buildQuery(q string) bson.M {
 	var reg []bson.RegEx
-	query := bson.M{}
+	query := bson.M{"active": true}
 	words := strings.Split(q, " ")
 	for _, w := range words {
 		tag := strings.SplitN(w, ":", 2)
@@ -35,8 +34,7 @@ type searchData struct {
 	Prev  string
 }
 
-func searchHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request) {
+func searchHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
 	err := r.ParseForm()
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -50,7 +48,7 @@ func searchHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request
 			page = 0
 		}
 	}
-		res, num, _ := GetBook(coll, buildQuery(req), SEARCH_ITEMS_PAGE, page*SEARCH_ITEMS_PAGE)
+	res, num, _ := db.GetBooks(buildQuery(req), SEARCH_ITEMS_PAGE, page*SEARCH_ITEMS_PAGE)
 
 	var data searchData
 	data.S = GetStatus(w, r)
@@ -65,5 +63,4 @@ func searchHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request
 		data.Prev = "/search/?q=" + req + "&p=" + strconv.Itoa(page-1)
 	}
 	loadTemplate(w, "search", data)
-	}
 }

templates/new.html

@@ -21,14 +21,15 @@
 		</p>
 		</div>
 		<div class="span2">
-		<div class="row">
+		<div class="row btn-group pull-right">
-		<p><a href="/readnew/{{.Id}}" class="btn btn-warning pull-right"><i class="icon-eye-open icon-white"></i> read it!</a>
+			<a href="/store/{{.Id}}" class="btn btn-success"><i class="icon-ok"></i> Save</a>
-		<a href="/{{.Path}}" class="btn btn-inverse pull-right"><i class="icon-download-alt icon-white"></i> download</a></p>
+			<a href="/edit/{{.Id}}" class="btn btn-primary"><i class="icon-pencil"></i> Edit</a>
+			<a href="/delete/{{.Id}}" class="btn btn-danger"><i class="icon-remove"></i> Delete</a>
 		</div>
 		<div class="row"><p></p></div>
 		<div class="row btn-group pull-right">
-			<a href="/store/{{.Id}}" class="btn btn-success"><i class="icon-ok"></i> Save</a>
+			<a href="/{{.Path}}" class="btn btn-inverse"><i class="icon-download-alt icon-white"></i> download</a>
-			<a href="/delnew/{{.Id}}" class="btn btn-danger"><i class="icon-remove"></i> Delete</a>
+			<a href="/read/{{.Id}}" class="btn btn-warning"><i class="icon-eye-open icon-white"></i> read it!</a>
 		</div>
 		</div>
 	</div>

trantor.go

@@ -1,8 +1,6 @@
 package main
 
 import (
-	"crypto/md5"
-	"labix.org/v2/mgo"
 	"labix.org/v2/mgo/bson"
 	"net/http"
 	"os"
@@ -27,16 +25,12 @@ func logoutHandler(w http.ResponseWriter, r *http.Request) {
 	http.Redirect(w, r, "/", 307)
 }
 
-func loginHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request) {
+func loginHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
 	if r.Method == "POST" {
 		user := r.FormValue("user")
 		pass := r.FormValue("pass")
-			h := md5.New()
-			hash := h.Sum(([]byte)(PASS_SALT + pass))
-			n, _ := coll.Find(bson.M{"user": user, "pass": hash}).Count()
 		sess := GetSession(r)
-			if n != 0 {
+		if db.UserValid(user, pass) {
 			sess.LogIn(user)
 			sess.Notify("Successful login!", "Welcome "+user, "success")
 		} else {
@@ -45,7 +39,6 @@ func loginHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request)
 		sess.Save(w, r)
 	}
 	http.Redirect(w, r, r.Referer(), 307)
-	}
 }
 
 type bookData struct {
@@ -53,19 +46,17 @@ type bookData struct {
 	Book Book
 }
 
-func bookHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request) {
+func bookHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
 	var data bookData
 	data.S = GetStatus(w, r)
 	id := bson.ObjectIdHex(r.URL.Path[len("/book/"):])
-		books, _, err := GetBook(coll, bson.M{"_id": id})
+	books, _, err := db.GetBooks(bson.M{"_id": id})
 	if err != nil || len(books) == 0 {
 		http.NotFound(w, r)
 		return
 	}
 	data.Book = books[0]
 	loadTemplate(w, "book", data)
-	}
 }
 
 func fileHandler(path string) {
@@ -80,12 +71,11 @@ type indexData struct {
 	Tags  []string
 }
 
-func indexHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request) {
+func indexHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
 	var data indexData
 
 	/* get the tags */
-		tags, err := GetTags(coll)
+	tags, err := db.GetTags()
 	if err == nil {
 		length := len(tags)
 		if length > TAGS_DISPLAY {
@@ -104,21 +94,16 @@ func indexHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request)
 
 	data.S = GetStatus(w, r)
 	data.S.Home = true
-		data.Books, data.Count, _ = GetBook(coll, bson.M{}, 6)
+	data.Books, data.Count, _ = db.GetBooks(bson.M{"active": true}, 6)
 	loadTemplate(w, "index", data)
-	}
 }
 
 func main() {
-	session, err := mgo.Dial(DB_IP)
+	db = initDB()
-	if err != nil {
+	defer db.Close()
-		panic(err)
-	}
-	defer session.Close()
-	coll := session.DB(DB_NAME).C(BOOKS_COLL)
-	userColl := session.DB(DB_NAME).C(USERS_COLL)
-	newColl := session.DB(DB_NAME).C(NEW_BOOKS_COLL)
 
+	/* create the needed folders */
+	var err error
 	_, err = os.Stat(BOOKS_PATH)
 	if err != nil {
 		os.Mkdir(BOOKS_PATH, os.ModePerm)
@@ -132,27 +117,25 @@ func main() {
 		os.Mkdir(NEW_PATH, os.ModePerm)
 	}
 
-	http.HandleFunc("/book/", bookHandler(coll))
+	/* set up web handlers */
-	http.HandleFunc("/search/", searchHandler(coll))
+	http.HandleFunc("/book/", bookHandler)
-	http.HandleFunc("/upload/", uploadHandler(newColl))
+	http.HandleFunc("/search/", searchHandler)
-	http.HandleFunc("/login/", loginHandler(userColl))
+	http.HandleFunc("/upload/", uploadHandler)
+	http.HandleFunc("/login/", loginHandler)
 	http.HandleFunc("/logout/", logoutHandler)
-	http.HandleFunc("/new/", newHandler(newColl, coll))
+	http.HandleFunc("/new/", newHandler)
-	http.HandleFunc("/delnew/", deleteHandler(newColl, "/new/"))
+	http.HandleFunc("/store/", storeHandler)
-	http.HandleFunc("/store/", storeHandler(newColl, coll))
+	http.HandleFunc("/read/", readHandler)
-	http.HandleFunc("/read/", readHandler(coll))
+	http.HandleFunc("/content/", contentHandler)
-	http.HandleFunc("/content/", contentHandler(coll))
+	http.HandleFunc("/edit/", editHandler)
-	http.HandleFunc("/readnew/", readHandler(newColl))
+	http.HandleFunc("/save/", saveHandler)
-	http.HandleFunc("/contentnew/", contentHandler(newColl))
+	http.HandleFunc("/delete/", deleteHandler)
-	http.HandleFunc("/edit/", editHandler(coll))
-	http.HandleFunc("/save/", saveHandler(coll))
-	http.HandleFunc("/delete/", deleteHandler(coll, "/"))
 	http.HandleFunc("/about/", aboutHandler)
 	fileHandler("/img/")
 	fileHandler("/cover/")
 	fileHandler("/books/")
 	fileHandler("/css/")
 	fileHandler("/js/")
-	http.HandleFunc("/", indexHandler(coll))
+	http.HandleFunc("/", indexHandler)
 	panic(http.ListenAndServe(":"+PORT, nil))
 }

upload.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"git.gitorious.org/go-pkg/epub.git"
-	"labix.org/v2/mgo"
 	"net/http"
 	"os"
 	"os/exec"
@@ -198,7 +197,7 @@ func keywords(b map[string]interface{}) (k []string) {
 	return
 }
 
-func parseFile(coll *mgo.Collection, path string) (string, error) {
+func parseFile(path string) (string, error) {
 	book := map[string]interface{}{}
 
 	e, err := epub.Open(path, 0)
@@ -229,7 +228,7 @@ func parseFile(coll *mgo.Collection, path string) (string, error) {
 	book["coversmall"] = coverSmall
 	book["keywords"] = keywords(book)
 
-	coll.Insert(book)
+	db.InsertBook(book)
 	return title, nil
 }
 
@@ -237,8 +236,7 @@ type uploadData struct {
 	S Status
 }
 
-func uploadHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request) {
+func uploadHandler(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
 	if r.Method == "POST" {
 		sess := GetSession(r)
 		paths, err := storeFiles(r)
@@ -248,7 +246,7 @@ func uploadHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request
 
 		uploaded := ""
 		for _, path := range paths {
-				title, err := parseFile(coll, path)
+			title, err := parseFile(path)
 			if err != nil {
 				os.Remove(path)
 				sess.Notify("Problem uploading!", "The file '"+path[len("new/"):]+"' is not a well formed epub", "error")
@@ -265,5 +263,4 @@ func uploadHandler(coll *mgo.Collection) func(http.ResponseWriter, *http.Request
 	data.S = GetStatus(w, r)
 	data.S.Upload = true
 	loadTemplate(w, "upload", data)
-	}
 }