organise stuff better

file/download.go

@@ -1,56 +1 @@
 package file
-
-import (
-	"io"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path/filepath"
-
-	"github.com/mholt/archiver"
-)
-
-// DownloadAs creates an archieve in one of the supported formats (zip, tar,
-// tar.gz or tar.bz2) and sends it to be downloaded.
-func (i *Info) DownloadAs(w http.ResponseWriter, query string) (int, error) {
-	var (
-		extension string
-		temp      string
-		err       error
-		tempfile  string
-	)
-
-	temp, err = ioutil.TempDir("", "")
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-
-	defer os.RemoveAll(temp)
-	tempfile = filepath.Join(temp, "temp")
-
-	switch query {
-	case "zip":
-		extension, err = ".zip", archiver.Zip.Make(tempfile, []string{i.Path})
-	case "tar":
-		extension, err = ".tar", archiver.Tar.Make(tempfile, []string{i.Path})
-	case "targz":
-		extension, err = ".tar.gz", archiver.TarGz.Make(tempfile, []string{i.Path})
-	case "tarbz2":
-		extension, err = ".tar.bz2", archiver.TarBz2.Make(tempfile, []string{i.Path})
-	default:
-		return http.StatusNotImplemented, nil
-	}
-
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-
-	file, err := os.Open(temp + "/temp")
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-
-	w.Header().Set("Content-Disposition", "attachment; filename="+i.Name()+extension)
-	io.Copy(w, file)
-	return http.StatusOK, nil
-}

file/info.go

@@ -10,7 +10,6 @@ import (
 
 	humanize "github.com/dustin/go-humanize"
 	"github.com/hacdias/caddy-filemanager/config"
-	"github.com/hacdias/caddy-filemanager/page"
 	"github.com/hacdias/caddy-filemanager/utils"
 )
 
@@ -75,63 +74,6 @@ func (i Info) HumanModTime(format string) string {
 	return i.ModTime().Format(format)
 }
 
-func (i *Info) ServeHTTP(w http.ResponseWriter, r *http.Request, c *config.Config, u *config.User) (int, error) {
-	if i.IsDir() {
-		return i.serveListing(w, r, c, u)
-	}
-
-	return i.serveSingleFile(w, r, c, u)
-}
-
-func (i *Info) serveSingleFile(w http.ResponseWriter, r *http.Request, c *config.Config, u *config.User) (int, error) {
-	err := i.Read()
-	if err != nil {
-		code := http.StatusInternalServerError
-
-		switch {
-		case os.IsPermission(err):
-			code = http.StatusForbidden
-		case os.IsNotExist(err):
-			code = http.StatusGone
-		case os.IsExist(err):
-			code = http.StatusGone
-		}
-
-		return code, err
-	}
-
-	if i.Type == "blob" {
-		http.Redirect(
-			w, r,
-			c.AddrPath+r.URL.Path+"?download=true",
-			http.StatusTemporaryRedirect,
-		)
-		return 0, nil
-	}
-
-	p := &page.Page{
-		Info: &page.Info{
-			Name:   i.Name(),
-			Path:   i.VirtualPath,
-			IsDir:  false,
-			Data:   i,
-			User:   u,
-			Config: c,
-		},
-	}
-
-	if i.CanBeEdited() && u.AllowEdit {
-		p.Data, err = i.GetEditor()
-		if err != nil {
-			return http.StatusInternalServerError, err
-		}
-
-		return p.PrintAsHTML(w, "frontmatter", "editor")
-	}
-
-	return p.PrintAsHTML(w, "single")
-}
-
 func simplifyMediaType(name string) string {
 	if strings.HasPrefix(name, "video") {
 		return "video"

file/listing.go

@@ -1,16 +1,13 @@
 package file
 
 import (
-	"encoding/json"
-	"net/http"
 	"net/url"
 	"os"
 	"path"
+	"sort"
 	"strings"
 
 	"github.com/hacdias/caddy-filemanager/config"
-	"github.com/hacdias/caddy-filemanager/page"
-	"github.com/hacdias/caddy-filemanager/utils"
 
 	"github.com/mholt/caddy/caddyhttp/httpserver"
 )
@@ -19,7 +16,7 @@ import (
 type Listing struct {
 	// The name of the directory (the last element of the path)
 	Name string
-	// The full path of the request
+	// The full path of the request relatively to a File System
 	Path string
 	// The items (files and folders) in the path
 	Items []Info
@@ -36,76 +33,17 @@ type Listing struct {
 	httpserver.Context `json:"-"`
 }
 
-func (i *Info) serveListing(w http.ResponseWriter, r *http.Request, c *config.Config, u *config.User) (int, error) {
-	var err error
-
+// GetListing gets the information about a specific directory and its files.
+func GetListing(u *config.User, filePath string, baseURL string) (*Listing, error) {
 	// Gets the directory information using the Virtual File System of
-	// the user configuration
-	file, err := u.FileSystem.OpenFile(i.VirtualPath, os.O_RDONLY, 0)
+	// the user configuration.
+	file, err := u.FileSystem.OpenFile(filePath, os.O_RDONLY, 0)
 	if err != nil {
-		return utils.ErrorToHTTPCode(err, true), err
+		return nil, err
 	}
 	defer file.Close()
 
-	// Loads the content of the directory
-	listing, err := i.loadDirectoryContents(file, r.URL.Path, u)
-	if err != nil {
-		return utils.ErrorToHTTPCode(err, true), err
-	}
-
-	listing.Context = httpserver.Context{
-		Root: http.Dir(u.Scope),
-		Req:  r,
-		URL:  r.URL,
-	}
-
-	// Copy the query values into the Listing struct
-	var limit int
-	listing.Sort, listing.Order, limit, err = handleSortOrder(w, r, c.Scope)
-	if err != nil {
-		return http.StatusBadRequest, err
-	}
-
-	listing.applySort()
-
-	if limit > 0 && limit <= len(listing.Items) {
-		listing.Items = listing.Items[:limit]
-		listing.ItemsLimitedTo = limit
-	}
-
-	if strings.Contains(r.Header.Get("Accept"), "application/json") {
-		marsh, err := json.Marshal(listing.Items)
-		if err != nil {
-			return http.StatusInternalServerError, err
-		}
-
-		w.Header().Set("Content-Type", "application/json; charset=utf-8")
-		if _, err := w.Write(marsh); err != nil {
-			return http.StatusInternalServerError, err
-		}
-
-		return http.StatusOK, nil
-	}
-
-	page := &page.Page{
-		Info: &page.Info{
-			Name:   listing.Name,
-			Path:   i.VirtualPath,
-			IsDir:  true,
-			User:   u,
-			Config: c,
-			Data:   listing,
-		},
-	}
-
-	if r.Header.Get("Minimal") == "true" {
-		page.Minimal = true
-	}
-
-	return page.PrintAsHTML(w, "listing")
-}
-
-func (i Info) loadDirectoryContents(file http.File, basePath string, u *config.User) (*Listing, error) {
+	// Reads the directory and gets the information about the files.
 	files, err := file.Readdir(-1)
 	if err != nil {
 		return nil, err
@@ -127,19 +65,108 @@ func (i Info) loadDirectoryContents(file http.File, basePath string, u *config.U
 		}
 
 		// Absolute URL
-		url := url.URL{Path: basePath + name}
+		url := url.URL{Path: baseURL + name}
 		fileinfos = append(fileinfos, Info{
 			FileInfo:    f,
 			URL:         url.String(),
-			UserAllowed: u.Allowed(i.VirtualPath),
+			UserAllowed: u.Allowed(filePath),
 		})
 	}
 
 	return &Listing{
-		Name:     path.Base(i.VirtualPath),
-		Path:     i.VirtualPath,
+		Name:     path.Base(filePath),
+		Path:     filePath,
 		Items:    fileinfos,
 		NumDirs:  dirCount,
 		NumFiles: fileCount,
 	}, nil
 }
+
+// ApplySort applies the sort order using .Order and .Sort
+func (l Listing) ApplySort() {
+	// Check '.Order' to know how to sort
+	if l.Order == "desc" {
+		switch l.Sort {
+		case "name":
+			sort.Sort(sort.Reverse(byName(l)))
+		case "size":
+			sort.Sort(sort.Reverse(bySize(l)))
+		case "time":
+			sort.Sort(sort.Reverse(byTime(l)))
+		default:
+			// If not one of the above, do nothing
+			return
+		}
+	} else { // If we had more Orderings we could add them here
+		switch l.Sort {
+		case "name":
+			sort.Sort(byName(l))
+		case "size":
+			sort.Sort(bySize(l))
+		case "time":
+			sort.Sort(byTime(l))
+		default:
+			sort.Sort(byName(l))
+			return
+		}
+	}
+}
+
+// Implement sorting for Listing
+type byName Listing
+type bySize Listing
+type byTime Listing
+
+// By Name
+func (l byName) Len() int {
+	return len(l.Items)
+}
+
+func (l byName) Swap(i, j int) {
+	l.Items[i], l.Items[j] = l.Items[j], l.Items[i]
+}
+
+// Treat upper and lower case equally
+func (l byName) Less(i, j int) bool {
+	if l.Items[i].IsDir() && !l.Items[j].IsDir() {
+		return true
+	}
+
+	if !l.Items[i].IsDir() && l.Items[j].IsDir() {
+		return false
+	}
+
+	return strings.ToLower(l.Items[i].Name()) < strings.ToLower(l.Items[j].Name())
+}
+
+// By Size
+func (l bySize) Len() int {
+	return len(l.Items)
+}
+
+func (l bySize) Swap(i, j int) {
+	l.Items[i], l.Items[j] = l.Items[j], l.Items[i]
+}
+
+const directoryOffset = -1 << 31 // = math.MinInt32
+func (l bySize) Less(i, j int) bool {
+	iSize, jSize := l.Items[i].Size(), l.Items[j].Size()
+	if l.Items[i].IsDir() {
+		iSize = directoryOffset + iSize
+	}
+	if l.Items[j].IsDir() {
+		jSize = directoryOffset + jSize
+	}
+	return iSize < jSize
+}
+
+// By Time
+func (l byTime) Len() int {
+	return len(l.Items)
+}
+func (l byTime) Swap(i, j int) {
+	l.Items[i], l.Items[j] = l.Items[j], l.Items[i]
+}
+func (l byTime) Less(i, j int) bool {
+	return l.Items[i].ModTime().Before(l.Items[j].ModTime())
+}

file/listing_sort.go

@@ -1,148 +0,0 @@
-package file
-
-import (
-	"net/http"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-// handleSortOrder gets and stores for a Listing the 'sort' and 'order',
-// and reads 'limit' if given. The latter is 0 if not given. Sets cookies.
-func handleSortOrder(w http.ResponseWriter, r *http.Request, scope string) (sort string, order string, limit int, err error) {
-	sort = r.URL.Query().Get("sort")
-	order = r.URL.Query().Get("order")
-	limitQuery := r.URL.Query().Get("limit")
-
-	// If the query 'sort' or 'order' is empty, use defaults or any values
-	// previously saved in Cookies.
-	switch sort {
-	case "":
-		sort = "name"
-		if sortCookie, sortErr := r.Cookie("sort"); sortErr == nil {
-			sort = sortCookie.Value
-		}
-	case "name", "size", "type":
-		http.SetCookie(w, &http.Cookie{
-			Name:   "sort",
-			Value:  sort,
-			Path:   scope,
-			Secure: r.TLS != nil,
-		})
-	}
-
-	switch order {
-	case "":
-		order = "asc"
-		if orderCookie, orderErr := r.Cookie("order"); orderErr == nil {
-			order = orderCookie.Value
-		}
-	case "asc", "desc":
-		http.SetCookie(w, &http.Cookie{
-			Name:   "order",
-			Value:  order,
-			Path:   scope,
-			Secure: r.TLS != nil,
-		})
-	}
-
-	if limitQuery != "" {
-		limit, err = strconv.Atoi(limitQuery)
-		// If the 'limit' query can't be interpreted as a number, return err.
-		if err != nil {
-			return
-		}
-	}
-
-	return
-}
-
-// Add sorting method to "Listing"
-// it will apply what's in ".Sort" and ".Order"
-func (l Listing) applySort() {
-	// Check '.Order' to know how to sort
-	if l.Order == "desc" {
-		switch l.Sort {
-		case "name":
-			sort.Sort(sort.Reverse(byName(l)))
-		case "size":
-			sort.Sort(sort.Reverse(bySize(l)))
-		case "time":
-			sort.Sort(sort.Reverse(byTime(l)))
-		default:
-			// If not one of the above, do nothing
-			return
-		}
-	} else { // If we had more Orderings we could add them here
-		switch l.Sort {
-		case "name":
-			sort.Sort(byName(l))
-		case "size":
-			sort.Sort(bySize(l))
-		case "time":
-			sort.Sort(byTime(l))
-		default:
-			sort.Sort(byName(l))
-			return
-		}
-	}
-}
-
-// Implement sorting for Listing
-type byName Listing
-type bySize Listing
-type byTime Listing
-
-// By Name
-func (l byName) Len() int {
-	return len(l.Items)
-}
-
-func (l byName) Swap(i, j int) {
-	l.Items[i], l.Items[j] = l.Items[j], l.Items[i]
-}
-
-// Treat upper and lower case equally
-func (l byName) Less(i, j int) bool {
-	if l.Items[i].IsDir() && !l.Items[j].IsDir() {
-		return true
-	}
-
-	if !l.Items[i].IsDir() && l.Items[j].IsDir() {
-		return false
-	}
-
-	return strings.ToLower(l.Items[i].Name()) < strings.ToLower(l.Items[j].Name())
-}
-
-// By Size
-func (l bySize) Len() int {
-	return len(l.Items)
-}
-
-func (l bySize) Swap(i, j int) {
-	l.Items[i], l.Items[j] = l.Items[j], l.Items[i]
-}
-
-const directoryOffset = -1 << 31 // = math.MinInt32
-func (l bySize) Less(i, j int) bool {
-	iSize, jSize := l.Items[i].Size(), l.Items[j].Size()
-	if l.Items[i].IsDir() {
-		iSize = directoryOffset + iSize
-	}
-	if l.Items[j].IsDir() {
-		jSize = directoryOffset + jSize
-	}
-	return iSize < jSize
-}
-
-// By Time
-func (l byTime) Len() int {
-	return len(l.Items)
-}
-func (l byTime) Swap(i, j int) {
-	l.Items[i], l.Items[j] = l.Items[j], l.Items[i]
-}
-func (l byTime) Less(i, j int) bool {
-	return l.Items[i].ModTime().Before(l.Items[j].ModTime())
-}