Henrique Dias
parent
b0e81a80a0
commit
850c4a10e1
|
|
@ -0,0 +1,120 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"net/http"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"github.com/hacdias/filemanager/frontmatter"
|
||||
"github.com/spf13/hugo/parser"
|
||||
)
|
||||
|
||||
// Editor contains the information for the editor page
|
||||
type Editor struct {
|
||||
Class string
|
||||
Mode string
|
||||
Visual bool
|
||||
Content string
|
||||
FrontMatter struct {
|
||||
Content *frontmatter.Content
|
||||
Rune rune
|
||||
}
|
||||
}
|
||||
|
||||
// GetEditor gets the editor based on a Info struct
|
||||
func GetEditor(r *http.Request, i *FileInfo) (*Editor, error) {
|
||||
var err error
|
||||
|
||||
// Create a new editor variable and set the mode
|
||||
e := new(Editor)
|
||||
e.Mode = editorMode(i.Name)
|
||||
e.Class = editorClass(e.Mode)
|
||||
|
||||
if e.Class == "frontmatter-only" || e.Class == "complete" {
|
||||
e.Visual = true
|
||||
}
|
||||
|
||||
if r.URL.Query().Get("visual") == "false" {
|
||||
e.Class = "content-only"
|
||||
}
|
||||
|
||||
hasRune := frontmatter.HasRune(i.content)
|
||||
|
||||
if e.Class == "frontmatter-only" && !hasRune {
|
||||
e.FrontMatter.Rune, err = frontmatter.StringFormatToRune(e.Mode)
|
||||
if err != nil {
|
||||
goto Error
|
||||
}
|
||||
i.content = frontmatter.AppendRune(i.content, e.FrontMatter.Rune)
|
||||
hasRune = true
|
||||
}
|
||||
|
||||
if e.Class == "frontmatter-only" && hasRune {
|
||||
e.FrontMatter.Content, _, err = frontmatter.Pretty(i.content)
|
||||
if err != nil {
|
||||
goto Error
|
||||
}
|
||||
}
|
||||
|
||||
if e.Class == "complete" && hasRune {
|
||||
var page parser.Page
|
||||
// Starts a new buffer and parses the file using Hugo's functions
|
||||
buffer := bytes.NewBuffer(i.content)
|
||||
page, err = parser.ReadFrom(buffer)
|
||||
|
||||
if err != nil {
|
||||
goto Error
|
||||
}
|
||||
|
||||
// Parses the page content and the frontmatter
|
||||
e.Content = strings.TrimSpace(string(page.Content()))
|
||||
e.FrontMatter.Rune = rune(i.content[0])
|
||||
e.FrontMatter.Content, _, err = frontmatter.Pretty(page.FrontMatter())
|
||||
}
|
||||
|
||||
if e.Class == "complete" && !hasRune {
|
||||
err = errors.New("Complete but without rune")
|
||||
}
|
||||
|
||||
Error:
|
||||
if e.Class == "content-only" || err != nil {
|
||||
e.Class = "content-only"
|
||||
e.Content = i.StringifyContent()
|
||||
}
|
||||
|
||||
return e, nil
|
||||
}
|
||||
|
||||
func editorClass(mode string) string {
|
||||
switch mode {
|
||||
case "json", "toml", "yaml":
|
||||
return "frontmatter-only"
|
||||
case "markdown", "asciidoc", "rst":
|
||||
return "complete"
|
||||
}
|
||||
|
||||
return "content-only"
|
||||
}
|
||||
|
||||
func editorMode(filename string) string {
|
||||
mode := strings.TrimPrefix(filepath.Ext(filename), ".")
|
||||
|
||||
switch mode {
|
||||
case "md", "markdown", "mdown", "mmark":
|
||||
mode = "markdown"
|
||||
case "asciidoc", "adoc", "ad":
|
||||
mode = "asciidoc"
|
||||
case "rst":
|
||||
mode = "rst"
|
||||
case "html", "htm":
|
||||
mode = "html"
|
||||
case "js":
|
||||
mode = "javascript"
|
||||
case "go":
|
||||
mode = "golang"
|
||||
}
|
||||
|
||||
return mode
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const errTemplate = `<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>TITLE</title>
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<meta charset="utf-8">
|
||||
<style>
|
||||
html {
|
||||
background-color: #2196f3;
|
||||
color: #fff;
|
||||
font-family: sans-serif;
|
||||
}
|
||||
code {
|
||||
background-color: rgba(0,0,0,0.1);
|
||||
border-radius: 5px;
|
||||
padding: 1em;
|
||||
display: block;
|
||||
box-sizing: border-box;
|
||||
}
|
||||
.center {
|
||||
max-width: 40em;
|
||||
margin: 2em auto 0;
|
||||
}
|
||||
a {
|
||||
text-decoration: none;
|
||||
color: #eee;
|
||||
font-weight: bold;
|
||||
}
|
||||
p {
|
||||
line-height: 1.3;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<div class="center">
|
||||
<h1>TITLE</h1>
|
||||
|
||||
<p>Try reloading the page or hitting the back button. If this error persists, it seems that you may have found a bug! Please create an issue at <a href="https://github.com/hacdias/caddy-filemanager/issues">hacdias/caddy-filemanager</a> repository on GitHub with the code below.</p>
|
||||
|
||||
<code>CODE</code>
|
||||
</div>
|
||||
</html>`
|
||||
|
||||
// PrintErrorHTML prints the error page
|
||||
func PrintErrorHTML(w http.ResponseWriter, code int, err error) (int, error) {
|
||||
tpl := errTemplate
|
||||
tpl = strings.Replace(tpl, "TITLE", strconv.Itoa(code)+" "+http.StatusText(code), -1)
|
||||
tpl = strings.Replace(tpl, "CODE", err.Error(), -1)
|
||||
|
||||
_, err = w.Write([]byte(tpl))
|
||||
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
return http.StatusOK, nil
|
||||
}
|
||||
|
|
@ -1 +1,99 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"regexp"
|
||||
"strings"
|
||||
|
||||
rice "github.com/GeertJohan/go.rice"
|
||||
"golang.org/x/net/webdav"
|
||||
)
|
||||
|
||||
// FileManager is a file manager instance.
|
||||
type FileManager struct {
|
||||
*User `json:"-"`
|
||||
Assets *Assets `json:"-"`
|
||||
|
||||
// PrefixURL is a part of the URL that is trimmed from the http.Request.URL before
|
||||
// it arrives to our handlers. It may be useful when using FileManager as a middleware
|
||||
// such as in caddy-filemanager plugin.
|
||||
PrefixURL string
|
||||
|
||||
// BaseURL is the path where the GUI will be accessible.
|
||||
BaseURL string
|
||||
|
||||
// WebDavURL is the path where the WebDAV will be accessible. It can be set to "/"
|
||||
// in order to override the GUI and only use the WebDAV.
|
||||
WebDavURL string
|
||||
|
||||
// Users is a map with the different configurations for each user.
|
||||
Users map[string]*User `json:"-"`
|
||||
|
||||
// TODO: event-based?
|
||||
BeforeSave CommandFunc `json:"-"`
|
||||
AfterSave CommandFunc `json:"-"`
|
||||
}
|
||||
|
||||
// User contains the configuration for each user.
|
||||
type User struct {
|
||||
Scope string `json:"-"` // Path the user have access
|
||||
FileSystem webdav.FileSystem `json:"-"` // The virtual file system the user have access
|
||||
Handler *webdav.Handler `json:"-"` // The WebDav HTTP Handler
|
||||
Rules []*Rule `json:"-"` // Access rules
|
||||
StyleSheet string `json:"-"` // Costum stylesheet
|
||||
AllowNew bool // Can create files and folders
|
||||
AllowEdit bool // Can edit/rename files
|
||||
AllowCommands bool // Can execute commands
|
||||
Commands []string // Available Commands
|
||||
}
|
||||
|
||||
// Assets are the static and front-end assets, such as JS, CSS and HTML templates.
|
||||
type Assets struct {
|
||||
requiredJS rice.Box // JS that is always required to have in order to be usable.
|
||||
Templates rice.Box
|
||||
CSS rice.Box
|
||||
JS rice.Box
|
||||
}
|
||||
|
||||
// Rule is a dissalow/allow rule.
|
||||
type Rule struct {
|
||||
Regex bool
|
||||
Allow bool
|
||||
Path string
|
||||
Regexp *regexp.Regexp
|
||||
}
|
||||
|
||||
// CommandFunc ...
|
||||
type CommandFunc func(r *http.Request, c *FileManager, u *User) error
|
||||
|
||||
// AbsoluteURL ...
|
||||
func (m FileManager) AbsoluteURL() string {
|
||||
return m.PrefixURL + m.BaseURL
|
||||
}
|
||||
|
||||
// AbsoluteWebdavURL ...
|
||||
func (m FileManager) AbsoluteWebdavURL() string {
|
||||
return m.PrefixURL + m.WebDavURL
|
||||
}
|
||||
|
||||
// Allowed checks if the user has permission to access a directory/file.
|
||||
func (u User) Allowed(url string) bool {
|
||||
var rule *Rule
|
||||
i := len(u.Rules) - 1
|
||||
|
||||
for i >= 0 {
|
||||
rule = u.Rules[i]
|
||||
|
||||
if rule.Regex {
|
||||
if rule.Regexp.MatchString(url) {
|
||||
return rule.Allow
|
||||
}
|
||||
} else if strings.HasPrefix(url, rule.Path) {
|
||||
return rule.Allow
|
||||
}
|
||||
|
||||
i--
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,276 @@
|
|||
package frontmatter
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"log"
|
||||
"reflect"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"gopkg.in/yaml.v2"
|
||||
|
||||
"github.com/BurntSushi/toml"
|
||||
"github.com/hacdias/filemanager/variables"
|
||||
|
||||
"github.com/spf13/cast"
|
||||
)
|
||||
|
||||
const (
|
||||
mainName = "#MAIN#"
|
||||
objectType = "object"
|
||||
arrayType = "array"
|
||||
)
|
||||
|
||||
var mainTitle = ""
|
||||
|
||||
// Pretty creates a new FrontMatter object
|
||||
func Pretty(content []byte) (*Content, string, error) {
|
||||
data, err := Unmarshal(content)
|
||||
|
||||
if err != nil {
|
||||
return &Content{}, "", err
|
||||
}
|
||||
|
||||
kind := reflect.ValueOf(data).Kind()
|
||||
|
||||
if kind == reflect.Invalid {
|
||||
return &Content{}, "", nil
|
||||
}
|
||||
|
||||
object := new(Block)
|
||||
object.Type = objectType
|
||||
object.Name = mainName
|
||||
|
||||
if kind == reflect.Map {
|
||||
object.Type = objectType
|
||||
} else if kind == reflect.Slice || kind == reflect.Array {
|
||||
object.Type = arrayType
|
||||
}
|
||||
|
||||
return rawToPretty(data, object), mainTitle, nil
|
||||
}
|
||||
|
||||
// Unmarshal returns the data of the frontmatter
|
||||
func Unmarshal(content []byte) (interface{}, error) {
|
||||
mark := rune(content[0])
|
||||
var data interface{}
|
||||
|
||||
switch mark {
|
||||
case '-':
|
||||
// If it's YAML
|
||||
if err := yaml.Unmarshal(content, &data); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
case '+':
|
||||
// If it's TOML
|
||||
content = bytes.Replace(content, []byte("+"), []byte(""), -1)
|
||||
if _, err := toml.Decode(string(content), &data); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
case '{', '[':
|
||||
// If it's JSON
|
||||
if err := json.Unmarshal(content, &data); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
default:
|
||||
return nil, errors.New("Invalid frontmatter type")
|
||||
}
|
||||
|
||||
return data, nil
|
||||
}
|
||||
|
||||
// Marshal encodes the interface in a specific format
|
||||
func Marshal(data interface{}, mark rune) ([]byte, error) {
|
||||
b := new(bytes.Buffer)
|
||||
|
||||
switch mark {
|
||||
case '+':
|
||||
enc := toml.NewEncoder(b)
|
||||
err := enc.Encode(data)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return b.Bytes(), nil
|
||||
case '{':
|
||||
by, err := json.MarshalIndent(data, "", " ")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
b.Write(by)
|
||||
_, err = b.Write([]byte("\n"))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return b.Bytes(), nil
|
||||
case '-':
|
||||
by, err := yaml.Marshal(data)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
b.Write(by)
|
||||
_, err = b.Write([]byte("..."))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return b.Bytes(), nil
|
||||
default:
|
||||
return nil, errors.New("Unsupported Format provided")
|
||||
}
|
||||
}
|
||||
|
||||
// Content is the block content
|
||||
type Content struct {
|
||||
Other interface{}
|
||||
Fields []*Block
|
||||
Arrays []*Block
|
||||
Objects []*Block
|
||||
}
|
||||
|
||||
// Block is a block
|
||||
type Block struct {
|
||||
Name string
|
||||
Title string
|
||||
Type string
|
||||
HTMLType string
|
||||
Content *Content
|
||||
Parent *Block
|
||||
}
|
||||
|
||||
func rawToPretty(config interface{}, parent *Block) *Content {
|
||||
objects := []*Block{}
|
||||
arrays := []*Block{}
|
||||
fields := []*Block{}
|
||||
|
||||
cnf := map[string]interface{}{}
|
||||
kind := reflect.TypeOf(config)
|
||||
|
||||
switch kind {
|
||||
case reflect.TypeOf(map[interface{}]interface{}{}):
|
||||
for key, value := range config.(map[interface{}]interface{}) {
|
||||
cnf[key.(string)] = value
|
||||
}
|
||||
case reflect.TypeOf([]map[string]interface{}{}):
|
||||
for index, value := range config.([]map[string]interface{}) {
|
||||
cnf[strconv.Itoa(index)] = value
|
||||
}
|
||||
case reflect.TypeOf([]map[interface{}]interface{}{}):
|
||||
for index, value := range config.([]map[interface{}]interface{}) {
|
||||
cnf[strconv.Itoa(index)] = value
|
||||
}
|
||||
case reflect.TypeOf([]interface{}{}):
|
||||
for index, value := range config.([]interface{}) {
|
||||
cnf[strconv.Itoa(index)] = value
|
||||
}
|
||||
default:
|
||||
cnf = config.(map[string]interface{})
|
||||
}
|
||||
|
||||
for name, element := range cnf {
|
||||
if variables.IsMap(element) {
|
||||
objects = append(objects, handleObjects(element, parent, name))
|
||||
} else if variables.IsSlice(element) {
|
||||
arrays = append(arrays, handleArrays(element, parent, name))
|
||||
} else {
|
||||
if name == "title" && parent.Name == mainName {
|
||||
mainTitle = element.(string)
|
||||
}
|
||||
fields = append(fields, handleFlatValues(element, parent, name))
|
||||
}
|
||||
}
|
||||
|
||||
sort.Sort(sortByTitle(fields))
|
||||
sort.Sort(sortByTitle(arrays))
|
||||
sort.Sort(sortByTitle(objects))
|
||||
return &Content{
|
||||
Fields: fields,
|
||||
Arrays: arrays,
|
||||
Objects: objects,
|
||||
}
|
||||
}
|
||||
|
||||
type sortByTitle []*Block
|
||||
|
||||
func (f sortByTitle) Len() int { return len(f) }
|
||||
func (f sortByTitle) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
|
||||
func (f sortByTitle) Less(i, j int) bool {
|
||||
return strings.ToLower(f[i].Name) < strings.ToLower(f[j].Name)
|
||||
}
|
||||
|
||||
func handleObjects(content interface{}, parent *Block, name string) *Block {
|
||||
c := new(Block)
|
||||
c.Parent = parent
|
||||
c.Type = objectType
|
||||
c.Title = name
|
||||
|
||||
if parent.Name == mainName {
|
||||
c.Name = c.Title
|
||||
} else if parent.Type == arrayType {
|
||||
c.Name = parent.Name + "[" + name + "]"
|
||||
} else {
|
||||
c.Name = parent.Name + "." + c.Title
|
||||
}
|
||||
|
||||
c.Content = rawToPretty(content, c)
|
||||
return c
|
||||
}
|
||||
|
||||
func handleArrays(content interface{}, parent *Block, name string) *Block {
|
||||
c := new(Block)
|
||||
c.Parent = parent
|
||||
c.Type = arrayType
|
||||
c.Title = name
|
||||
|
||||
if parent.Name == mainName {
|
||||
c.Name = name
|
||||
} else {
|
||||
c.Name = parent.Name + "." + name
|
||||
}
|
||||
|
||||
c.Content = rawToPretty(content, c)
|
||||
return c
|
||||
}
|
||||
|
||||
func handleFlatValues(content interface{}, parent *Block, name string) *Block {
|
||||
c := new(Block)
|
||||
c.Parent = parent
|
||||
|
||||
switch content.(type) {
|
||||
case bool:
|
||||
c.Type = "boolean"
|
||||
case int, float32, float64:
|
||||
c.Type = "number"
|
||||
default:
|
||||
c.Type = "string"
|
||||
}
|
||||
|
||||
c.Content = &Content{Other: content}
|
||||
|
||||
switch strings.ToLower(name) {
|
||||
case "description":
|
||||
c.HTMLType = "textarea"
|
||||
case "date", "publishdate":
|
||||
c.HTMLType = "datetime"
|
||||
c.Content = &Content{Other: cast.ToTime(content)}
|
||||
default:
|
||||
c.HTMLType = "text"
|
||||
}
|
||||
|
||||
if parent.Type == arrayType {
|
||||
c.Name = parent.Name + "[]"
|
||||
c.Title = content.(string)
|
||||
} else if parent.Type == objectType {
|
||||
c.Title = name
|
||||
c.Name = parent.Name + "." + name
|
||||
|
||||
if parent.Name == mainName {
|
||||
c.Name = name
|
||||
}
|
||||
} else {
|
||||
log.Panic("Parent type not allowed in handleFlatValues.")
|
||||
}
|
||||
|
||||
return c
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
package frontmatter
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// HasRune checks if the file has the frontmatter rune
|
||||
func HasRune(file []byte) bool {
|
||||
return strings.HasPrefix(string(file), "---") ||
|
||||
strings.HasPrefix(string(file), "+++") ||
|
||||
strings.HasPrefix(string(file), "{")
|
||||
}
|
||||
|
||||
// AppendRune appends the frontmatter rune to a file
|
||||
func AppendRune(frontmatter []byte, mark rune) []byte {
|
||||
frontmatter = bytes.TrimSpace(frontmatter)
|
||||
|
||||
switch mark {
|
||||
case '-':
|
||||
return []byte("---\n" + string(frontmatter) + "\n---")
|
||||
case '+':
|
||||
return []byte("+++\n" + string(frontmatter) + "\n+++")
|
||||
case '{':
|
||||
return []byte("{\n" + string(frontmatter) + "\n}")
|
||||
}
|
||||
|
||||
return frontmatter
|
||||
}
|
||||
|
||||
// RuneToStringFormat converts the rune to a string with the format
|
||||
func RuneToStringFormat(mark rune) (string, error) {
|
||||
switch mark {
|
||||
case '-':
|
||||
return "yaml", nil
|
||||
case '+':
|
||||
return "toml", nil
|
||||
case '{', '}':
|
||||
return "json", nil
|
||||
default:
|
||||
return "", errors.New("Unsupported format type")
|
||||
}
|
||||
}
|
||||
|
||||
// StringFormatToRune converts the format name to its rune
|
||||
func StringFormatToRune(format string) (rune, error) {
|
||||
switch format {
|
||||
case "yaml":
|
||||
return '-', nil
|
||||
case "toml":
|
||||
return '+', nil
|
||||
case "json":
|
||||
return '{', nil
|
||||
default:
|
||||
return '0', errors.New("Unsupported format type")
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
package frontmatter
|
||||
|
||||
import "testing"
|
||||
|
||||
type hasRuneTest struct {
|
||||
File []byte
|
||||
Return bool
|
||||
}
|
||||
|
||||
var testHasRune = []hasRuneTest{
|
||||
hasRuneTest{
|
||||
File: []byte(`---
|
||||
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
|
||||
Sed auctor libero eget ante fermentum commodo.
|
||||
---`),
|
||||
Return: true,
|
||||
},
|
||||
hasRuneTest{
|
||||
File: []byte(`+++
|
||||
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
|
||||
Sed auctor libero eget ante fermentum commodo.
|
||||
+++`),
|
||||
Return: true,
|
||||
},
|
||||
hasRuneTest{
|
||||
File: []byte(`{
|
||||
"json": "Lorem ipsum dolor sit amet"
|
||||
}`),
|
||||
Return: true,
|
||||
},
|
||||
hasRuneTest{
|
||||
File: []byte(`+`),
|
||||
Return: false,
|
||||
},
|
||||
hasRuneTest{
|
||||
File: []byte(`++`),
|
||||
Return: false,
|
||||
},
|
||||
hasRuneTest{
|
||||
File: []byte(`-`),
|
||||
Return: false,
|
||||
},
|
||||
hasRuneTest{
|
||||
File: []byte(`--`),
|
||||
Return: false,
|
||||
},
|
||||
hasRuneTest{
|
||||
File: []byte(`Lorem ipsum`),
|
||||
Return: false,
|
||||
},
|
||||
}
|
||||
|
||||
func TestHasRune(t *testing.T) {
|
||||
for _, test := range testHasRune {
|
||||
if HasRune(test.File) != test.Return {
|
||||
t.Error("Incorrect value on HasRune")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type appendRuneTest struct {
|
||||
Before []byte
|
||||
After []byte
|
||||
Mark rune
|
||||
}
|
||||
|
||||
var testAppendRuneTest = []appendRuneTest{}
|
||||
|
||||
func TestAppendRune(t *testing.T) {
|
||||
for i, test := range testAppendRuneTest {
|
||||
if !compareByte(AppendRune(test.Before, test.Mark), test.After) {
|
||||
t.Errorf("Incorrect value on AppendRune of Test %d", i)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func compareByte(a, b []byte) bool {
|
||||
if a == nil && b == nil {
|
||||
return true
|
||||
}
|
||||
|
||||
if a == nil || b == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
|
||||
for i := range a {
|
||||
if a[i] != b[i] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
var testRuneToStringFormat = map[rune]string{
|
||||
'-': "yaml",
|
||||
'+': "toml",
|
||||
'{': "json",
|
||||
'}': "json",
|
||||
'1': "",
|
||||
'a': "",
|
||||
}
|
||||
|
||||
func TestRuneToStringFormat(t *testing.T) {
|
||||
for mark, format := range testRuneToStringFormat {
|
||||
val, _ := RuneToStringFormat(mark)
|
||||
if val != format {
|
||||
t.Errorf("Incorrect value on RuneToStringFormat of %v; want: %s; got: %s", mark, format, val)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var testStringFormatToRune = map[string]rune{
|
||||
"yaml": '-',
|
||||
"toml": '+',
|
||||
"json": '{',
|
||||
"lorem": '0',
|
||||
}
|
||||
|
||||
func TestStringFormatToRune(t *testing.T) {
|
||||
for format, mark := range testStringFormatToRune {
|
||||
val, _ := StringFormatToRune(format)
|
||||
if val != mark {
|
||||
t.Errorf("Incorrect value on StringFormatToRune of %s; want: %v; got: %v", format, mark, val)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,167 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"github.com/mholt/caddy/caddyhttp/httpserver"
|
||||
)
|
||||
|
||||
// ServeHTTP determines if the request is for this plugin, and if all prerequisites are met.
|
||||
func (c *FileManager) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
|
||||
var (
|
||||
fi *FileInfo
|
||||
code int
|
||||
err error
|
||||
user *User
|
||||
)
|
||||
|
||||
// Checks if the URL matches the Assets URL. Returns the asset if the
|
||||
// method is GET and Status Forbidden otherwise.
|
||||
if httpserver.Path(r.URL.Path).Matches(c.BaseURL + AssetsURL) {
|
||||
if r.Method == http.MethodGet {
|
||||
return serveAssets(w, r, c)
|
||||
}
|
||||
|
||||
return http.StatusForbidden, nil
|
||||
}
|
||||
|
||||
username, _, _ := r.BasicAuth()
|
||||
if _, ok := c.Users[username]; ok {
|
||||
user = c.Users[username]
|
||||
} else {
|
||||
user = c.User
|
||||
}
|
||||
|
||||
// Checks if the request URL is for the WebDav server
|
||||
if httpserver.Path(r.URL.Path).Matches(c.WebDavURL) {
|
||||
// Checks for user permissions relatively to this PATH
|
||||
if !user.Allowed(strings.TrimPrefix(r.URL.Path, c.WebDavURL)) {
|
||||
return http.StatusForbidden, nil
|
||||
}
|
||||
|
||||
switch r.Method {
|
||||
case "GET", "HEAD":
|
||||
// Excerpt from RFC4918, section 9.4:
|
||||
//
|
||||
// GET, when applied to a collection, may return the contents of an
|
||||
// "index.html" resource, a human-readable view of the contents of
|
||||
// the collection, or something else altogether.
|
||||
//
|
||||
// It was decided on https://github.com/hacdias/caddy-filemanager/issues/85
|
||||
// that GET, for collections, will return the same as PROPFIND method.
|
||||
path := strings.Replace(r.URL.Path, c.WebDavURL, "", 1)
|
||||
path = user.Scope + "/" + path
|
||||
path = filepath.Clean(path)
|
||||
|
||||
var i os.FileInfo
|
||||
i, err = os.Stat(path)
|
||||
if err != nil {
|
||||
// Is there any error? WebDav will handle it... no worries.
|
||||
break
|
||||
}
|
||||
|
||||
if i.IsDir() {
|
||||
r.Method = "PROPFIND"
|
||||
|
||||
if r.Method == "HEAD" {
|
||||
w = newResponseWriterNoBody(w)
|
||||
}
|
||||
}
|
||||
case "PROPPATCH", "MOVE", "PATCH", "PUT", "DELETE":
|
||||
if !user.AllowEdit {
|
||||
return http.StatusForbidden, nil
|
||||
}
|
||||
case "MKCOL", "COPY":
|
||||
if !user.AllowNew {
|
||||
return http.StatusForbidden, nil
|
||||
}
|
||||
}
|
||||
|
||||
// Preprocess the PUT request if it's the case
|
||||
if r.Method == http.MethodPut {
|
||||
if err = c.BeforeSave(r, c, user); err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
if put(w, r, c, user) != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
}
|
||||
|
||||
c.Handler.ServeHTTP(w, r)
|
||||
if err = c.AfterSave(r, c, user); err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
w.Header().Set("x-frame-options", "SAMEORIGIN")
|
||||
w.Header().Set("x-content-type", "nosniff")
|
||||
w.Header().Set("x-xss-protection", "1; mode=block")
|
||||
|
||||
// Checks if the User is allowed to access this file
|
||||
if !user.Allowed(strings.TrimPrefix(r.URL.Path, c.BaseURL)) {
|
||||
if r.Method == http.MethodGet {
|
||||
return PrintErrorHTML(
|
||||
w, http.StatusForbidden,
|
||||
errors.New("You don't have permission to access this page"),
|
||||
)
|
||||
}
|
||||
|
||||
return http.StatusForbidden, nil
|
||||
}
|
||||
|
||||
if r.URL.Query().Get("search") != "" {
|
||||
return search(w, r, c, user)
|
||||
}
|
||||
|
||||
if r.URL.Query().Get("command") != "" {
|
||||
return command(w, r, c, user)
|
||||
}
|
||||
|
||||
if r.Method == http.MethodGet {
|
||||
// Gets the information of the directory/file
|
||||
fi, err = GetInfo(r.URL, c, user)
|
||||
if err != nil {
|
||||
if r.Method == http.MethodGet {
|
||||
return PrintErrorHTML(w, code, err)
|
||||
}
|
||||
code = errorToHTTP(err, false)
|
||||
return code, err
|
||||
}
|
||||
|
||||
// If it's a dir and the path doesn't end with a trailing slash,
|
||||
// redirect the user.
|
||||
if fi.IsDir && !strings.HasSuffix(r.URL.Path, "/") {
|
||||
http.Redirect(w, r, c.PrefixURL+r.URL.Path+"/", http.StatusTemporaryRedirect)
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
switch {
|
||||
case r.URL.Query().Get("download") != "":
|
||||
code, err = download(w, r, fi)
|
||||
case r.URL.Query().Get("raw") == "true" && !fi.IsDir:
|
||||
http.ServeFile(w, r, fi.Path)
|
||||
code, err = 0, nil
|
||||
case !fi.IsDir && r.URL.Query().Get("checksum") != "":
|
||||
code, err = checksum(w, r, fi)
|
||||
case fi.IsDir:
|
||||
code, err = serveListing(w, r, c, user, fi)
|
||||
default:
|
||||
code, err = serveSingle(w, r, c, user, fi)
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
code, err = PrintErrorHTML(w, code, err)
|
||||
}
|
||||
|
||||
return code, err
|
||||
}
|
||||
|
||||
return http.StatusNotImplemented, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"mime"
|
||||
"net/http"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// AssetsURL is the url of the assets
|
||||
const AssetsURL = "/_filemanagerinternal"
|
||||
|
||||
// Serve provides the needed assets for the front-end
|
||||
func serveAssets(w http.ResponseWriter, r *http.Request, m *FileManager) (int, error) {
|
||||
// gets the filename to be used with Assets function
|
||||
filename := strings.Replace(r.URL.Path, m.BaseURL+AssetsURL, "", 1)
|
||||
|
||||
var file []byte
|
||||
var err error
|
||||
|
||||
switch {
|
||||
case strings.HasPrefix(filename, "/css"):
|
||||
filename = strings.Replace(filename, "/css/", "", 1)
|
||||
file, err = m.Assets.CSS.Bytes(filename)
|
||||
case strings.HasPrefix(filename, "/js"):
|
||||
filename = strings.Replace(filename, "/js/", "", 1)
|
||||
file, err = m.Assets.requiredJS.Bytes(filename)
|
||||
case strings.HasPrefix(filename, "/vendor"):
|
||||
filename = strings.Replace(filename, "/vendor/", "", 1)
|
||||
file, err = m.Assets.JS.Bytes(filename)
|
||||
default:
|
||||
err = errors.New("not found")
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
return http.StatusNotFound, nil
|
||||
}
|
||||
|
||||
// Get the file extension and its mimetype
|
||||
extension := filepath.Ext(filename)
|
||||
mediatype := mime.TypeByExtension(extension)
|
||||
|
||||
// Write the header with the Content-Type and write the file
|
||||
// content to the buffer
|
||||
w.Header().Set("Content-Type", mediatype)
|
||||
w.Write(file)
|
||||
return 200, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"crypto/md5"
|
||||
"crypto/sha1"
|
||||
"crypto/sha256"
|
||||
"crypto/sha512"
|
||||
"encoding/hex"
|
||||
e "errors"
|
||||
"hash"
|
||||
"io"
|
||||
"net/http"
|
||||
"os"
|
||||
)
|
||||
|
||||
// checksum calculates the hash of a file. Supports MD5, SHA1, SHA256 and SHA512.
|
||||
func checksum(w http.ResponseWriter, r *http.Request, i *FileInfo) (int, error) {
|
||||
query := r.URL.Query().Get("checksum")
|
||||
|
||||
file, err := os.Open(i.Path)
|
||||
if err != nil {
|
||||
return errorToHTTP(err, true), err
|
||||
}
|
||||
|
||||
defer file.Close()
|
||||
|
||||
var h hash.Hash
|
||||
|
||||
switch query {
|
||||
case "md5":
|
||||
h = md5.New()
|
||||
case "sha1":
|
||||
h = sha1.New()
|
||||
case "sha256":
|
||||
h = sha256.New()
|
||||
case "sha512":
|
||||
h = sha512.New()
|
||||
default:
|
||||
return http.StatusBadRequest, e.New("Unknown HASH type")
|
||||
}
|
||||
|
||||
_, err = io.Copy(h, file)
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
val := hex.EncodeToString(h.Sum(nil))
|
||||
w.Write([]byte(val))
|
||||
return http.StatusOK, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"net/http"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/gorilla/websocket"
|
||||
)
|
||||
|
||||
var upgrader = websocket.Upgrader{
|
||||
ReadBufferSize: 1024,
|
||||
WriteBufferSize: 1024,
|
||||
}
|
||||
|
||||
var (
|
||||
cmdNotImplemented = []byte("Command not implemented.")
|
||||
cmdNotAllowed = []byte("Command not allowed.")
|
||||
)
|
||||
|
||||
// command handles the requests for VCS related commands: git, svn and mercurial
|
||||
func command(w http.ResponseWriter, r *http.Request, c *FileManager, u *User) (int, error) {
|
||||
// Upgrades the connection to a websocket and checks for errors.
|
||||
conn, err := upgrader.Upgrade(w, r, nil)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
defer conn.Close()
|
||||
|
||||
var (
|
||||
message []byte
|
||||
command []string
|
||||
)
|
||||
|
||||
// Starts an infinite loop until a valid command is captured.
|
||||
for {
|
||||
_, message, err = conn.ReadMessage()
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
command = strings.Split(string(message), " ")
|
||||
if len(command) != 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// Check if the command is allowed
|
||||
allowed := false
|
||||
|
||||
for _, cmd := range u.Commands {
|
||||
if cmd == command[0] {
|
||||
allowed = true
|
||||
}
|
||||
}
|
||||
|
||||
if !allowed {
|
||||
err = conn.WriteMessage(websocket.BinaryMessage, cmdNotAllowed)
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
// Check if the program is talled is installed on the computer.
|
||||
if _, err = exec.LookPath(command[0]); err != nil {
|
||||
err = conn.WriteMessage(websocket.BinaryMessage, cmdNotImplemented)
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
return http.StatusNotImplemented, nil
|
||||
}
|
||||
|
||||
// Gets the path and initializes a buffer.
|
||||
path := strings.Replace(r.URL.Path, c.BaseURL, c.Scope, 1)
|
||||
path = filepath.Clean(path)
|
||||
buff := new(bytes.Buffer)
|
||||
|
||||
// Sets up the command executation.
|
||||
cmd := exec.Command(command[0], command[1:]...)
|
||||
cmd.Dir = path
|
||||
cmd.Stderr = buff
|
||||
cmd.Stdout = buff
|
||||
|
||||
// Starts the command and checks for errors.
|
||||
err = cmd.Start()
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
// Set a 'done' variable to check whetever the command has already finished
|
||||
// running or not. This verification is done using a goroutine that uses the
|
||||
// method .Wait() from the command.
|
||||
done := false
|
||||
go func() {
|
||||
err = cmd.Wait()
|
||||
done = true
|
||||
}()
|
||||
|
||||
// Function to print the current information on the buffer to the connection.
|
||||
print := func() error {
|
||||
by := buff.Bytes()
|
||||
if len(by) > 0 {
|
||||
err = conn.WriteMessage(websocket.TextMessage, by)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// While the command hasn't finished running, continue sending the output
|
||||
// to the client in intervals of 100 milliseconds.
|
||||
for !done {
|
||||
if err = print(); err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
|
||||
// After the command is done executing, send the output one more time to the
|
||||
// browser to make sure it gets the latest information.
|
||||
if err = print(); err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
return 0, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"github.com/mholt/archiver"
|
||||
)
|
||||
|
||||
// download creates an archive in one of the supported formats (zip, tar,
|
||||
// tar.gz or tar.bz2) and sends it to be downloaded.
|
||||
func download(w http.ResponseWriter, r *http.Request, i *FileInfo) (int, error) {
|
||||
query := r.URL.Query().Get("download")
|
||||
|
||||
if !i.IsDir {
|
||||
w.Header().Set("Content-Disposition", "attachment; filename="+i.Name)
|
||||
http.ServeFile(w, r, i.Path)
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
files := []string{}
|
||||
names := strings.Split(r.URL.Query().Get("files"), ",")
|
||||
|
||||
if len(names) != 0 {
|
||||
for _, name := range names {
|
||||
name, err := url.QueryUnescape(name)
|
||||
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
files = append(files, filepath.Join(i.Path, name))
|
||||
}
|
||||
|
||||
} else {
|
||||
files = append(files, i.Path)
|
||||
}
|
||||
|
||||
if query == "true" {
|
||||
query = "zip"
|
||||
}
|
||||
|
||||
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, files)
|
||||
case "tar":
|
||||
extension, err = ".tar", archiver.Tar.Make(tempfile, files)
|
||||
case "targz":
|
||||
extension, err = ".tar.gz", archiver.TarGz.Make(tempfile, files)
|
||||
case "tarbz2":
|
||||
extension, err = ".tar.bz2", archiver.TarBz2.Make(tempfile, files)
|
||||
case "tarxz":
|
||||
extension, err = ".tar.xz", archiver.TarXZ.Make(tempfile, files)
|
||||
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
|
||||
}
|
||||
|
||||
name := i.Name
|
||||
if name == "." || name == "" {
|
||||
name = "download"
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Disposition", "attachment; filename="+name+extension)
|
||||
io.Copy(w, file)
|
||||
return http.StatusOK, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/mholt/caddy/caddyhttp/httpserver"
|
||||
)
|
||||
|
||||
// serveListing presents the user with a listage of a directory folder.
|
||||
func serveListing(w http.ResponseWriter, r *http.Request, c *FileManager, u *User, i *FileInfo) (int, error) {
|
||||
var err error
|
||||
|
||||
// Loads the content of the directory
|
||||
listing, err := GetListing(u, i.VirtualPath, c.PrefixURL+r.URL.Path)
|
||||
if err != nil {
|
||||
return errorToHTTP(err, true), err
|
||||
}
|
||||
|
||||
listing.Context = httpserver.Context{
|
||||
Root: http.Dir(u.Scope),
|
||||
Req: r,
|
||||
URL: r.URL,
|
||||
}
|
||||
|
||||
cookieScope := c.BaseURL
|
||||
if cookieScope == "" {
|
||||
cookieScope = "/"
|
||||
}
|
||||
|
||||
// Copy the query values into the Listing struct
|
||||
var limit int
|
||||
listing.Sort, listing.Order, limit, err = handleSortOrder(w, r, cookieScope)
|
||||
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
|
||||
}
|
||||
|
||||
displayMode := r.URL.Query().Get("display")
|
||||
|
||||
if displayMode == "" {
|
||||
if displayCookie, err := r.Cookie("display"); err == nil {
|
||||
displayMode = displayCookie.Value
|
||||
}
|
||||
}
|
||||
|
||||
if displayMode == "" || (displayMode != "mosaic" && displayMode != "list") {
|
||||
displayMode = "mosaic"
|
||||
}
|
||||
|
||||
http.SetCookie(w, &http.Cookie{
|
||||
Name: "display",
|
||||
Value: displayMode,
|
||||
Path: cookieScope,
|
||||
Secure: r.TLS != nil,
|
||||
})
|
||||
|
||||
page := &Page{
|
||||
Minimal: r.Header.Get("Minimal") == "true",
|
||||
PageInfo: &PageInfo{
|
||||
Name: listing.Name,
|
||||
Path: i.VirtualPath,
|
||||
IsDir: true,
|
||||
User: u,
|
||||
Config: c,
|
||||
Display: displayMode,
|
||||
Data: listing,
|
||||
},
|
||||
}
|
||||
|
||||
return page.PrintAsHTML(w, "listing")
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
|
@ -0,0 +1,138 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/hacdias/filemanager/frontmatter"
|
||||
)
|
||||
|
||||
// put is used to update a file that was edited
|
||||
func put(w http.ResponseWriter, r *http.Request, c *FileManager, u *User) (err error) {
|
||||
var (
|
||||
data = map[string]interface{}{}
|
||||
file []byte
|
||||
kind string
|
||||
rawBuffer = new(bytes.Buffer)
|
||||
)
|
||||
|
||||
kind = r.Header.Get("kind")
|
||||
rawBuffer.ReadFrom(r.Body)
|
||||
|
||||
if kind != "" {
|
||||
err = json.Unmarshal(rawBuffer.Bytes(), &data)
|
||||
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
switch kind {
|
||||
case "frontmatter-only":
|
||||
if file, err = parseFrontMatterOnlyFile(data, r.URL.Path); err != nil {
|
||||
return
|
||||
}
|
||||
case "content-only":
|
||||
mainContent := data["content"].(string)
|
||||
mainContent = strings.TrimSpace(mainContent)
|
||||
file = []byte(mainContent)
|
||||
case "complete":
|
||||
var mark rune
|
||||
|
||||
if v := r.Header.Get("Rune"); v != "" {
|
||||
var n int
|
||||
n, err = strconv.Atoi(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
mark = rune(n)
|
||||
}
|
||||
|
||||
if file, err = parseCompleteFile(data, r.URL.Path, mark); err != nil {
|
||||
return
|
||||
}
|
||||
default:
|
||||
file = rawBuffer.Bytes()
|
||||
}
|
||||
|
||||
// Overwrite the request Body
|
||||
r.Body = ioutil.NopCloser(bytes.NewReader(file))
|
||||
return
|
||||
}
|
||||
|
||||
// parseFrontMatterOnlyFile parses a frontmatter only file
|
||||
func parseFrontMatterOnlyFile(data interface{}, filename string) ([]byte, error) {
|
||||
frontmatter := strings.TrimPrefix(filepath.Ext(filename), ".")
|
||||
f, err := parseFrontMatter(data, frontmatter)
|
||||
fString := string(f)
|
||||
|
||||
// If it's toml or yaml, strip frontmatter identifier
|
||||
if frontmatter == "toml" {
|
||||
fString = strings.TrimSuffix(fString, "+++\n")
|
||||
fString = strings.TrimPrefix(fString, "+++\n")
|
||||
}
|
||||
|
||||
if frontmatter == "yaml" {
|
||||
fString = strings.TrimSuffix(fString, "---\n")
|
||||
fString = strings.TrimPrefix(fString, "---\n")
|
||||
}
|
||||
|
||||
f = []byte(fString)
|
||||
return f, err
|
||||
}
|
||||
|
||||
// parseFrontMatter is the frontmatter parser
|
||||
func parseFrontMatter(data interface{}, front string) ([]byte, error) {
|
||||
var mark rune
|
||||
|
||||
switch front {
|
||||
case "toml":
|
||||
mark = '+'
|
||||
case "json":
|
||||
mark = '{'
|
||||
case "yaml":
|
||||
mark = '-'
|
||||
default:
|
||||
return nil, errors.New("Unsupported Format provided")
|
||||
}
|
||||
|
||||
return frontmatter.Marshal(data, mark)
|
||||
}
|
||||
|
||||
// parseCompleteFile parses a complete file
|
||||
func parseCompleteFile(data map[string]interface{}, filename string, mark rune) ([]byte, error) {
|
||||
mainContent := ""
|
||||
|
||||
if _, ok := data["content"]; ok {
|
||||
// The main content of the file
|
||||
mainContent = data["content"].(string)
|
||||
mainContent = "\n\n" + strings.TrimSpace(mainContent) + "\n"
|
||||
|
||||
// Removes the main content from the rest of the frontmatter
|
||||
delete(data, "content")
|
||||
}
|
||||
|
||||
if _, ok := data["date"]; ok {
|
||||
data["date"] = data["date"].(string) + ":00"
|
||||
}
|
||||
|
||||
front, err := frontmatter.Marshal(data, mark)
|
||||
if err != nil {
|
||||
return []byte{}, err
|
||||
}
|
||||
|
||||
front = frontmatter.AppendRune(front, mark)
|
||||
|
||||
// Generates the final file
|
||||
f := new(bytes.Buffer)
|
||||
f.Write(front)
|
||||
f.Write([]byte(mainContent))
|
||||
return f.Bytes(), nil
|
||||
}
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"github.com/gorilla/websocket"
|
||||
)
|
||||
|
||||
type searchOptions struct {
|
||||
CaseInsensitive bool
|
||||
Terms []string
|
||||
}
|
||||
|
||||
func parseSearch(value string) *searchOptions {
|
||||
opts := &searchOptions{
|
||||
CaseInsensitive: strings.Contains(value, "case:insensitive"),
|
||||
}
|
||||
|
||||
// removes the options from the value
|
||||
value = strings.Replace(value, "case:insensitive", "", -1)
|
||||
value = strings.Replace(value, "case:sensitive", "", -1)
|
||||
value = strings.TrimSpace(value)
|
||||
|
||||
if opts.CaseInsensitive {
|
||||
value = strings.ToLower(value)
|
||||
}
|
||||
|
||||
// if the value starts with " and finishes what that character, we will
|
||||
// only search for that term
|
||||
if value[0] == '"' && value[len(value)-1] == '"' {
|
||||
unique := strings.TrimPrefix(value, "\"")
|
||||
unique = strings.TrimSuffix(unique, "\"")
|
||||
|
||||
opts.Terms = []string{unique}
|
||||
return opts
|
||||
}
|
||||
|
||||
opts.Terms = strings.Split(value, " ")
|
||||
return opts
|
||||
}
|
||||
|
||||
// search searches for a file or directory.
|
||||
func search(w http.ResponseWriter, r *http.Request, c *FileManager, u *User) (int, error) {
|
||||
// Upgrades the connection to a websocket and checks for errors.
|
||||
conn, err := upgrader.Upgrade(w, r, nil)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
defer conn.Close()
|
||||
|
||||
var (
|
||||
value string
|
||||
search *searchOptions
|
||||
message []byte
|
||||
)
|
||||
|
||||
// Starts an infinite loop until a valid command is captured.
|
||||
for {
|
||||
_, message, err = conn.ReadMessage()
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
if len(message) != 0 {
|
||||
value = string(message)
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
search = parseSearch(value)
|
||||
scope := strings.Replace(r.URL.Path, c.BaseURL, "", 1)
|
||||
scope = strings.TrimPrefix(scope, "/")
|
||||
scope = "/" + scope
|
||||
scope = u.Scope + scope
|
||||
scope = strings.Replace(scope, "\\", "/", -1)
|
||||
scope = filepath.Clean(scope)
|
||||
|
||||
err = filepath.Walk(scope, func(path string, f os.FileInfo, err error) error {
|
||||
if search.CaseInsensitive {
|
||||
path = strings.ToLower(path)
|
||||
}
|
||||
|
||||
path = strings.Replace(path, "\\", "/", -1)
|
||||
is := false
|
||||
|
||||
for _, term := range search.Terms {
|
||||
if is {
|
||||
break
|
||||
}
|
||||
|
||||
if strings.Contains(path, term) {
|
||||
if !u.Allowed(path) {
|
||||
return nil
|
||||
}
|
||||
|
||||
is = true
|
||||
}
|
||||
}
|
||||
|
||||
if !is {
|
||||
return nil
|
||||
}
|
||||
|
||||
path = strings.TrimPrefix(path, scope)
|
||||
path = strings.TrimPrefix(path, "/")
|
||||
return conn.WriteMessage(websocket.TextMessage, []byte(path))
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
return http.StatusOK, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// serveSingle serves a single file in an editor (if it is editable), shows the
|
||||
// plain file, or downloads it if it can't be shown.
|
||||
func serveSingle(w http.ResponseWriter, r *http.Request, c *FileManager, u *User, i *FileInfo) (int, error) {
|
||||
var err error
|
||||
|
||||
if err = i.RetrieveFileType(); err != nil {
|
||||
return errorToHTTP(err, true), err
|
||||
}
|
||||
|
||||
p := &Page{
|
||||
PageInfo: &PageInfo{
|
||||
Name: i.Name,
|
||||
Path: i.VirtualPath,
|
||||
IsDir: false,
|
||||
Data: i,
|
||||
User: u,
|
||||
Config: c,
|
||||
},
|
||||
}
|
||||
|
||||
// If the request accepts JSON, we send the file information.
|
||||
if strings.Contains(r.Header.Get("Accept"), "application/json") {
|
||||
return p.PrintAsJSON(w)
|
||||
}
|
||||
|
||||
if i.Type == "text" {
|
||||
if err = i.Read(); err != nil {
|
||||
return errorToHTTP(err, true), err
|
||||
}
|
||||
}
|
||||
|
||||
if i.CanBeEdited() && u.AllowEdit {
|
||||
p.Data, err = GetEditor(r, i)
|
||||
p.Editor = true
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
return p.PrintAsHTML(w, "frontmatter", "editor")
|
||||
}
|
||||
|
||||
return p.PrintAsHTML(w, "single")
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"os"
|
||||
)
|
||||
|
||||
// responseWriterNoBody is a wrapper used to suprress the body of the response
|
||||
// to a request. Mainly used for HEAD requests.
|
||||
type responseWriterNoBody struct {
|
||||
http.ResponseWriter
|
||||
}
|
||||
|
||||
// newResponseWriterNoBody creates a new responseWriterNoBody.
|
||||
func newResponseWriterNoBody(w http.ResponseWriter) *responseWriterNoBody {
|
||||
return &responseWriterNoBody{w}
|
||||
}
|
||||
|
||||
// Header executes the Header method from the http.ResponseWriter.
|
||||
func (w responseWriterNoBody) Header() http.Header {
|
||||
return w.ResponseWriter.Header()
|
||||
}
|
||||
|
||||
// Write suprresses the body.
|
||||
func (w responseWriterNoBody) Write(data []byte) (int, error) {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
// WriteHeader writes the header to the http.ResponseWriter.
|
||||
func (w responseWriterNoBody) WriteHeader(statusCode int) {
|
||||
w.ResponseWriter.WriteHeader(statusCode)
|
||||
}
|
||||
|
||||
// errorToHTTP converts errors to HTTP Status Code.
|
||||
func errorToHTTP(err error, gone bool) int {
|
||||
switch {
|
||||
case os.IsPermission(err):
|
||||
return http.StatusForbidden
|
||||
case os.IsNotExist(err):
|
||||
if !gone {
|
||||
return http.StatusNotFound
|
||||
}
|
||||
|
||||
return http.StatusGone
|
||||
case os.IsExist(err):
|
||||
return http.StatusGone
|
||||
default:
|
||||
return http.StatusInternalServerError
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,163 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"io/ioutil"
|
||||
"mime"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
humanize "github.com/dustin/go-humanize"
|
||||
)
|
||||
|
||||
// FileInfo contains the information about a particular file or directory
|
||||
type FileInfo struct {
|
||||
Name string
|
||||
Size int64
|
||||
URL string
|
||||
Extension string
|
||||
ModTime time.Time
|
||||
Mode os.FileMode
|
||||
IsDir bool
|
||||
Path string // Relative path to Current Working Directory
|
||||
VirtualPath string // Relative path to user's virtual File System
|
||||
Mimetype string
|
||||
Type string
|
||||
UserAllowed bool // Indicates if the user has enough permissions
|
||||
|
||||
content []byte
|
||||
}
|
||||
|
||||
// GetInfo gets the file information and, in case of error, returns the
|
||||
// respective HTTP error code
|
||||
func GetInfo(url *url.URL, c *FileManager, u *User) (*FileInfo, error) {
|
||||
var err error
|
||||
|
||||
i := &FileInfo{URL: c.PrefixURL + url.Path}
|
||||
i.VirtualPath = strings.Replace(url.Path, c.BaseURL, "", 1)
|
||||
i.VirtualPath = strings.TrimPrefix(i.VirtualPath, "/")
|
||||
i.VirtualPath = "/" + i.VirtualPath
|
||||
|
||||
i.Path = u.Scope + i.VirtualPath
|
||||
i.Path = filepath.Clean(i.Path)
|
||||
|
||||
info, err := os.Stat(i.Path)
|
||||
if err != nil {
|
||||
return i, err
|
||||
}
|
||||
|
||||
i.Name = info.Name()
|
||||
i.ModTime = info.ModTime()
|
||||
i.Mode = info.Mode()
|
||||
i.IsDir = info.IsDir()
|
||||
i.Size = info.Size()
|
||||
i.Extension = filepath.Ext(i.Name)
|
||||
return i, nil
|
||||
}
|
||||
|
||||
var textExtensions = [...]string{
|
||||
".md", ".markdown", ".mdown", ".mmark",
|
||||
".asciidoc", ".adoc", ".ad",
|
||||
".rst",
|
||||
".json", ".toml", ".yaml", ".csv", ".xml", ".rss", ".conf", ".ini",
|
||||
".tex", ".sty",
|
||||
".css", ".sass", ".scss",
|
||||
".js",
|
||||
".html",
|
||||
".txt", ".rtf",
|
||||
".sh", ".bash", ".ps1", ".bat", ".cmd",
|
||||
".php", ".pl", ".py",
|
||||
"Caddyfile",
|
||||
".c", ".cc", ".h", ".hh", ".cpp", ".hpp", ".f90",
|
||||
".f", ".bas", ".d", ".ada", ".nim", ".cr", ".java", ".cs", ".vala", ".vapi",
|
||||
}
|
||||
|
||||
// RetrieveFileType obtains the mimetype and a simplified internal Type
|
||||
// using the first 512 bytes from the file.
|
||||
func (i FileInfo) RetrieveFileType() error {
|
||||
i.Mimetype = mime.TypeByExtension(i.Extension)
|
||||
|
||||
if i.Mimetype == "" {
|
||||
err := i.Read()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
i.Mimetype = http.DetectContentType(i.content)
|
||||
}
|
||||
|
||||
if strings.HasPrefix(i.Mimetype, "video") {
|
||||
i.Type = "video"
|
||||
return nil
|
||||
}
|
||||
|
||||
if strings.HasPrefix(i.Mimetype, "audio") {
|
||||
i.Type = "audio"
|
||||
return nil
|
||||
}
|
||||
|
||||
if strings.HasPrefix(i.Mimetype, "image") {
|
||||
i.Type = "image"
|
||||
return nil
|
||||
}
|
||||
|
||||
if strings.HasPrefix(i.Mimetype, "text") {
|
||||
i.Type = "text"
|
||||
return nil
|
||||
}
|
||||
|
||||
if strings.HasPrefix(i.Mimetype, "application/javascript") {
|
||||
i.Type = "text"
|
||||
return nil
|
||||
}
|
||||
|
||||
// If the type isn't text (and is blob for example), it will check some
|
||||
// common types that are mistaken not to be text.
|
||||
for _, extension := range textExtensions {
|
||||
if strings.HasSuffix(i.Name, extension) {
|
||||
i.Type = "text"
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
i.Type = "blob"
|
||||
return nil
|
||||
}
|
||||
|
||||
// Reads the file.
|
||||
func (i FileInfo) Read() error {
|
||||
if len(i.content) != 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
var err error
|
||||
i.content, err = ioutil.ReadFile(i.Path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// StringifyContent returns the string version of Raw
|
||||
func (i FileInfo) StringifyContent() string {
|
||||
return string(i.content)
|
||||
}
|
||||
|
||||
// HumanSize returns the size of the file as a human-readable string
|
||||
// in IEC format (i.e. power of 2 or base 1024).
|
||||
func (i FileInfo) HumanSize() string {
|
||||
return humanize.IBytes(uint64(i.Size))
|
||||
}
|
||||
|
||||
// HumanModTime returns the modified time of the file as a human-readable string.
|
||||
func (i FileInfo) HumanModTime(format string) string {
|
||||
return i.ModTime.Format(format)
|
||||
}
|
||||
|
||||
// CanBeEdited checks if the extension of a file is supported by the editor
|
||||
func (i FileInfo) CanBeEdited() bool {
|
||||
return i.Type == "text"
|
||||
}
|
||||
|
|
@ -0,0 +1,184 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/url"
|
||||
"os"
|
||||
"path"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/mholt/caddy/caddyhttp/httpserver"
|
||||
)
|
||||
|
||||
// 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 relatively to a File System
|
||||
Path string
|
||||
// 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
|
||||
httpserver.Context `json:"-"`
|
||||
}
|
||||
|
||||
// GetListing gets the information about a specific directory and its files.
|
||||
func GetListing(u *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(context.TODO(), filePath, os.O_RDONLY, 0)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer file.Close()
|
||||
|
||||
// Reads the directory and gets the information about the files.
|
||||
files, err := file.Readdir(-1)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var (
|
||||
fileinfos []FileInfo
|
||||
dirCount, fileCount int
|
||||
)
|
||||
|
||||
for _, f := range files {
|
||||
name := f.Name()
|
||||
allowed := u.Allowed("/" + name)
|
||||
|
||||
if !allowed {
|
||||
continue
|
||||
}
|
||||
|
||||
if f.IsDir() {
|
||||
name += "/"
|
||||
dirCount++
|
||||
} else {
|
||||
fileCount++
|
||||
}
|
||||
|
||||
// Absolute URL
|
||||
url := url.URL{Path: baseURL + name}
|
||||
|
||||
i := FileInfo{
|
||||
Name: f.Name(),
|
||||
Size: f.Size(),
|
||||
ModTime: f.ModTime(),
|
||||
Mode: f.Mode(),
|
||||
IsDir: f.IsDir(),
|
||||
URL: url.String(),
|
||||
UserAllowed: allowed,
|
||||
}
|
||||
i.RetrieveFileType()
|
||||
|
||||
fileinfos = append(fileinfos, i)
|
||||
}
|
||||
|
||||
return &Listing{
|
||||
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)
|
||||
}
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
package filemanager
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"html/template"
|
||||
"log"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"github.com/hacdias/filemanager/variables"
|
||||
)
|
||||
|
||||
// Page contains the informations and functions needed to show the Page
|
||||
type Page struct {
|
||||
*PageInfo
|
||||
Minimal bool
|
||||
}
|
||||
|
||||
// PageInfo contains the information of a Page
|
||||
type PageInfo struct {
|
||||
Name string
|
||||
Path string
|
||||
IsDir bool
|
||||
User *User
|
||||
Config *FileManager
|
||||
Data interface{}
|
||||
Editor bool
|
||||
Display string
|
||||
}
|
||||
|
||||
// BreadcrumbMapItem ...
|
||||
type BreadcrumbMapItem struct {
|
||||
Name string
|
||||
URL string
|
||||
}
|
||||
|
||||
// BreadcrumbMap returns p.Path where every element is a map
|
||||
// of URLs and path segment names.
|
||||
func (i PageInfo) BreadcrumbMap() []BreadcrumbMapItem {
|
||||
result := []BreadcrumbMapItem{}
|
||||
|
||||
if len(i.Path) == 0 {
|
||||
return result
|
||||
}
|
||||
|
||||
// skip trailing slash
|
||||
lpath := i.Path
|
||||
if lpath[len(lpath)-1] == '/' {
|
||||
lpath = lpath[:len(lpath)-1]
|
||||
}
|
||||
|
||||
parts := strings.Split(lpath, "/")
|
||||
for i, part := range parts {
|
||||
if i == len(parts)-1 {
|
||||
continue
|
||||
}
|
||||
|
||||
if i == 0 && part == "" {
|
||||
result = append([]BreadcrumbMapItem{{
|
||||
Name: "/",
|
||||
URL: "/",
|
||||
}}, result...)
|
||||
continue
|
||||
}
|
||||
|
||||
result = append([]BreadcrumbMapItem{{
|
||||
Name: part,
|
||||
URL: strings.Join(parts[:i+1], "/") + "/",
|
||||
}}, result...)
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
// PreviousLink returns the path of the previous folder
|
||||
func (i PageInfo) PreviousLink() string {
|
||||
path := strings.TrimSuffix(i.Path, "/")
|
||||
path = strings.TrimPrefix(path, "/")
|
||||
path = i.Config.AbsoluteURL() + "/" + path
|
||||
path = path[0 : len(path)-len(i.Name)]
|
||||
|
||||
if len(path) < len(i.Config.AbsoluteURL()+"/") {
|
||||
return ""
|
||||
}
|
||||
|
||||
return path
|
||||
}
|
||||
|
||||
// Create the functions map, then the template, check for erros and
|
||||
// execute the template if there aren't errors
|
||||
var functions = template.FuncMap{
|
||||
"Defined": variables.FieldInStruct,
|
||||
"CSS": func(s string) template.CSS {
|
||||
return template.CSS(s)
|
||||
},
|
||||
"Marshal": func(v interface{}) template.JS {
|
||||
a, _ := json.Marshal(v)
|
||||
return template.JS(a)
|
||||
},
|
||||
"EncodeBase64": func(s string) string {
|
||||
return base64.StdEncoding.EncodeToString([]byte(s))
|
||||
},
|
||||
}
|
||||
|
||||
// PrintAsHTML formats the page in HTML and executes the template
|
||||
func (p Page) PrintAsHTML(w http.ResponseWriter, templates ...string) (int, error) {
|
||||
|
||||
if p.Minimal {
|
||||
templates = append(templates, "minimal")
|
||||
} else {
|
||||
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 := p.Config.Assets.Templates.String(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).Funcs(functions).Parse(Page)
|
||||
} else {
|
||||
tpl, err = tpl.Parse(string(Page))
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
log.Print(err)
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
}
|
||||
|
||||
buf := &bytes.Buffer{}
|
||||
err := tpl.Execute(buf, p.PageInfo)
|
||||
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
||||
_, err = buf.WriteTo(w)
|
||||
return http.StatusOK, err
|
||||
}
|
||||
|
||||
// PrintAsJSON prints the current Page information in JSON
|
||||
func (p Page) PrintAsJSON(w http.ResponseWriter) (int, error) {
|
||||
marsh, err := json.MarshalIndent(p.PageInfo.Data, "", " ")
|
||||
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
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
package variables
|
||||
|
||||
import "reflect"
|
||||
|
||||
// IsMap checks if some variable is a map
|
||||
func IsMap(sth interface{}) bool {
|
||||
return reflect.ValueOf(sth).Kind() == reflect.Map
|
||||
}
|
||||
|
||||
// IsSlice checks if some variable is a slice
|
||||
func IsSlice(sth interface{}) bool {
|
||||
return reflect.ValueOf(sth).Kind() == reflect.Slice
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
package variables
|
||||
|
||||
import "testing"
|
||||
|
||||
type interfaceToBool struct {
|
||||
Value interface{}
|
||||
Result bool
|
||||
}
|
||||
|
||||
var testIsMap = []*interfaceToBool{
|
||||
&interfaceToBool{"teste", false},
|
||||
&interfaceToBool{453478, false},
|
||||
&interfaceToBool{-984512, false},
|
||||
&interfaceToBool{true, false},
|
||||
&interfaceToBool{map[string]bool{}, true},
|
||||
&interfaceToBool{map[int]bool{}, true},
|
||||
&interfaceToBool{map[interface{}]bool{}, true},
|
||||
&interfaceToBool{[]string{}, false},
|
||||
}
|
||||
|
||||
func TestIsMap(t *testing.T) {
|
||||
for _, test := range testIsMap {
|
||||
if IsMap(test.Value) != test.Result {
|
||||
t.Errorf("Incorrect value on IsMap for %v; want: %v; got: %v", test.Value, test.Result, !test.Result)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var testIsSlice = []*interfaceToBool{
|
||||
&interfaceToBool{"teste", false},
|
||||
&interfaceToBool{453478, false},
|
||||
&interfaceToBool{-984512, false},
|
||||
&interfaceToBool{true, false},
|
||||
&interfaceToBool{map[string]bool{}, false},
|
||||
&interfaceToBool{map[int]bool{}, false},
|
||||
&interfaceToBool{map[interface{}]bool{}, false},
|
||||
&interfaceToBool{[]string{}, true},
|
||||
&interfaceToBool{[]int{}, true},
|
||||
&interfaceToBool{[]bool{}, true},
|
||||
&interfaceToBool{[]interface{}{}, true},
|
||||
}
|
||||
|
||||
func TestIsSlice(t *testing.T) {
|
||||
for _, test := range testIsSlice {
|
||||
if IsSlice(test.Value) != test.Result {
|
||||
t.Errorf("Incorrect value on IsSlice for %v; want: %v; got: %v", test.Value, test.Result, !test.Result)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
package variables
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"log"
|
||||
"reflect"
|
||||
)
|
||||
|
||||
// Dict allows to send more than one variable into a template.
|
||||
func Dict(values ...interface{}) (map[string]interface{}, error) {
|
||||
if len(values)%2 != 0 {
|
||||
return nil, errors.New("invalid dict call")
|
||||
}
|
||||
dict := make(map[string]interface{}, len(values)/2)
|
||||
for i := 0; i < len(values); i += 2 {
|
||||
key, ok := values[i].(string)
|
||||
if !ok {
|
||||
return nil, errors.New("dict keys must be strings")
|
||||
}
|
||||
dict[key] = values[i+1]
|
||||
}
|
||||
|
||||
return dict, nil
|
||||
}
|
||||
|
||||
// FieldInStruct checks if variable is defined in a struct.
|
||||
func FieldInStruct(data interface{}, field string) bool {
|
||||
t := reflect.Indirect(reflect.ValueOf(data)).Type()
|
||||
|
||||
if t.Kind() != reflect.Struct {
|
||||
log.Print("Non-struct type not allowed.")
|
||||
return false
|
||||
}
|
||||
|
||||
_, b := t.FieldByName(field)
|
||||
return b
|
||||
}
|
||||
|
||||
// StringInSlice checks if a slice contains a string.
|
||||
func StringInSlice(a string, list []string) (bool, int) {
|
||||
for i, b := range list {
|
||||
if b == a {
|
||||
return true, i
|
||||
}
|
||||
}
|
||||
return false, 0
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
package variables
|
||||
|
||||
import "testing"
|
||||
|
||||
type testFieldInStructData struct {
|
||||
f1 string
|
||||
f2 bool
|
||||
f3 int
|
||||
f4 func()
|
||||
}
|
||||
|
||||
type testFieldInStruct struct {
|
||||
data interface{}
|
||||
field string
|
||||
result bool
|
||||
}
|
||||
|
||||
var testFieldInStructCases = []testFieldInStruct{
|
||||
{testFieldInStructData{}, "f1", true},
|
||||
{testFieldInStructData{}, "f2", true},
|
||||
{testFieldInStructData{}, "f3", true},
|
||||
{testFieldInStructData{}, "f4", true},
|
||||
{testFieldInStructData{}, "f5", false},
|
||||
{[]string{}, "", false},
|
||||
{map[string]int{"oi": 4}, "", false},
|
||||
{"asa", "", false},
|
||||
{"int", "", false},
|
||||
}
|
||||
|
||||
func TestFieldInStruct(t *testing.T) {
|
||||
for _, pair := range testFieldInStructCases {
|
||||
v := FieldInStruct(pair.data, pair.field)
|
||||
if v != pair.result {
|
||||
t.Error(
|
||||
"For", pair.data,
|
||||
"expected", pair.result,
|
||||
"got", v,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue