Added more typescript files, fixed some error correcting

backend/db/utils/fileUtils/index.js

@@ -1,167 +0,0 @@
-import mongoose from "../../mongoose";
-const conn = mongoose.connection;
-const ObjectID = require('mongodb').ObjectID
-
-const DbUtil = function() {
-
-    this.getPublicFile = async(fileID) => {
-
-        let file = await conn.db.collection("fs.files")
-        .findOne({"_id": ObjectID(fileID)});
-
-        return file;
-    }
-
-    this.removeOneTimePublicLink = async(fileID) => {
-
-        const file = await conn.db.collection("fs.files")
-                .findOneAndUpdate({"_id": ObjectID(fileID)}, {
-                    "$unset": {"metadata.linkType": "", "metadata.link": ""}});
-
-        return file;
-    
-    }
-
-    this.removeLink = async(fileID, userID) => {
-
-        const file = await conn.db.collection("fs.files")
-            .findOneAndUpdate({"_id": ObjectID(fileID), 
-            "metadata.owner": userID}, 
-            {"$unset": {"metadata.linkType": "", "metadata.link": ""}})
-
-        return file;
-    }
-
-    this.makePublic = async(fileID, userID, token) => {
-
-        const file = await conn.db.collection("fs.files")
-            .findOneAndUpdate({"_id": ObjectID(fileID), 
-            "metadata.owner": userID}, 
-            {"$set": {"metadata.linkType": "public", "metadata.link": token}})
-
-        return file;
-    }
-
-    this.getPublicInfo = async(fileID, tempToken) => {
-
-        const file = await conn.db.collection("fs.files")
-            .findOne({"_id": ObjectID(fileID), "metadata.link": tempToken})
-
-        return file;
-    }
-
-    this.makeOneTimePublic = async(fileID, userID, token) => {
-
-        const file = await conn.db.collection("fs.files")
-            .findOneAndUpdate({"_id": ObjectID(fileID), 
-            "metadata.owner": userID}, 
-            {"$set": {"metadata.linkType": "one", "metadata.link": token}})
-
-        return file;
-    }
-
-    this.getFileInfo = async(fileID, userID) => {
-
-        const file = await conn.db.collection("fs.files")
-            .findOne({"metadata.owner": userID, "_id": ObjectID(fileID)});
-
-        return file;
-    }
-
-    this.getQuickList = async(userID) => {
-
-        const fileList = await conn.db.collection("fs.files")
-            .find({"metadata.owner": userID})
-            .sort({uploadDate: -1})
-            .limit(10)
-            .toArray();
-
-        return fileList;
-    }
-
-    this.getList = async(queryObj, sortBy, limit) => {
-
-        const fileList = await conn.db.collection("fs.files")
-            .find(queryObj)
-            .sort(sortBy)
-            .limit(limit)
-            .toArray();
-
-
-        return fileList;
-    }
-
-    this.removeTempToken = async(user, tempToken) => {
-    
-        user.tempTokens = user.tempTokens.filter((filterToken) => {
-            
-            return filterToken.token !== tempToken;
-        });
-
-        return user;
-    }
-
-    this.removeTranscodeVideo = async(fileID, userID) => {
-
-        const file = await conn.db.collection("fs.files")
-            .findOneAndUpdate({"_id": ObjectID(fileID), "metadata.owner": userID}, 
-            {"$unset": {"metadata.transcoded": "", "metadata.transcodedIV": "", 
-            "metadata.transcoded_size": "", "metadata.transcodedID": ""}})
-    
-        return file;
-    }
-
-    this.getFileSearchList = async(userID, searchQuery) => {
-
-        const fileList = await conn.db.collection("fs.files")
-        .find({"metadata.owner": userID, "filename": searchQuery})
-        .limit(10)
-        .toArray();
-
-        return fileList;
-    }
-
-    this.renameFile = async(fileID, userID, title) => {
-
-        const file = await conn.db.collection("fs.files")
-            .findOneAndUpdate({"_id": ObjectID(fileID), 
-            "metadata.owner": userID}, {"$set": {"filename": title}})
-    
-        return file;
-    }
-
-    this.moveFile = async(fileID, userID, parent, parentList) => {
-
-        const file = await conn.db.collection("fs.files")
-            .findOneAndUpdate({"_id": ObjectID(fileID), 
-            "metadata.owner": userID}, {"$set": {"metadata.parent": parent, "metadata.parentList": parentList}})
-    
-        return file;
-    }
-
-    this.getFileListByParent = async(userID, parentListString) => {
-
-        const fileList = await conn.db.collection("fs.files")
-            .find({"metadata.owner": userID, 
-            "metadata.parentList":  {$regex : `.*${parentListString}.*`}}).toArray();
-        
-        return fileList;
-    }
-
-    this.getFileListByOwner = async(userID) => {
-
-        const fileList = await conn.db.collection("fs.files")
-                        .find({"metadata.owner": userID}).toArray();
-
-        return fileList;
-    }
-
-    this.removeChunksByID = async(fileID) => {
-
-        await conn.db.collection("fs.chunks").deleteMany({files_id: fileID});
-    }
-
-}
-
-module.exports = DbUtil;
-export default DbUtil;

backend/db/utils/fileUtils/index.ts

@@ -0,0 +1,322 @@
+import mongoose from "../../mongoose";
+import {ObjectID} from "mongodb";
+import {FileInterface} from "../../../models/file";
+import {UserInterface} from "../../../models/user";
+const conn = mongoose.connection;
+
+class DbUtil {
+
+    constructor() {
+
+    }
+
+    getPublicFile = async(fileID: string) => {
+
+        let file = await conn.db.collection("fs.files")
+        .findOne({"_id": new ObjectID(fileID)}) as FileInterface;
+
+        return file;
+    }
+
+    removeOneTimePublicLink = async(fileID: string) => {
+
+        const file = await conn.db.collection("fs.files")
+                .findOneAndUpdate({"_id": new ObjectID(fileID)}, {
+                    "$unset": {"metadata.linkType": "", "metadata.link": ""}}) as FileInterface;
+
+        return file;
+    }
+
+    removeLink = async(fileID: string, userID: string) => {
+
+        const file = await conn.db.collection("fs.files")
+            .findOneAndUpdate({"_id": new ObjectID(fileID), 
+            "metadata.owner": userID}, 
+            {"$unset": {"metadata.linkType": "", "metadata.link": ""}}) as FileInterface;
+
+        return file;
+    }
+
+    makePublic = async(fileID: string, userID: string, token: any) => {
+
+        const file = await conn.db.collection("fs.files")
+            .findOneAndUpdate({"_id": new ObjectID(fileID), 
+            "metadata.owner": userID}, 
+            {"$set": {"metadata.linkType": "public", "metadata.link": token}}) as FileInterface
+
+        return file;
+    }
+
+    getPublicInfo = async(fileID: string, tempToken: any) => {
+
+        const file = await conn.db.collection("fs.files")
+            .findOne({"_id": new ObjectID(fileID), "metadata.link": tempToken}) as FileInterface;
+
+        return file;
+    }
+
+    makeOneTimePublic = async(fileID: string, userID: string, token: any) => {
+
+        const file = await conn.db.collection("fs.files")
+            .findOneAndUpdate({"_id": new ObjectID(fileID), 
+            "metadata.owner": userID}, 
+            {"$set": {"metadata.linkType": "one", "metadata.link": token}}) as FileInterface;
+
+        return file;
+    }
+
+    getFileInfo = async(fileID: string, userID: string) => {
+
+        const file = await conn.db.collection("fs.files")
+            .findOne({"metadata.owner": userID, "_id": new ObjectID(fileID)}) as FileInterface;
+
+        return file;
+    }
+
+    getQuickList = async(userID: string) => {
+
+        const fileList = await conn.db.collection("fs.files")
+            .find({"metadata.owner": userID})
+            .sort({uploadDate: -1})
+            .limit(10)
+            .toArray() as FileInterface[];
+
+        return fileList;
+    }
+
+    getList = async(queryObj: any, sortBy: string, limit: number) => {
+
+        const fileList = await conn.db.collection("fs.files")
+            .find(queryObj)
+            .sort(sortBy)
+            .limit(limit)
+            .toArray() as FileInterface[];
+
+
+        return fileList;
+    }
+
+    removeTempToken = async(user: UserInterface, tempToken: string) => {
+
+        user.tempTokens = user.tempTokens.filter((filterToken) => {
+            
+            return filterToken.token !== tempToken;
+        });
+
+        return user;
+    }
+
+    getFileSearchList = async(userID: string, searchQuery: any) => {
+
+        const fileList = await conn.db.collection("fs.files")
+        .find({"metadata.owner": userID, "filename": searchQuery})
+        .limit(10)
+        .toArray() as FileInterface[];
+
+        return fileList;
+    }
+
+    renameFile = async(fileID: string, userID: string, title: string) => {
+
+        const file = await conn.db.collection("fs.files")
+            .findOneAndUpdate({"_id": new ObjectID(fileID), 
+            "metadata.owner": userID}, {"$set": {"filename": title}}) as FileInterface;
+    
+        return file;
+    }
+
+    moveFile = async(fileID: string, userID: string, parent: string, parentList: string) => {
+
+        const file = await conn.db.collection("fs.files")
+            .findOneAndUpdate({"_id": new ObjectID(fileID), 
+            "metadata.owner": userID}, {"$set": {"metadata.parent": parent, "metadata.parentList": parentList}})
+    
+        return file;
+    }
+
+    getFileListByParent = async(userID: string, parentListString: string) => {
+
+        const fileList = await conn.db.collection("fs.files")
+            .find({"metadata.owner": userID, 
+            "metadata.parentList":  {$regex : `.*${parentListString}.*`}}).toArray() as FileInterface[];
+        
+        return fileList;
+    }
+
+    getFileListByOwner = async(userID: string) => {
+
+        const fileList = await conn.db.collection("fs.files")
+                        .find({"metadata.owner": userID}).toArray() as FileInterface[];
+
+        return fileList;
+    }
+
+    removeChunksByID = async(fileID: string) => {
+
+        await conn.db.collection("fs.chunks").deleteMany({files_id: fileID});
+    }
+}
+
+// const DbUtil = function() {
+
+//     this.getPublicFile = async(fileID) => {
+
+//         let file = await conn.db.collection("fs.files")
+//         .findOne({"_id": ObjectID(fileID)});
+
+//         return file;
+//     }
+
+//     this.removeOneTimePublicLink = async(fileID) => {
+
+//         const file = await conn.db.collection("fs.files")
+//                 .findOneAndUpdate({"_id": ObjectID(fileID)}, {
+//                     "$unset": {"metadata.linkType": "", "metadata.link": ""}});
+
+//         return file;
+    
+//     }
+
+//     this.removeLink = async(fileID, userID) => {
+
+//         const file = await conn.db.collection("fs.files")
+//             .findOneAndUpdate({"_id": ObjectID(fileID), 
+//             "metadata.owner": userID}, 
+//             {"$unset": {"metadata.linkType": "", "metadata.link": ""}})
+
+//         return file;
+//     }
+
+//     this.makePublic = async(fileID, userID, token) => {
+
+//         const file = await conn.db.collection("fs.files")
+//             .findOneAndUpdate({"_id": ObjectID(fileID), 
+//             "metadata.owner": userID}, 
+//             {"$set": {"metadata.linkType": "public", "metadata.link": token}})
+
+//         return file;
+//     }
+
+//     this.getPublicInfo = async(fileID, tempToken) => {
+
+//         const file = await conn.db.collection("fs.files")
+//             .findOne({"_id": ObjectID(fileID), "metadata.link": tempToken})
+
+//         return file;
+//     }
+
+//     this.makeOneTimePublic = async(fileID, userID, token) => {
+
+//         const file = await conn.db.collection("fs.files")
+//             .findOneAndUpdate({"_id": ObjectID(fileID), 
+//             "metadata.owner": userID}, 
+//             {"$set": {"metadata.linkType": "one", "metadata.link": token}})
+
+//         return file;
+//     }
+
+//     this.getFileInfo = async(fileID, userID) => {
+
+//         const file = await conn.db.collection("fs.files")
+//             .findOne({"metadata.owner": userID, "_id": ObjectID(fileID)});
+
+//         return file;
+//     }
+
+//     this.getQuickList = async(userID) => {
+
+//         const fileList = await conn.db.collection("fs.files")
+//             .find({"metadata.owner": userID})
+//             .sort({uploadDate: -1})
+//             .limit(10)
+//             .toArray();
+
+//         return fileList;
+//     }
+
+//     this.getList = async(queryObj, sortBy, limit) => {
+
+//         const fileList = await conn.db.collection("fs.files")
+//             .find(queryObj)
+//             .sort(sortBy)
+//             .limit(limit)
+//             .toArray();
+
+
+//         return fileList;
+//     }
+
+//     this.removeTempToken = async(user, tempToken) => {
+    
+//         user.tempTokens = user.tempTokens.filter((filterToken) => {
+            
+//             return filterToken.token !== tempToken;
+//         });
+
+//         return user;
+//     }
+
+//     this.removeTranscodeVideo = async(fileID, userID) => {
+
+//         const file = await conn.db.collection("fs.files")
+//             .findOneAndUpdate({"_id": ObjectID(fileID), "metadata.owner": userID}, 
+//             {"$unset": {"metadata.transcoded": "", "metadata.transcodedIV": "", 
+//             "metadata.transcoded_size": "", "metadata.transcodedID": ""}})
+    
+//         return file;
+//     }
+
+//     this.getFileSearchList = async(userID, searchQuery) => {
+
+//         const fileList = await conn.db.collection("fs.files")
+//         .find({"metadata.owner": userID, "filename": searchQuery})
+//         .limit(10)
+//         .toArray();
+
+//         return fileList;
+//     }
+
+//     this.renameFile = async(fileID, userID, title) => {
+
+//         const file = await conn.db.collection("fs.files")
+//             .findOneAndUpdate({"_id": ObjectID(fileID), 
+//             "metadata.owner": userID}, {"$set": {"filename": title}})
+    
+//         return file;
+//     }
+
+//     this.moveFile = async(fileID, userID, parent, parentList) => {
+
+//         const file = await conn.db.collection("fs.files")
+//             .findOneAndUpdate({"_id": ObjectID(fileID), 
+//             "metadata.owner": userID}, {"$set": {"metadata.parent": parent, "metadata.parentList": parentList}})
+    
+//         return file;
+//     }
+
+//     this.getFileListByParent = async(userID, parentListString) => {
+
+//         const fileList = await conn.db.collection("fs.files")
+//             .find({"metadata.owner": userID, 
+//             "metadata.parentList":  {$regex : `.*${parentListString}.*`}}).toArray();
+        
+//         return fileList;
+//     }
+
+//     this.getFileListByOwner = async(userID) => {
+
+//         const fileList = await conn.db.collection("fs.files")
+//                         .find({"metadata.owner": userID}).toArray();
+
+//         return fileList;
+//     }
+
+//     this.removeChunksByID = async(fileID) => {
+
+//         await conn.db.collection("fs.chunks").deleteMany({files_id: fileID});
+//     }
+
+// }
+
+//module.exports = DbUtil;
+export default DbUtil;

backend/db/utils/folderUtils/index.js

@@ -1,62 +0,0 @@
-const Folder = require("../../../models/folder");
-const ObjectID = require('mongodb').ObjectID
-
-const DbUtil = function() {
-
-    this.getFolderSearchList = async(userID, searchQuery) => {
-
-        const folderList = await Folder.find({"owner": userID, "name": searchQuery}).limit(10);
-
-        return folderList;
-    }
-
-    this.getFolderInfo = async(folderID, userID) => {
-
-        const folder = await Folder.findOne({"owner": userID, "_id": ObjectID(folderID)});
-
-        return folder;
-    }
-
-    this.getFolderListByParent = async(userID, parent, sortBy) => {
-
-        const folderList = await Folder.find({"owner": userID, "parent": parent})
-        .sort(sortBy);
-
-        return folderList;
-    }
-
-    this.getFolderListBySearch = async(userID, searchQuery, sortBy) => {
-
-        const folderList = await Folder.find({"name": searchQuery,"owner": userID})
-            .sort(sortBy);
-
-        return folderList;
-    }
-
-    this.moveFolder = async(folderID, userID, parent, parentList) => {
-
-        const folder = await Folder.findOneAndUpdate({"_id": ObjectID(folderID), 
-        "owner": userID}, {"$set": {"parent": parent, "parentList": parentList}});
-
-        return folder;
-    }
-
-    this.renameFolder = async(folderID, userID, title) => {
-
-        const folder = await Folder.findOneAndUpdate({"_id": ObjectID(folderID), 
-        "owner": userID}, {"$set": {"name": title}});
-
-        return folder;
-    }
-
-    this.findAllFoldersByParent = async(parentID, userID) => {
-
-        const folderList = await Folder.find({"parentList": parentID, "owner": userID});
-
-        return folderList;
-
-    }
-}
-
-module.exports = DbUtil;
-export default DbUtil;

backend/db/utils/folderUtils/index.ts

@@ -0,0 +1,122 @@
+import Folder, { FolderInterface } from "../../../models/folder";
+import {ObjectID} from "mongodb";
+
+
+class DbUtil {
+
+    constructor() {
+
+    }
+
+    getFolderSearchList = async(userID: string, searchQuery: any) => {
+
+        const folderList = await Folder.find({"owner": userID, "name": searchQuery}).limit(10) as FolderInterface[];
+
+        return folderList;
+    }
+
+    getFolderInfo = async(folderID: string, userID: string) => {
+
+        const folder = await Folder.findOne({"owner": userID, "_id": new ObjectID(folderID)}) as FolderInterface;
+
+        return folder;
+    }
+
+    getFolderListByParent = async(userID: string, parent: string, sortBy: string) => {
+
+        const folderList = await Folder.find({"owner": userID, "parent": parent})
+        .sort(sortBy) as FolderInterface[];
+
+        return folderList;
+    }
+
+    getFolderListBySearch = async(userID: string, searchQuery: string, sortBy: string) => {
+
+        const folderList = await Folder.find({"name": searchQuery,"owner": userID})
+            .sort(sortBy) as FolderInterface[];
+
+        return folderList;
+    }
+
+    moveFolder = async(folderID: string, userID: string, parent: string, parentList: string[]) => {
+
+        const folder = await Folder.findOneAndUpdate({"_id": new ObjectID(folderID), 
+        "owner": userID}, {"$set": {"parent": parent, "parentList": parentList}}) as FolderInterface;
+
+        return folder;
+    }
+
+    renameFolder = async(folderID: string, userID: string, title: string) => {
+
+        const folder = await Folder.findOneAndUpdate({"_id": new ObjectID(folderID), 
+        "owner": userID}, {"$set": {"name": title}}) as FolderInterface;
+
+        return folder;
+    }
+
+    findAllFoldersByParent = async(parentID: string, userID: string) => {
+
+        const folderList = await Folder.find({"parentList": parentID, "owner": userID}) as FolderInterface[];
+
+        return folderList;
+    }
+}
+
+// const DbUtil = function() {
+
+//     this.getFolderSearchList = async(userID, searchQuery) => {
+
+//         const folderList = await Folder.find({"owner": userID, "name": searchQuery}).limit(10);
+
+//         return folderList;
+//     }
+
+//     this.getFolderInfo = async(folderID, userID) => {
+
+//         const folder = await Folder.findOne({"owner": userID, "_id": ObjectID(folderID)});
+
+//         return folder;
+//     }
+
+//     this.getFolderListByParent = async(userID, parent, sortBy) => {
+
+//         const folderList = await Folder.find({"owner": userID, "parent": parent})
+//         .sort(sortBy);
+
+//         return folderList;
+//     }
+
+//     this.getFolderListBySearch = async(userID, searchQuery, sortBy) => {
+
+//         const folderList = await Folder.find({"name": searchQuery,"owner": userID})
+//             .sort(sortBy);
+
+//         return folderList;
+//     }
+
+//     this.moveFolder = async(folderID, userID, parent, parentList) => {
+
+//         const folder = await Folder.findOneAndUpdate({"_id": ObjectID(folderID), 
+//         "owner": userID}, {"$set": {"parent": parent, "parentList": parentList}});
+
+//         return folder;
+//     }
+
+//     this.renameFolder = async(folderID, userID, title) => {
+
+//         const folder = await Folder.findOneAndUpdate({"_id": ObjectID(folderID), 
+//         "owner": userID}, {"$set": {"name": title}});
+
+//         return folder;
+//     }
+
+//     this.findAllFoldersByParent = async(parentID, userID) => {
+
+//         const folderList = await Folder.find({"parentList": parentID, "owner": userID});
+
+//         return folderList;
+
+//     }
+// }
+
+export default DbUtil;

backend/models/file.ts

@@ -65,6 +65,7 @@ export interface FileInterface extends Document {
     chunkSize: number,
     uploadDate: string,
     filename: string,
+    lastErrorObject: {updatedExisting: any}
     metadata: {
         owner: string,
         parent: string,

backend/models/folder.ts

@@ -1,4 +1,4 @@
-const mongoose = require("mongoose");
+import mongoose, {Document} from "mongoose";
 
 const folderSchema = new mongoose.Schema({
     
@@ -27,6 +27,13 @@ const folderSchema = new mongoose.Schema({
     timestamps: true
 })
 
-const Folder = mongoose.model("Folder", folderSchema);
+export interface FolderInterface extends Document {
+    name: string,
+    parent: string,
+    owner: string,
+    parentList: string[]
+}
 
-module.exports = Folder;
+const Folder = mongoose.model<FolderInterface>("Folder", folderSchema);
+
+export default Folder;

backend/services/ChunkService/MongoService.ts

@@ -2,7 +2,7 @@ import mongoose from "../../db/mongoose";
 import { Response, Request } from "express";
 const conn = mongoose.connection;
 const DbUtilFolder = require("../../db/utils/folderUtils");
-import DbUtilFile from "../../db/utils/fileUtils/index";
+import DbUtilFile from "../../db/utils/fileUtils";
 import crypto from "crypto";
 import videoChecker from "../../utils/videoChecker"
 import imageChecker from "../../utils/imageChecker"
@@ -147,7 +147,7 @@ class MongoService implements ChunkInterface {
 
         const userID = user._id;
 
-        const file: FileInterface = await dbUtilsFile.getFileInfo(fileID, userID);
+        const file = await dbUtilsFile.getFileInfo(fileID, userID);
 
         if (!file) throw new NotFoundError("File Thumbnail Not Found");
 
@@ -177,7 +177,7 @@ class MongoService implements ChunkInterface {
 
     getPublicDownload = async(fileID: string, tempToken: any, res: Response) => {
 
-        const file: FileInterface = await dbUtilsFile.getPublicFile(fileID);
+        const file = await dbUtilsFile.getPublicFile(fileID);
 
         if (!file || !file.metadata.link || file.metadata.link !== tempToken) {
             throw new NotAuthorizedError("File Not Public");
@@ -276,13 +276,13 @@ class MongoService implements ChunkInterface {
             await Thumbnail.deleteOne({_id: file.metadata.thumbnailID});
         }
     
-        if (file.metadata.isVideo && file.metadata.transcoded) {
-            try {
-                await bucket.delete(new ObjectID(file.metadata.transcodedID));
-            } catch (e) {
-                console.log("Could Not Find Transcoded Video");
-            }
-        }
+        // if (file.metadata.isVideo && file.metadata.transcoded) {
+        //     try {
+        //         await bucket.delete(new ObjectID(file.metadata.transcodedID));
+        //     } catch (e) {
+        //         console.log("Could Not Find Transcoded Video");
+        //     }
+        // }
     
         await bucket.delete(new ObjectID(fileID));
     }

backend/services/FileService/utils/removeChunks.ts

@@ -1,6 +1,6 @@
 import { GridFSBucketWriteStream } from "mongodb";
 
-const DbUtilsFile = require("../../../db/utils/fileUtils");
+import DbUtilsFile from "../../../db/utils/fileUtils";
 const dbUtilsFile = new DbUtilsFile();
 
 const removeChunks = async(bucketStream: GridFSBucketWriteStream) => {

backend/services/FolderService/index.js

@@ -1,7 +1,7 @@
-const Folder = require("../../models/folder");
+import Folder from "../../models/folder";
 const InternalServerError = require("../../utils/InternalServerError");
 const NotFoundError = require("../../utils/NotFoundError");
-const UtilsFile = require("../../db/utils/fileUtils");
+import UtilsFile from "../../db/utils/fileUtils";
 const ObjectID = require('mongodb').ObjectID
 const UtilsFolder = require("../../db/utils/folderUtils");
 import mongoose from "../../db/mongoose";