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{} // }