Start refactoring to make code cleaner

OLD/listing.go

@@ -0,0 +1,172 @@
+package filemanager
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+	"github.com/mholt/caddy/caddyhttp/staticfiles"
+)
+
+// A Listing is the context used to fill out a template.
+type Listing struct {
+	// The name of the directory (the last element of the path)
+	Name string
+
+	// The full path of the request
+	Path string
+
+	// Whether the parent directory is browsable
+	CanGoUp bool
+
+	// The items (files and folders) in the path
+	Items []FileInfo
+
+	// The number of directories in the listing
+	NumDirs int
+
+	// The number of files (items that aren't directories) in the listing
+	NumFiles int
+
+	// Which sorting order is used
+	Sort string
+
+	// And which order
+	Order string
+
+	// If ≠0 then Items have been limited to that many elements
+	ItemsLimitedTo int
+
+	// Optional custom variables for use in browse templates
+	User interface{}
+
+	httpserver.Context
+}
+
+func (f FileManager) loadDirectoryContents(requestedFilepath http.File, urlPath string) (*Listing, bool, error) {
+	files, err := requestedFilepath.Readdir(-1)
+	if err != nil {
+		return nil, false, err
+	}
+
+	// Determine if user can browse up another folder
+	// TODO: review this
+	var canGoUp bool
+	curPathDir := path.Dir(strings.TrimSuffix(urlPath, "/"))
+	for _, other := range f.Configs {
+		if strings.HasPrefix(curPathDir, other.PathScope) {
+			canGoUp = true
+			break
+		}
+	}
+
+	// Assemble listing of directory contents
+	listing, _ := directoryListing(files, canGoUp, urlPath)
+	return &listing, false, nil
+}
+
+// ServeListing returns a formatted view of 'requestedFilepath' contents'.
+func (f FileManager) ServeListing(w http.ResponseWriter, r *http.Request, requestedFilepath http.File, bc *Config) (int, error) {
+	listing, containsIndex, err := f.loadDirectoryContents(requestedFilepath, r.URL.Path)
+	if err != nil {
+		fmt.Println(err)
+		switch {
+		case os.IsPermission(err):
+			return http.StatusForbidden, err
+		case os.IsExist(err):
+			return http.StatusGone, err
+		default:
+			return http.StatusInternalServerError, err
+		}
+	}
+
+	if containsIndex && !f.IgnoreIndexes { // directory isn't browsable
+		return f.Next.ServeHTTP(w, r)
+	}
+	listing.Context = httpserver.Context{
+		Root: bc.Root,
+		Req:  r,
+		URL:  r.URL,
+	}
+	listing.User = bc.Variables
+
+	// Copy the query values into the Listing struct
+	var limit int
+	listing.Sort, listing.Order, limit, err = f.handleSortOrder(w, r, bc.PathScope)
+	if err != nil {
+		return http.StatusBadRequest, err
+	}
+
+	listing.applySort()
+
+	if limit > 0 && limit <= len(listing.Items) {
+		listing.Items = listing.Items[:limit]
+		listing.ItemsLimitedTo = limit
+	}
+
+	acceptHeader := strings.ToLower(strings.Join(r.Header["Accept"], ","))
+
+	page := &Page{
+		Info: &PageInfo{
+			Name: listing.Name,
+			Path: listing.Path,
+			Data: listing,
+		},
+	}
+
+	if strings.Contains(acceptHeader, "application/json") {
+		return page.PrintAsJSON(w)
+	}
+
+	return page.PrintAsHTML(w, "listing")
+}
+
+func directoryListing(files []os.FileInfo, canGoUp bool, urlPath string) (Listing, bool) {
+	var (
+		fileinfos           []FileInfo
+		dirCount, fileCount int
+		hasIndexFile        bool
+	)
+
+	for _, f := range files {
+		name := f.Name()
+
+		for _, indexName := range staticfiles.IndexPages {
+			if name == indexName {
+				hasIndexFile = true
+				break
+			}
+		}
+
+		if f.IsDir() {
+			name += "/"
+			dirCount++
+		} else {
+			fileCount++
+		}
+
+		url := url.URL{Path: "./" + name} // prepend with "./" to fix paths with ':' in the name
+
+		fileinfos = append(fileinfos, FileInfo{
+			IsDir:   f.IsDir(),
+			Name:    f.Name(),
+			Size:    f.Size(),
+			URL:     url.String(),
+			ModTime: f.ModTime().UTC(),
+			Mode:    f.Mode(),
+		})
+	}
+
+	return Listing{
+		Name:     path.Base(urlPath),
+		Path:     urlPath,
+		CanGoUp:  canGoUp,
+		Items:    fileinfos,
+		NumDirs:  dirCount,
+		NumFiles: fileCount,
+	}, hasIndexFile
+}

OLD/page.go

@@ -0,0 +1,100 @@
+package filemanager
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+	"strings"
+	"text/template"
+)
+
+// PageInfo contains the information of a page
+type PageInfo struct {
+	Name string
+	Path string
+	Data interface{}
+}
+
+// BreadcrumbMap returns p.Path where every element is a map
+// of URLs and path segment names.
+func (p PageInfo) BreadcrumbMap() map[string]string {
+	result := map[string]string{}
+
+	if len(p.Path) == 0 {
+		return result
+	}
+
+	// skip trailing slash
+	lpath := p.Path
+	if lpath[len(lpath)-1] == '/' {
+		lpath = lpath[:len(lpath)-1]
+	}
+
+	parts := strings.Split(lpath, "/")
+	for i, part := range parts {
+		if i == 0 && part == "" {
+			// Leading slash (root)
+			result["/"] = "/"
+			continue
+		}
+		result[strings.Join(parts[:i+1], "/")] = part
+	}
+
+	return result
+}
+
+// Page contains the informations and functions needed to show the page
+type Page struct {
+	Info *PageInfo
+}
+
+// PrintAsHTML formats the page in HTML and executes the template
+func (p Page) PrintAsHTML(w http.ResponseWriter, templates ...string) (int, error) {
+	templates = append(templates, "base")
+	var tpl *template.Template
+
+	// For each template, add it to the the tpl variable
+	for i, t := range templates {
+		// Get the template from the assets
+		page, err := Asset("templates/" + t + ".tmpl")
+
+		// Check if there is some error. If so, the template doesn't exist
+		if err != nil {
+			log.Print(err)
+			return http.StatusInternalServerError, err
+		}
+
+		// If it's the first iteration, creates a new template and add the
+		// functions map
+		if i == 0 {
+			tpl, err = template.New(t).Parse(string(page))
+		} else {
+			tpl, err = tpl.Parse(string(page))
+		}
+
+		if err != nil {
+			log.Print(err)
+			return http.StatusInternalServerError, err
+		}
+	}
+
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	err := tpl.Execute(w, p.Info)
+
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+
+	return http.StatusOK, nil
+}
+
+// PrintAsJSON prints the current page infromation in JSON
+func (p Page) PrintAsJSON(w http.ResponseWriter) (int, error) {
+	marsh, err := json.Marshal(p.Info.Data)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	return w.Write(marsh)
+}

OLD/single.go

@@ -0,0 +1,67 @@
+package filemanager
+
+import (
+	"encoding/base64"
+	"html"
+	"io/ioutil"
+	"mime"
+	"net/http"
+	"path/filepath"
+	"regexp"
+)
+
+var (
+	videoRegex = regexp.MustCompile("video[/]")
+	audioRegex = regexp.MustCompile("audio[/]")
+	imageRegex = regexp.MustCompile("image[/]")
+)
+
+type File struct {
+	*FileInfo
+	Content string
+}
+
+// ServeSingleFile redirects the request for the respective method
+func (f FileManager) ServeSingleFile(w http.ResponseWriter, r *http.Request, file *InfoRequest, c *Config) (int, error) {
+	fullpath := c.PathScope + file.Path
+	fullpath = filepath.Clean(fullpath)
+
+	raw, err := ioutil.ReadFile(fullpath)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+
+	base := base64.StdEncoding.EncodeToString(raw)
+	mimetype := mime.TypeByExtension(filepath.Ext(file.Path))
+	data := "data:" + mimetype + ";base64," + base
+
+	page := &Page{
+		Info: &PageInfo{
+			Name: file.Path,
+			Path: file.Path,
+			Data: map[string]string{
+				"Type":    RetrieveContentType(mimetype),
+				"Base64":  data,
+				"Content": html.EscapeString(string(raw)),
+			},
+		},
+	}
+
+	return page.PrintAsHTML(w, "single")
+}
+
+func RetrieveContentType(name string) string {
+	if videoRegex.FindString(name) != "" {
+		return "video"
+	}
+
+	if audioRegex.FindString(name) != "" {
+		return "audio"
+	}
+
+	if imageRegex.FindString(name) != "" {
+		return "image"
+	}
+
+	return "text"
+}

OLD/sort.go

@@ -0,0 +1,112 @@
+package filemanager
+
+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.
+//
+// This sets Cookies.
+func (f FileManager) handleSortOrder(w http.ResponseWriter, r *http.Request, scope string) (sort string, order string, limit int, err error) {
+	sort, order, limitQuery := r.URL.Query().Get("sort"), r.URL.Query().Get("order"), 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 err != nil { // if the 'limit' query can't be interpreted as a number, return err
+			return
+		}
+	}
+
+	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 {
+	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) }
+
+// 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:
+			// If not one of the above, do nothing
+			return
+		}
+	}
+}