github
/
filebrowser
mirror of https://github.com/filebrowser/filebrowser
1
0
Fork 0
Code Issues Releases Wiki Activity

some updates

pull/144/head
Henrique Dias 2016-06-11 10:08:33 +01:00
parent 9b25214272
commit 4163aeae40
6 changed files with 256 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
assets/templates/base.tmpl
View File

@ -3,76 +3,19 @@
<head>
<title>{{.Name}}</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="/_filemanager_internal/styles.css">
<link rel="stylesheet" href="/_filemanagerinternal/css/styles.css">
<style>
{{ .StyleSheet }}
</style>
</head>
<body>
<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" height="0" width="0" style="position: absolute;">
<defs>
<!-- Folder -->
<linearGradient id="f" y2="640" gradientUnits="userSpaceOnUse" x2="244.84" gradientTransform="matrix(.97319 0 0 1.0135 -.50695 -13.679)" y1="415.75" x1="244.84">
<stop stop-color="#b3ddfd" offset="0"/>
<stop stop-color="#69c" offset="1"/>
</linearGradient>
<linearGradient id="e" y2="571.06" gradientUnits="userSpaceOnUse" x2="238.03" gradientTransform="translate(0,2)" y1="346.05" x1="236.26">
<stop stop-color="#ace" offset="0"/>
<stop stop-color="#369" offset="1"/>
</linearGradient>
<g id="folder" transform="translate(-266.06 -193.36)">
<g transform="matrix(.066019 0 0 .066019 264.2 170.93)">
<g transform="matrix(1.4738 0 0 1.4738 -52.053 -166.93)">
<path fill="#69c" d="m98.424 343.78c-11.08 0-20 8.92-20 20v48.5 33.719 105.06c0 11.08 8.92 20 20 20h279.22c11.08 0 20-8.92 20-20v-138.78c0-11.08-8.92-20-20-20h-117.12c-7.5478-1.1844-9.7958-6.8483-10.375-11.312v-5.625-11.562c0-11.08-8.92-20-20-20h-131.72z"/>
<rect rx="12.885" ry="12.199" height="227.28" width="366.69" y="409.69" x="54.428" fill="#369"/>
<path fill="url(#e)" d="m98.424 345.78c-11.08 0-20 8.92-20 20v48.5 33.719 105.06c0 11.08 8.92 20 20 20h279.22c11.08 0 20-8.92 20-20v-138.78c0-11.08-8.92-20-20-20h-117.12c-7.5478-1.1844-9.7958-6.8483-10.375-11.312v-5.625-11.562c0-11.08-8.92-20-20-20h-131.72z"/>
<rect rx="12.885" ry="12.199" height="227.28" width="366.69" y="407.69" x="54.428" fill="url(#f)"/>
</g>
</g>
</g>
<!-- File -->
<linearGradient id="a">
<stop stop-color="#cbcbcb" offset="0"/>
<stop stop-color="#f0f0f0" offset=".34923"/>
<stop stop-color="#e2e2e2" offset="1"/>
</linearGradient>
<linearGradient id="d" y2="686.15" xlink:href="#a" gradientUnits="userSpaceOnUse" y1="207.83" gradientTransform="matrix(.28346 0 0 .31053 -608.52 485.11)" x2="380.1" x1="749.25"/>
<linearGradient id="c" y2="287.74" xlink:href="#a" gradientUnits="userSpaceOnUse" y1="169.44" gradientTransform="matrix(.28342 0 0 .31057 -608.52 485.11)" x2="622.33" x1="741.64"/>
<linearGradient id="b" y2="418.54" gradientUnits="userSpaceOnUse" y1="236.13" gradientTransform="matrix(.29343 0 0 .29999 -608.52 485.11)" x2="330.88" x1="687.96">
<stop stop-color="#fff" offset="0"/>
<stop stop-color="#fff" stop-opacity="0" offset="1"/>
</linearGradient>
<g id="file" transform="translate(-278.15 -216.59)">
<g fill-rule="evenodd" transform="matrix(.19775 0 0 .19775 381.05 112.68)">
<path d="m-520.17 525.5v36.739 36.739 36.739 36.739h33.528 33.528 33.528 33.528v-36.739-36.739-36.739l-33.528-36.739h-33.528-33.528-33.528z" stroke-opacity=".36478" stroke-width=".42649" fill="#fff"/>
<g>
<path d="m-520.11 525.68v36.739 36.739 36.739 36.739h33.528 33.528 33.528 33.528v-36.739-36.739-36.739l-33.528-36.739h-33.528-33.528-33.528z" stroke-opacity=".36478" stroke="#000" stroke-width=".42649" fill="url(#d)"/>
<path d="m-386 562.42c-10.108-2.9925-23.206-2.5682-33.101-0.86253 1.7084-10.962 1.922-24.701-0.4271-35.877l33.528 36.739z" stroke-width=".95407pt" fill="url(#c)"/>
<path d="m-519.13 537-0.60402 134.7h131.68l0.0755-33.296c-2.9446 1.1325-32.692-40.998-70.141-39.186-37.483 1.8137-27.785-56.777-61.006-62.214z" stroke-width="1pt" fill="url(#b)"/>
</g>
</g>
</g>
<!-- Up arrow -->
<g id="up-arrow" transform="translate(-279.22 -208.12)">
<path transform="matrix(.22413 0 0 .12089 335.67 164.35)" stroke-width="0" d="m-194.17 412.01h-28.827-28.827l14.414-24.965 14.414-24.965 14.414 24.965z"/>
</g>
<!-- Down arrow -->
<g id="down-arrow" transform="translate(-279.22 -208.12)">
<path transform="matrix(.22413 0 0 -.12089 335.67 257.93)" stroke-width="0" d="m-194.17 412.01h-28.827-28.827l14.414-24.965 14.414-24.965 14.414 24.965z"/>
</g>
</defs>
</svg>
<header>
<h1>
{{range $url, $name := .BreadcrumbMap}}<a href="{{$url}}">{{$name}}</a>{{if ne $url "/"}}/{{end}}{{end}}
</h1>
</header>
<main>
{{ template "content" .Listing }}
{{ template "content" .Data }}
</main>
<footer>
Served with <a rel="noopener noreferrer" href="https://caddyserver.com">Caddy</a>.

31
delete.go Normal file
View File

@ -0,0 +1,31 @@
package filemanager
import (
"net/http"
"os"
)
// Delete handles the delete requests
func Delete(path string, info os.FileInfo) (int, error) {
var err error
// If it's dir, remove all of the content inside
if info.IsDir() {
err = os.RemoveAll(path)
} else {
err = os.Remove(path)
}
// Check for errors
if err != nil {
switch {
case os.IsPermission(err):
return http.StatusForbidden, err
case os.IsExist(err):
return http.StatusGone, err
default:
return http.StatusInternalServerError, err
}
}
return http.StatusOK, nil
}

214
filemanager.go
View File

@ -9,20 +9,13 @@
package filemanager
import (
"bytes"
"encoding/json"
"net/http"
"os"
"path"
"strings"
"text/template"
"github.com/mholt/caddy/caddyhttp/httpserver"
)
// Template used to show FileManager
var Template *template.Template
// FileManager is an http.Handler that can show a file listing when
// directories in the given paths are specified.
type FileManager struct {
@ -43,158 +36,105 @@ type Config struct {
// ServeHTTP determines if the request is for this plugin, and if all prerequisites are met.
// If so, control is handed over to ServeListing.
func (f FileManager) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
var fmc *Config
var c *Config
var file *InfoRequest
// See if there's a browse configuration to match the path
// Check if there is a FileManager configuration to match the path
for i := range f.Configs {
if httpserver.Path(r.URL.Path).Matches(f.Configs[i].BaseURL) {
fmc = &f.Configs[i]
c = &f.Configs[i]
// Serve Assets
if httpserver.Path(r.URL.Path).Matches(fmc.BaseURL + "/_filemanagerinternal") {
return ServeAssets(w, r, fmc)
// Serve assets
if httpserver.Path(r.URL.Path).Matches(c.BaseURL + "/_filemanagerinternal") {
return ServeAssets(w, r, c)
}
// Browse works on existing directories; delegate everything else
requestedFilepath, err := fmc.Root.Open(strings.Replace(r.URL.Path, fmc.BaseURL, "", 1))
if err != nil {
switch {
case os.IsPermission(err):
return http.StatusForbidden, err
case os.IsExist(err):
return http.StatusNotFound, err
default:
return f.Next.ServeHTTP(w, r)
// Gets the file path to be used within c.Root
filepath := strings.Replace(r.URL.Path, c.BaseURL, "", 1)
if r.Method != http.MethodPost {
file = GetFileInfo(filepath, c)
if file.Err != nil {
defer file.File.Close()
return file.Code, file.Err
}
if file.Info.IsDir() && !strings.HasSuffix(r.URL.Path, "/") {
http.Redirect(w, r, r.URL.Path+"/", http.StatusTemporaryRedirect)
return 0, nil
}
}
defer requestedFilepath.Close()
info, err := requestedFilepath.Stat()
if err != nil {
switch {
case os.IsPermission(err):
return http.StatusForbidden, err
case os.IsExist(err):
return http.StatusGone, err
default:
return f.Next.ServeHTTP(w, r)
}
}
if !info.IsDir() {
return f.Next.ServeHTTP(w, r)
}
// Do not reply to anything else because it might be nonsensical
// Route the request depending on the HTTP Method
switch r.Method {
case http.MethodGet, http.MethodHead:
// proceed, noop
case "PROPFIND", http.MethodOptions:
return http.StatusNotImplemented, nil
case http.MethodGet:
// Read and show directory or file
if file.Info.IsDir() {
return f.ServeListing(w, r, file.File, c)
}
return f.ServeSingleFile(w, r, file.File, c)
case http.MethodPost:
// Create new file or directory
return http.StatusOK, nil
case http.MethodDelete:
// Delete a file or a directory
return Delete(filepath, file.Info)
case http.MethodPut:
// Update/Modify a directory or file
return http.StatusOK, nil
case http.MethodPatch:
// Rename a file or directory
return http.StatusOK, nil
default:
return f.Next.ServeHTTP(w, r)
return http.StatusNotImplemented, nil
}
// Browsing navigation gets messed up if browsing a directory
// that doesn't end in "/" (which it should, anyway)
if !strings.HasSuffix(r.URL.Path, "/") {
http.Redirect(w, r, r.URL.Path+"/", http.StatusTemporaryRedirect)
return 0, nil
}
return f.ServeListing(w, r, requestedFilepath, fmc)
}
}
return f.Next.ServeHTTP(w, r)
}
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
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, hasIndex := directoryListing(files, canGoUp, urlPath)
return &listing, hasIndex, nil
// InfoRequest is the information given by a GetFileInfo function
type InfoRequest struct {
Info os.FileInfo
File http.File
Code int
Err error
}
// 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 {
// GetFileInfo gets the file information and, in case of error, returns the
// respective HTTP error code
func GetFileInfo(path string, c *Config) *InfoRequest {
request := &InfoRequest{}
request.File, request.Err = c.Root.Open(path)
if request.Err != nil {
switch {
case os.IsPermission(err):
return http.StatusForbidden, err
case os.IsExist(err):
return http.StatusGone, err
case os.IsPermission(request.Err):
request.Code = http.StatusForbidden
case os.IsExist(request.Err):
request.Code = http.StatusNotFound
default:
return http.StatusInternalServerError, err
request.Code = http.StatusInternalServerError
}
return request
}
request.Info, request.Err = request.File.Stat()
if request.Err != nil {
switch {
case os.IsPermission(request.Err):
request.Code = http.StatusForbidden
case os.IsExist(request.Err):
request.Code = http.StatusGone
default:
request.Code = http.StatusInternalServerError
}
}
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
}
var buf *bytes.Buffer
acceptHeader := strings.ToLower(strings.Join(r.Header["Accept"], ","))
switch {
case strings.Contains(acceptHeader, "application/json"):
if buf, err = f.formatAsJSON(listing, bc); err != nil {
return http.StatusInternalServerError, err
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
default: // There's no 'application/json' in the 'Accept' header; browse normally
if buf, err = f.formatAsHTML(listing, bc, "listing"); err != nil {
return http.StatusInternalServerError, err
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
}
buf.WriteTo(w)
return http.StatusOK, nil
}
func (f FileManager) formatAsJSON(listing *Listing, bc *Config) (*bytes.Buffer, error) {
marsh, err := json.Marshal(listing.Items)
if err != nil {
return nil, err
}
buf := new(bytes.Buffer)
_, err = buf.Write(marsh)
return buf, err
return request
}

133
listing.go
View File

@ -1,6 +1,10 @@
package filemanager
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"net/url"
"os"
"path"
@ -42,12 +46,107 @@ type Listing struct {
// Optional custom variables for use in browse templates
User interface{}
// StyleSheet to costumize the page
StyleSheet string
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, hasIndex := directoryListing(files, canGoUp, urlPath)
return &listing, hasIndex, 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
}
var buf *bytes.Buffer
acceptHeader := strings.ToLower(strings.Join(r.Header["Accept"], ","))
if strings.Contains(acceptHeader, "application/json") {
if buf, err = f.formatAsJSON(listing, bc); err != nil {
return http.StatusInternalServerError, err
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
} else {
page := &Page{
Name: listing.Name,
Path: listing.Path,
Config: bc,
Data: listing,
}
if buf, err = f.formatAsHTML(page, "listing"); err != nil {
return http.StatusInternalServerError, err
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
}
buf.WriteTo(w)
return http.StatusOK, nil
}
func (f FileManager) formatAsJSON(listing *Listing, bc *Config) (*bytes.Buffer, error) {
marsh, err := json.Marshal(listing.Items)
if err != nil {
return nil, err
}
buf := new(bytes.Buffer)
_, err = buf.Write(marsh)
return buf, err
}
func directoryListing(files []os.FileInfo, canGoUp bool, urlPath string) (Listing, bool) {
var (
fileinfos []FileInfo
@ -93,31 +192,3 @@ func directoryListing(files []os.FileInfo, canGoUp bool, urlPath string) (Listin
NumFiles: fileCount,
}, hasIndexFile
}
// BreadcrumbMap returns l.Path where every element is a map
// of URLs and path segment names.
func (l Listing) BreadcrumbMap() map[string]string {
result := map[string]string{}
if len(l.Path) == 0 {
return result
}
// skip trailing slash
lpath := l.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
}

39
page.go
View File

@ -4,19 +4,18 @@ import (
"bytes"
"html/template"
"log"
"strings"
)
type Page struct {
Name string
Path string
Config *Config
Data interface{}
}
func (f FileManager) formatAsHTML(data interface{}, fmc *Config, templates ...string) (*bytes.Buffer, error) {
func (f FileManager) formatAsHTML(page *Page, templates ...string) (*bytes.Buffer, error) {
buf := new(bytes.Buffer)
pg := &Page{
Config: fmc,
Data: data,
}
templates = append(templates, "base")
var tpl *template.Template
@ -46,6 +45,34 @@ func (f FileManager) formatAsHTML(data interface{}, fmc *Config, templates ...st
}
}
err := Template.Execute(buf, pg)
err := tpl.Execute(buf, page)
return buf, err
}
// BreadcrumbMap returns p.Path where every element is a map
// of URLs and path segment names.
func (p Page) 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
}

10
single.go Normal file
View File

@ -0,0 +1,10 @@
package filemanager
import "net/http"
// ServeSingleFile redirects the request for the respective method
func (f FileManager) ServeSingleFile(w http.ResponseWriter, r *http.Request, file http.File, c *Config) (int, error) {
w.Header().Set("Content-Type", "text/plain")
w.Write([]byte("Hello"))
return 200, nil
}