455 lines
10 KiB
Go
455 lines
10 KiB
Go
package webfilesystem
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/mitchellh/mapstructure"
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
)
|
|
|
|
type WebFileSystem struct {
|
|
webfsCollection *mongo.Collection
|
|
// folders []*Folder
|
|
}
|
|
|
|
func NewWebFileSystem(mongoClient *mongo.Client, dBName string, fsCollectionName string) *WebFileSystem {
|
|
return &WebFileSystem{
|
|
webfsCollection: mongoClient.Database(dBName).Collection(fsCollectionName), // TODO Check collection is exist
|
|
}
|
|
}
|
|
|
|
func (fs *WebFileSystem) Read(path string) (*WebFSFile, error) {
|
|
splittedPath := fs.SplitPath(path)
|
|
filter := primitive.D{
|
|
{
|
|
Key: "name",
|
|
Value: splittedPath[len(splittedPath)-1],
|
|
},
|
|
}
|
|
file, err := fs.findFileInMongo(filter)
|
|
return file, err
|
|
}
|
|
|
|
func (fs *WebFileSystem) ReadByObjectID(objectId primitive.ObjectID) (*WebFSFile, error) {
|
|
filter := primitive.D{
|
|
{
|
|
Key: "_id",
|
|
Value: objectId,
|
|
},
|
|
}
|
|
file, err := fs.findFileInMongo(filter)
|
|
return file, err
|
|
}
|
|
|
|
func (fs *WebFileSystem) findFileInMongo(filter primitive.D) (*WebFSFile, error) {
|
|
res := fs.webfsCollection.FindOne(context.Background(), &filter)
|
|
file := WebFSFile{}
|
|
err := res.Decode(&file)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &file, nil
|
|
}
|
|
|
|
func (fs *WebFileSystem) List(path string) ([]*WebFSFile, error) {
|
|
// dirFile, err := fs.Read(fs.GetParentPath(path))
|
|
dirFile, err := fs.Read(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if dirFile.Type != "directory" {
|
|
return nil, errors.New("file is not a directory")
|
|
}
|
|
fileData := FolderData{}
|
|
err = mapstructure.Decode(dirFile.Data.(primitive.D).Map(), &fileData)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
files := []*WebFSFile{}
|
|
for _, child := range fileData.Children {
|
|
file, err := fs.ReadByObjectID(child)
|
|
if err != nil {
|
|
println(err.Error())
|
|
continue
|
|
}
|
|
files = append(files, file)
|
|
}
|
|
return files, nil
|
|
}
|
|
|
|
func (fs *WebFileSystem) CreateDirectory(path string) error {
|
|
splittedpath := fs.SplitPath(path)
|
|
parentPath := fs.GetParentPath(path)
|
|
parentDir, err := fs.Read(parentPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
directory := WebFSFile{
|
|
MongoId: primitive.NewObjectID(),
|
|
Name: splittedpath[len(splittedpath)-1],
|
|
Type: "directory",
|
|
Data: FolderData{
|
|
Parent: parentDir.MongoId,
|
|
Children: []primitive.ObjectID{},
|
|
},
|
|
}
|
|
|
|
fs.CreateFile(&directory, parentPath)
|
|
// res, err := fs.webfsCollection.InsertOne(context.Background(), &directory) //TODO
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
|
|
// fileId := fs.castInsertId(res)
|
|
// fs.insertFileToDirectory(fileId, parentDir.MongoId)
|
|
return nil
|
|
}
|
|
|
|
func (fs *WebFileSystem) UpdateFile(filePath string, update primitive.M) error {
|
|
file, err := fs.Read(filePath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if file.MongoId.IsZero() {
|
|
return errors.New("mongo id is zero")
|
|
}
|
|
filter := primitive.M{
|
|
"_id": file.MongoId,
|
|
}
|
|
|
|
_, err = fs.webfsCollection.UpdateOne(context.Background(), filter, primitive.M{"$set": update})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
}
|
|
|
|
func (fs *WebFileSystem) CreateFile(file *WebFSFile, parentPath string) error {
|
|
//TODO Check file existance
|
|
parentDir, err := fs.Read(parentPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
res, err := fs.webfsCollection.InsertOne(context.Background(), &file)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_ = parentDir
|
|
fileId := fs.castInsertId(res)
|
|
fs.insertFileToDirectory(fileId, parentDir.MongoId)
|
|
return nil
|
|
}
|
|
|
|
func (fs *WebFileSystem) castInsertId(res *mongo.InsertOneResult) primitive.ObjectID {
|
|
return res.InsertedID.(primitive.ObjectID)
|
|
}
|
|
|
|
func (fs *WebFileSystem) insertFileToDirectory(fileId primitive.ObjectID, directoryId primitive.ObjectID) error {
|
|
dir, err := fs.ReadByObjectID(directoryId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
//TODO check if file exist
|
|
fileData := FolderData{}
|
|
err = mapstructure.Decode(dir.Data.(primitive.D).Map(), &fileData)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fileData.Children = append(fileData.Children, fileId)
|
|
|
|
fs.webfsCollection.UpdateByID(context.Background(), directoryId, bson.M{"$set": bson.M{"data": fileData}})
|
|
return nil
|
|
}
|
|
|
|
func (fs *WebFileSystem) SplitPath(path string) []string {
|
|
resPath := []string{}
|
|
splittedPath := strings.Split(path, "/")
|
|
splittedPath[0] = "/"
|
|
for _, split := range splittedPath {
|
|
if split != "" {
|
|
resPath = append(resPath, split)
|
|
}
|
|
}
|
|
return resPath
|
|
}
|
|
|
|
func (fs *WebFileSystem) GetExtension(filename string) string {
|
|
// extension := []string{}
|
|
splittedName := strings.Split(filename, ".")
|
|
|
|
return splittedName[len(splittedName)-1]
|
|
}
|
|
|
|
func (fs *WebFileSystem) GetParentPath(path string) string {
|
|
splittedPath := fs.SplitPath(path)
|
|
parentPath := strings.Join(splittedPath[:len(splittedPath)-1], "/")
|
|
return parentPath
|
|
}
|
|
|
|
func (fs *WebFileSystem) Delete(filePath string) error {
|
|
splittedPath := fs.SplitPath(filePath)
|
|
parentPath := strings.Join(splittedPath[:len(splittedPath)-1], "/")
|
|
|
|
file, err := fs.Read(filePath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
parentDir, err := fs.Read(parentPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
parentDir.Data.(primitive.D).Map()
|
|
|
|
// update:= primitive.M{
|
|
// "data.children":
|
|
// }
|
|
// filter := primitive.M{}
|
|
res, err := fs.webfsCollection.UpdateByID(context.Background(), parentDir.MongoId, primitive.M{"$unset": bson.M{"data.children." + file.MongoId.String(): ""}})
|
|
// res, err := fs.webfsCollection.UpdateOne(context.Background(), filter, primitive.M{"$unset": bson.M{"data.children." + file.MongoId.String(): ""}})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if res.MatchedCount < 1 {
|
|
return errors.New("no documents found")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (fs *WebFileSystem) Route(route *gin.RouterGroup) {
|
|
route.POST("/upload", func(ctx *gin.Context) { //TODO To PUT request
|
|
// fileName := ctx.Query("fileName")
|
|
// if fileName == "" {
|
|
// ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
|
|
// return
|
|
// }
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
// single file
|
|
file, _ := ctx.FormFile("file")
|
|
if file == nil {
|
|
ctx.String(http.StatusBadRequest, "file is nil")
|
|
return
|
|
}
|
|
// generateMins := c.Param("generateMins")
|
|
// log.Println(file.Filename)
|
|
|
|
// Upload the file to specific dst.
|
|
dst := "./test-img/" + file.Filename
|
|
ctx.SaveUploadedFile(file, dst)
|
|
|
|
//TODO: Not Save to disk
|
|
err := fs.UploadFile(dst, path)
|
|
if err != nil {
|
|
ctx.String(http.StatusInternalServerError, "TODO") //TODO
|
|
return
|
|
}
|
|
|
|
// webFsCollection.CreateMiniatures("./test-img/", file.Filename)
|
|
|
|
// webfs.CreateFile(&img, "/home/user/")
|
|
|
|
ctx.Status(http.StatusCreated)
|
|
})
|
|
|
|
route.GET("writeFile", func(ctx *gin.Context) {
|
|
parentPath := ctx.Query("parentPath")
|
|
if parentPath == "" {
|
|
ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
file := WebFSFile{
|
|
MongoId: primitive.NewObjectID(),
|
|
Name: "pp",
|
|
Type: "test",
|
|
Data: nil,
|
|
}
|
|
err := fs.CreateFile(&file, parentPath)
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, "OK")
|
|
})
|
|
route.GET("createDir", func(ctx *gin.Context) {
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
err := fs.CreateDirectory(path)
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, "OK")
|
|
})
|
|
|
|
route.GET("list", func(ctx *gin.Context) {
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
files, err := fs.List(path)
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, &files)
|
|
})
|
|
|
|
route.GET("read", func(ctx *gin.Context) {
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
file, err := fs.Read(path)
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, &file)
|
|
})
|
|
|
|
route.GET("validate", func(ctx *gin.Context) {
|
|
err := fs.Validate()
|
|
if err != nil {
|
|
ctx.Status(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
ctx.Status(http.StatusOK)
|
|
})
|
|
|
|
route.GET("delete", func(ctx *gin.Context) {
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.Status(http.StatusBadRequest) //TODO
|
|
return
|
|
}
|
|
err := fs.Delete(path)
|
|
if err != nil {
|
|
ctx.Status(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
ctx.Status(http.StatusOK)
|
|
})
|
|
}
|
|
|
|
func (fs *WebFileSystem) Validate() error {
|
|
filter := primitive.D{
|
|
{
|
|
Key: "type",
|
|
Value: "directory",
|
|
},
|
|
}
|
|
cur, err := fs.webfsCollection.Find(context.Background(), filter)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer cur.Close(context.Background())
|
|
|
|
directories := []*WebFSFile{}
|
|
|
|
for cur.Next(context.Background()) {
|
|
dir := &WebFSFile{}
|
|
|
|
err = cur.Decode(dir)
|
|
if err != nil {
|
|
println(err.Error())
|
|
return err
|
|
}
|
|
directories = append(directories, dir)
|
|
}
|
|
|
|
for _, d := range directories {
|
|
fs.validateDir(d)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (fs *WebFileSystem) validateDir(dir *WebFSFile) error {
|
|
kek := dir.Data.(primitive.D).Map()["children"].(primitive.A)
|
|
_ = kek
|
|
|
|
children := []primitive.ObjectID{}
|
|
counter := 0
|
|
for _, v := range kek {
|
|
_, err := fs.ReadByObjectID(v.(primitive.ObjectID))
|
|
if err != nil {
|
|
counter++
|
|
} else {
|
|
children = append(children, v.(primitive.ObjectID))
|
|
}
|
|
}
|
|
if counter > 0 {
|
|
println(dir.Name + " broken iDs: " + strconv.Itoa(counter))
|
|
_, err := fs.webfsCollection.UpdateByID(context.Background(), dir.MongoId, bson.M{"$set": bson.M{"data.children": children}})
|
|
if err != nil {
|
|
println(err.Error())
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type WebFSFile struct {
|
|
MongoId primitive.ObjectID `bson:"_id" json:"-"`
|
|
Name string `bson:"name" json:"name"`
|
|
Type string `bson:"type" json:"type"`
|
|
Data interface{} `bson:"data" json:"-"`
|
|
Icon string `bson:"-" json:"icon"`
|
|
}
|
|
|
|
type FolderData struct {
|
|
Parent primitive.ObjectID `bson:"parent"`
|
|
Children []primitive.ObjectID `bson:"children"`
|
|
}
|
|
|
|
type File interface {
|
|
GetUuid() string
|
|
GetFileName() string
|
|
}
|
|
|
|
type Image struct {
|
|
}
|
|
|
|
type Exec struct {
|
|
WebFSFile
|
|
}
|
|
|
|
func (e *Exec) GetFileName() string {
|
|
return e.Name
|
|
}
|
|
|
|
// type WebFSFile2 interface {
|
|
// GetName() string
|
|
// GetType() string
|
|
// GetData() interface{}
|
|
// }
|