|
package handles |
|
|
|
import ( |
|
"fmt" |
|
stdpath "path" |
|
"strings" |
|
"time" |
|
|
|
"github.com/alist-org/alist/v3/internal/conf" |
|
"github.com/alist-org/alist/v3/internal/errs" |
|
"github.com/alist-org/alist/v3/internal/fs" |
|
"github.com/alist-org/alist/v3/internal/model" |
|
"github.com/alist-org/alist/v3/internal/op" |
|
"github.com/alist-org/alist/v3/internal/setting" |
|
"github.com/alist-org/alist/v3/internal/sign" |
|
"github.com/alist-org/alist/v3/pkg/utils" |
|
"github.com/alist-org/alist/v3/server/common" |
|
"github.com/gin-gonic/gin" |
|
"github.com/pkg/errors" |
|
) |
|
|
|
type ListReq struct { |
|
model.PageReq |
|
Path string `json:"path" form:"path"` |
|
Password string `json:"password" form:"password"` |
|
Refresh bool `json:"refresh"` |
|
} |
|
|
|
type DirReq struct { |
|
Path string `json:"path" form:"path"` |
|
Password string `json:"password" form:"password"` |
|
ForceRoot bool `json:"force_root" form:"force_root"` |
|
} |
|
|
|
type ObjResp struct { |
|
Name string `json:"name"` |
|
Size int64 `json:"size"` |
|
IsDir bool `json:"is_dir"` |
|
Modified time.Time `json:"modified"` |
|
Created time.Time `json:"created"` |
|
Sign string `json:"sign"` |
|
Thumb string `json:"thumb"` |
|
Type int `json:"type"` |
|
HashInfoStr string `json:"hashinfo"` |
|
HashInfo map[*utils.HashType]string `json:"hash_info"` |
|
} |
|
|
|
type FsListResp struct { |
|
Content []ObjResp `json:"content"` |
|
Total int64 `json:"total"` |
|
Readme string `json:"readme"` |
|
Header string `json:"header"` |
|
Write bool `json:"write"` |
|
Provider string `json:"provider"` |
|
} |
|
|
|
func FsList(c *gin.Context) { |
|
var req ListReq |
|
if err := c.ShouldBind(&req); err != nil { |
|
common.ErrorResp(c, err, 400) |
|
return |
|
} |
|
req.Validate() |
|
user := c.MustGet("user").(*model.User) |
|
reqPath, err := user.JoinPath(req.Path) |
|
if err != nil { |
|
common.ErrorResp(c, err, 403) |
|
return |
|
} |
|
meta, err := op.GetNearestMeta(reqPath) |
|
if err != nil { |
|
if !errors.Is(errors.Cause(err), errs.MetaNotFound) { |
|
common.ErrorResp(c, err, 500, true) |
|
return |
|
} |
|
} |
|
c.Set("meta", meta) |
|
if !common.CanAccess(user, meta, reqPath, req.Password) { |
|
common.ErrorStrResp(c, "password is incorrect or you have no permission", 403) |
|
return |
|
} |
|
if !user.CanWrite() && !common.CanWrite(meta, reqPath) && req.Refresh { |
|
common.ErrorStrResp(c, "Refresh without permission", 403) |
|
return |
|
} |
|
objs, err := fs.List(c, reqPath, &fs.ListArgs{Refresh: req.Refresh}) |
|
if err != nil { |
|
common.ErrorResp(c, err, 500) |
|
return |
|
} |
|
total, objs := pagination(objs, &req.PageReq) |
|
provider := "unknown" |
|
storage, err := fs.GetStorage(reqPath, &fs.GetStoragesArgs{}) |
|
if err == nil { |
|
provider = storage.GetStorage().Driver |
|
} |
|
common.SuccessResp(c, FsListResp{ |
|
Content: toObjsResp(objs, reqPath, isEncrypt(meta, reqPath)), |
|
Total: int64(total), |
|
Readme: getReadme(meta, reqPath), |
|
Header: getHeader(meta, reqPath), |
|
Write: user.CanWrite() || common.CanWrite(meta, reqPath), |
|
Provider: provider, |
|
}) |
|
} |
|
|
|
func FsDirs(c *gin.Context) { |
|
var req DirReq |
|
if err := c.ShouldBind(&req); err != nil { |
|
common.ErrorResp(c, err, 400) |
|
return |
|
} |
|
user := c.MustGet("user").(*model.User) |
|
reqPath := req.Path |
|
if req.ForceRoot { |
|
if !user.IsAdmin() { |
|
common.ErrorStrResp(c, "Permission denied", 403) |
|
return |
|
} |
|
} else { |
|
tmp, err := user.JoinPath(req.Path) |
|
if err != nil { |
|
common.ErrorResp(c, err, 403) |
|
return |
|
} |
|
reqPath = tmp |
|
} |
|
meta, err := op.GetNearestMeta(reqPath) |
|
if err != nil { |
|
if !errors.Is(errors.Cause(err), errs.MetaNotFound) { |
|
common.ErrorResp(c, err, 500, true) |
|
return |
|
} |
|
} |
|
c.Set("meta", meta) |
|
if !common.CanAccess(user, meta, reqPath, req.Password) { |
|
common.ErrorStrResp(c, "password is incorrect or you have no permission", 403) |
|
return |
|
} |
|
objs, err := fs.List(c, reqPath, &fs.ListArgs{}) |
|
if err != nil { |
|
common.ErrorResp(c, err, 500) |
|
return |
|
} |
|
dirs := filterDirs(objs) |
|
common.SuccessResp(c, dirs) |
|
} |
|
|
|
type DirResp struct { |
|
Name string `json:"name"` |
|
Modified time.Time `json:"modified"` |
|
} |
|
|
|
func filterDirs(objs []model.Obj) []DirResp { |
|
var dirs []DirResp |
|
for _, obj := range objs { |
|
if obj.IsDir() { |
|
dirs = append(dirs, DirResp{ |
|
Name: obj.GetName(), |
|
Modified: obj.ModTime(), |
|
}) |
|
} |
|
} |
|
return dirs |
|
} |
|
|
|
func getReadme(meta *model.Meta, path string) string { |
|
if meta != nil && (utils.PathEqual(meta.Path, path) || meta.RSub) { |
|
return meta.Readme |
|
} |
|
return "" |
|
} |
|
|
|
func getHeader(meta *model.Meta, path string) string { |
|
if meta != nil && (utils.PathEqual(meta.Path, path) || meta.HeaderSub) { |
|
return meta.Header |
|
} |
|
return "" |
|
} |
|
|
|
func isEncrypt(meta *model.Meta, path string) bool { |
|
if common.IsStorageSignEnabled(path) { |
|
return true |
|
} |
|
if meta == nil || meta.Password == "" { |
|
return false |
|
} |
|
if !utils.PathEqual(meta.Path, path) && !meta.PSub { |
|
return false |
|
} |
|
return true |
|
} |
|
|
|
func pagination(objs []model.Obj, req *model.PageReq) (int, []model.Obj) { |
|
pageIndex, pageSize := req.Page, req.PerPage |
|
total := len(objs) |
|
start := (pageIndex - 1) * pageSize |
|
if start > total { |
|
return total, []model.Obj{} |
|
} |
|
end := start + pageSize |
|
if end > total { |
|
end = total |
|
} |
|
return total, objs[start:end] |
|
} |
|
|
|
func toObjsResp(objs []model.Obj, parent string, encrypt bool) []ObjResp { |
|
var resp []ObjResp |
|
for _, obj := range objs { |
|
thumb, _ := model.GetThumb(obj) |
|
resp = append(resp, ObjResp{ |
|
Name: obj.GetName(), |
|
Size: obj.GetSize(), |
|
IsDir: obj.IsDir(), |
|
Modified: obj.ModTime(), |
|
Created: obj.CreateTime(), |
|
HashInfoStr: obj.GetHash().String(), |
|
HashInfo: obj.GetHash().Export(), |
|
Sign: common.Sign(obj, parent, encrypt), |
|
Thumb: thumb, |
|
Type: utils.GetObjType(obj.GetName(), obj.IsDir()), |
|
}) |
|
} |
|
return resp |
|
} |
|
|
|
type FsGetReq struct { |
|
Path string `json:"path" form:"path"` |
|
Password string `json:"password" form:"password"` |
|
} |
|
|
|
type FsGetResp struct { |
|
ObjResp |
|
RawURL string `json:"raw_url"` |
|
Readme string `json:"readme"` |
|
Header string `json:"header"` |
|
Provider string `json:"provider"` |
|
Related []ObjResp `json:"related"` |
|
} |
|
|
|
func FsGet(c *gin.Context) { |
|
var req FsGetReq |
|
if err := c.ShouldBind(&req); err != nil { |
|
common.ErrorResp(c, err, 400) |
|
return |
|
} |
|
user := c.MustGet("user").(*model.User) |
|
reqPath, err := user.JoinPath(req.Path) |
|
if err != nil { |
|
common.ErrorResp(c, err, 403) |
|
return |
|
} |
|
meta, err := op.GetNearestMeta(reqPath) |
|
if err != nil { |
|
if !errors.Is(errors.Cause(err), errs.MetaNotFound) { |
|
common.ErrorResp(c, err, 500) |
|
return |
|
} |
|
} |
|
c.Set("meta", meta) |
|
if !common.CanAccess(user, meta, reqPath, req.Password) { |
|
common.ErrorStrResp(c, "password is incorrect or you have no permission", 403) |
|
return |
|
} |
|
obj, err := fs.Get(c, reqPath, &fs.GetArgs{}) |
|
if err != nil { |
|
common.ErrorResp(c, err, 500) |
|
return |
|
} |
|
var rawURL string |
|
|
|
storage, err := fs.GetStorage(reqPath, &fs.GetStoragesArgs{}) |
|
provider := "unknown" |
|
if err == nil { |
|
provider = storage.Config().Name |
|
} |
|
if !obj.IsDir() { |
|
if err != nil { |
|
common.ErrorResp(c, err, 500) |
|
return |
|
} |
|
if storage.Config().MustProxy() || storage.GetStorage().WebProxy { |
|
query := "" |
|
if isEncrypt(meta, reqPath) || setting.GetBool(conf.SignAll) { |
|
query = "?sign=" + sign.Sign(reqPath) |
|
} |
|
if storage.GetStorage().DownProxyUrl != "" { |
|
rawURL = fmt.Sprintf("%s%s?sign=%s", |
|
strings.Split(storage.GetStorage().DownProxyUrl, "\n")[0], |
|
utils.EncodePath(reqPath, true), |
|
sign.Sign(reqPath)) |
|
} else { |
|
rawURL = fmt.Sprintf("%s/p%s%s", |
|
common.GetApiUrl(c.Request), |
|
utils.EncodePath(reqPath, true), |
|
query) |
|
} |
|
} else { |
|
|
|
if url, ok := model.GetUrl(obj); ok { |
|
rawURL = url |
|
} else { |
|
|
|
link, _, err := fs.Link(c, reqPath, model.LinkArgs{ |
|
IP: c.ClientIP(), |
|
Header: c.Request.Header, |
|
HttpReq: c.Request, |
|
}) |
|
if err != nil { |
|
common.ErrorResp(c, err, 500) |
|
return |
|
} |
|
rawURL = link.URL |
|
} |
|
} |
|
} |
|
var related []model.Obj |
|
parentPath := stdpath.Dir(reqPath) |
|
sameLevelFiles, err := fs.List(c, parentPath, &fs.ListArgs{}) |
|
if err == nil { |
|
related = filterRelated(sameLevelFiles, obj) |
|
} |
|
parentMeta, _ := op.GetNearestMeta(parentPath) |
|
thumb, _ := model.GetThumb(obj) |
|
common.SuccessResp(c, FsGetResp{ |
|
ObjResp: ObjResp{ |
|
Name: obj.GetName(), |
|
Size: obj.GetSize(), |
|
IsDir: obj.IsDir(), |
|
Modified: obj.ModTime(), |
|
Created: obj.CreateTime(), |
|
HashInfoStr: obj.GetHash().String(), |
|
HashInfo: obj.GetHash().Export(), |
|
Sign: common.Sign(obj, parentPath, isEncrypt(meta, reqPath)), |
|
Type: utils.GetFileType(obj.GetName()), |
|
Thumb: thumb, |
|
}, |
|
RawURL: rawURL, |
|
Readme: getReadme(meta, reqPath), |
|
Header: getHeader(meta, reqPath), |
|
Provider: provider, |
|
Related: toObjsResp(related, parentPath, isEncrypt(parentMeta, parentPath)), |
|
}) |
|
} |
|
|
|
func filterRelated(objs []model.Obj, obj model.Obj) []model.Obj { |
|
var related []model.Obj |
|
nameWithoutExt := strings.TrimSuffix(obj.GetName(), stdpath.Ext(obj.GetName())) |
|
for _, o := range objs { |
|
if o.GetName() == obj.GetName() { |
|
continue |
|
} |
|
if strings.HasPrefix(o.GetName(), nameWithoutExt) { |
|
related = append(related, o) |
|
} |
|
} |
|
return related |
|
} |
|
|
|
type FsOtherReq struct { |
|
model.FsOtherArgs |
|
Password string `json:"password" form:"password"` |
|
} |
|
|
|
func FsOther(c *gin.Context) { |
|
var req FsOtherReq |
|
if err := c.ShouldBind(&req); err != nil { |
|
common.ErrorResp(c, err, 400) |
|
return |
|
} |
|
user := c.MustGet("user").(*model.User) |
|
var err error |
|
req.Path, err = user.JoinPath(req.Path) |
|
if err != nil { |
|
common.ErrorResp(c, err, 403) |
|
return |
|
} |
|
meta, err := op.GetNearestMeta(req.Path) |
|
if err != nil { |
|
if !errors.Is(errors.Cause(err), errs.MetaNotFound) { |
|
common.ErrorResp(c, err, 500) |
|
return |
|
} |
|
} |
|
c.Set("meta", meta) |
|
if !common.CanAccess(user, meta, req.Path, req.Password) { |
|
common.ErrorStrResp(c, "password is incorrect or you have no permission", 403) |
|
return |
|
} |
|
res, err := fs.Other(c, req.FsOtherArgs) |
|
if err != nil { |
|
common.ErrorResp(c, err, 500) |
|
return |
|
} |
|
common.SuccessResp(c, res) |
|
} |
|
|
