2020-02-24 18:07:47 +00:00
|
|
|
package router
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
2020-03-30 20:51:26 +01:00
|
|
|
"fmt"
|
2020-02-24 18:07:47 +00:00
|
|
|
"github.com/gmemstr/nas/files"
|
|
|
|
"github.com/gorilla/mux"
|
|
|
|
"net/http"
|
2020-04-03 21:17:43 +01:00
|
|
|
"net/url"
|
2020-04-15 12:16:27 +01:00
|
|
|
"os"
|
2020-03-22 00:18:19 +00:00
|
|
|
"sort"
|
|
|
|
"strings"
|
2020-04-15 12:16:27 +01:00
|
|
|
"time"
|
2020-02-24 18:07:47 +00:00
|
|
|
)
|
|
|
|
|
2020-04-02 20:50:39 +01:00
|
|
|
func HandleProvider() Handler {
|
|
|
|
return func(context *Context, w http.ResponseWriter, r *http.Request) *HTTPError {
|
2020-02-24 18:07:47 +00:00
|
|
|
vars := mux.Vars(r)
|
2020-04-02 20:50:39 +01:00
|
|
|
providerCodename := vars["provider"]
|
|
|
|
providerCodename = strings.Replace(providerCodename, "/", "", -1)
|
|
|
|
provider := *files.Providers[providerCodename]
|
2020-02-24 18:07:47 +00:00
|
|
|
|
2020-04-12 22:10:51 +01:00
|
|
|
// Directory listing or serve file.
|
2020-04-02 20:50:39 +01:00
|
|
|
if r.Method == "GET" {
|
2020-02-24 18:07:47 +00:00
|
|
|
fileList := provider.GetDirectory("")
|
|
|
|
if vars["file"] != "" {
|
2020-04-03 21:17:43 +01:00
|
|
|
filename, err := url.QueryUnescape(vars["file"])
|
|
|
|
if err != nil {
|
|
|
|
return &HTTPError{
|
|
|
|
Message: fmt.Sprintf("error determining filetype for %s\n", filename),
|
|
|
|
StatusCode: http.StatusInternalServerError,
|
|
|
|
}
|
|
|
|
}
|
2020-04-15 12:16:27 +01:00
|
|
|
fileType, location := provider.ObjectInfo(filename)
|
|
|
|
|
2020-03-15 23:48:37 +00:00
|
|
|
if fileType == "" {
|
2020-04-02 20:50:39 +01:00
|
|
|
return &HTTPError{
|
2020-04-03 21:17:43 +01:00
|
|
|
Message: fmt.Sprintf("error determining filetype for %s\n", filename),
|
2020-04-02 20:50:39 +01:00
|
|
|
StatusCode: http.StatusInternalServerError,
|
|
|
|
}
|
2020-03-15 23:48:37 +00:00
|
|
|
}
|
|
|
|
if fileType == "file" {
|
2020-04-15 12:16:27 +01:00
|
|
|
if location == "local" {
|
|
|
|
rp := provider.ViewFile(filename)
|
|
|
|
if rp != "" {
|
|
|
|
f, _ := os.Open(rp)
|
|
|
|
http.ServeContent(w, r, filename, time.Time{}, f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if location == "remote" {
|
|
|
|
provider.RemoteFile(filename, w)
|
|
|
|
}
|
2020-03-15 23:48:37 +00:00
|
|
|
return nil
|
|
|
|
}
|
2020-04-03 21:17:43 +01:00
|
|
|
fileList = provider.GetDirectory(filename)
|
2020-02-24 18:07:47 +00:00
|
|
|
}
|
|
|
|
data, err := json.Marshal(fileList)
|
|
|
|
if err != nil {
|
2020-04-02 20:50:39 +01:00
|
|
|
return &HTTPError{
|
|
|
|
Message: fmt.Sprintf("error fetching filelisting for %s\n", vars["file"]),
|
|
|
|
StatusCode: http.StatusInternalServerError,
|
|
|
|
}
|
2020-02-24 18:07:47 +00:00
|
|
|
}
|
|
|
|
w.Write(data)
|
|
|
|
}
|
2020-04-02 20:50:39 +01:00
|
|
|
|
2020-04-12 22:10:51 +01:00
|
|
|
// File upload or directory creation.
|
2020-03-30 20:51:26 +01:00
|
|
|
if r.Method == "POST" {
|
2020-04-12 22:10:51 +01:00
|
|
|
xType := r.Header.Get("X-NAS-Type")
|
|
|
|
|
|
|
|
if xType == "file" || xType == ""{
|
|
|
|
err := r.ParseMultipartForm(32 << 20)
|
|
|
|
if err != nil {
|
|
|
|
return &HTTPError{
|
|
|
|
Message: fmt.Sprintf("error parsing form for %s\n", vars["file"]),
|
|
|
|
StatusCode: http.StatusInternalServerError,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
file, handler, err := r.FormFile("file")
|
|
|
|
defer file.Close()
|
|
|
|
|
|
|
|
success := provider.SaveFile(file, handler.Filename, vars["file"])
|
|
|
|
if !success {
|
|
|
|
return &HTTPError{
|
|
|
|
Message: fmt.Sprintf("error saving file %s\n", vars["file"]),
|
|
|
|
StatusCode: http.StatusInternalServerError,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
w.Write([]byte("saved file"))
|
|
|
|
}
|
|
|
|
if xType == "directory" {
|
|
|
|
dirname := vars["file"]
|
|
|
|
success := provider.CreateDirectory(dirname)
|
|
|
|
if !success {
|
|
|
|
return &HTTPError{
|
|
|
|
Message: fmt.Sprintf("error creating directory %s\n", dirname),
|
|
|
|
StatusCode: http.StatusInternalServerError,
|
|
|
|
}
|
2020-04-02 20:50:39 +01:00
|
|
|
}
|
2020-04-12 22:10:51 +01:00
|
|
|
_, _ = w.Write([]byte("created directory"))
|
2020-03-30 20:51:26 +01:00
|
|
|
}
|
2020-04-12 22:10:51 +01:00
|
|
|
}
|
2020-03-30 20:51:26 +01:00
|
|
|
|
2020-04-12 22:10:51 +01:00
|
|
|
// Delete file.
|
|
|
|
if r.Method == "DELETE" {
|
|
|
|
path := vars["file"]
|
|
|
|
success := provider.Delete(path)
|
2020-03-30 20:51:26 +01:00
|
|
|
if !success {
|
2020-04-02 20:50:39 +01:00
|
|
|
return &HTTPError{
|
2020-04-12 22:10:51 +01:00
|
|
|
Message: fmt.Sprintf("error deleting %s\n", path),
|
2020-04-02 20:50:39 +01:00
|
|
|
StatusCode: http.StatusInternalServerError,
|
|
|
|
}
|
2020-03-30 20:51:26 +01:00
|
|
|
}
|
2020-04-12 22:10:51 +01:00
|
|
|
_, _ = w.Write([]byte("deleted"))
|
2020-03-30 20:51:26 +01:00
|
|
|
}
|
2020-02-24 18:07:47 +00:00
|
|
|
|
2020-04-12 22:10:51 +01:00
|
|
|
return nil
|
2020-02-24 18:07:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-02 20:50:39 +01:00
|
|
|
func ListProviders() Handler {
|
|
|
|
return func(context *Context, w http.ResponseWriter, r *http.Request) *HTTPError {
|
2020-03-22 00:18:19 +00:00
|
|
|
var providers []string
|
|
|
|
for v, _ := range files.ProviderConfig {
|
|
|
|
providers = append(providers, v)
|
|
|
|
}
|
|
|
|
sort.Strings(providers)
|
|
|
|
data, err := json.Marshal(providers)
|
|
|
|
if err != nil {
|
2020-04-02 20:50:39 +01:00
|
|
|
return &HTTPError{
|
|
|
|
Message: fmt.Sprintf("error provider listing"),
|
|
|
|
StatusCode: http.StatusInternalServerError,
|
|
|
|
}
|
2020-03-22 00:18:19 +00:00
|
|
|
}
|
|
|
|
w.Write(data)
|
2020-02-24 18:07:47 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|