deep-links models fully work AND add translations

src/main/ipcs/bs-model-ipcs.ts

@@ -13,4 +13,49 @@ ipcMain.on("one-click-install-model", async (event, request: IpcRequest<MSModel>
     }).catch(e => {
         utils.ipcSend(request.responceChannel, {success: false, error: e});
     })
+});
+
+ipcMain.on("register-models-deep-link", async (event, request: IpcRequest<void>) => {
+    
+    const maps = LocalModelsManagerService.getInstance();
+    const utils = UtilsService.getInstance();
+
+    try{
+        const res = maps.enableDeepLinks();
+        utils.ipcSend(request.responceChannel, {success: true, data: res});
+    }
+    catch(e){
+        utils.ipcSend(request.responceChannel, {success: false});
+    }
+
+});
+
+ipcMain.on("unregister-models-deep-link", async (event, request: IpcRequest<void>) => {
+    
+    const maps = LocalModelsManagerService.getInstance();
+    const utils = UtilsService.getInstance();
+
+    try{
+        const res = maps.disableDeepLinks();
+        utils.ipcSend(request.responceChannel, {success: true, data: res});
+    }
+    catch(e){
+        utils.ipcSend(request.responceChannel, {success: false});
+    }
+    
+});
+
+ipcMain.on("is-models-deep-links-enabled", async (event, request: IpcRequest<void>) => {
+
+    const maps = LocalModelsManagerService.getInstance();
+    const utils = UtilsService.getInstance();
+
+    try{
+        const res = maps.isDeepLinksEnabled();
+        utils.ipcSend(request.responceChannel, {success: true, data: res});
+    }
+    catch(e){
+        utils.ipcSend(request.responceChannel, {success: false});
+    }
+
 });

src/main/ipcs/index.ts

@@ -10,4 +10,5 @@ import './bs-mods-ipcs';
 import './bs-maps-ipcs';
 import './beat-saver-ipcs';
 import './bs-playlist-ipcs';
-import './model-saber.ipcs';
+import './model-saber.ipcs';
+import './bs-model-ipcs';

src/main/main.ts

@@ -89,7 +89,7 @@ else{
 
     app.whenReady().then(() => {
 
-        process.argv.push("modelsaber://saber/1670981586/r_Happy Crimbo!.saber"); // to force deep-link (oneClick map)
+        // process.argv.push("modelsaber://platform/1671435302/The grinch mountain.plat"); // to force deep-link (oneClick map)
 
         initServicesMustBeInitialized();
         

src/main/services/additional-content/local-models-manager.service.ts

@@ -6,6 +6,10 @@ import { UtilsService } from "../utils.service";
 import { WindowManagerService } from "../window-manager.service";
 import { MSModel, MSModelType } from "shared/models/model-saber/model-saber.model";
 import { BSVersion } from "shared/bs-version.interface";
+import { BSLocalVersionService } from "../bs-local-version.service";
+import path from "path";
+import { RequestService } from "../request.service";
+import { copyFileSync, constants } from "fs-extra";
 
 export class LocalModelsManagerService {
 
@@ -20,14 +24,25 @@ export class LocalModelsManagerService {
         ModelSaber: "modelsaber",
     };
 
+    private readonly MODEL_TYPE_FOLDER: Record<Exclude<MSModelType, "misc">, string>  = {
+        avatar: "CustomAvatars",
+        bloq: "CustomNotes",
+        platform: "CustomPlatforms",
+        saber: "CustomSabers"
+    }
+
     private readonly deepLink: DeepLinkService;
     private readonly utils: UtilsService;
     private readonly windows: WindowManagerService;
+    private readonly localVersion: BSLocalVersionService;
+    private readonly request: RequestService;
 
     private constructor(){
         this.deepLink = DeepLinkService.getInstance();
         this.utils = UtilsService.getInstance();
         this.windows = WindowManagerService.getInstance();
+        this.localVersion = BSLocalVersionService.getInstance();
+        this.request = RequestService.getInstance();
 
         this.deepLink.addLinkOpenedListener(this.DEEP_LINKS.ModelSaber, (link) => {
             log.info("DEEP-LINK RECEIVED FROM", this.DEEP_LINKS.ModelSaber, link);
@@ -42,8 +57,7 @@ export class LocalModelsManagerService {
 
     private openOneClickDownloadModelWindow(id: string, type: string){
         
-        // TODO make once
-        ipcMain.on("one-click-model-info", async (event, req: IpcRequest<void>) => {
+        ipcMain.once("one-click-model-info", async (event, req: IpcRequest<void>) => {
             this.utils.ipcSend(req.responceChannel, {success: true, data: {id, type}});
         });
 
@@ -51,16 +65,61 @@ export class LocalModelsManagerService {
 
     }
 
-    private getModelFolderPath(type: MSModelType, version?: BSVersion): Promise<string>{
-        // TODO : return path of model type of version
+    private async getModelFolderPath(type: MSModelType, version?: BSVersion): Promise<string>{
+
+        if(!version){ throw "will be implemented whith models management" }
+        if(type === "misc"){ throw "model type not supported"; }
+
+        const versionPath = await this.localVersion.getVersionPath(version);
+        const modelFolderPath = path.join(versionPath, this.MODEL_TYPE_FOLDER[type]);
+
+        this.utils.createFolderIfNotExist(modelFolderPath);
+
+        return modelFolderPath;
+
     }
 
-    public downloadModel(model: MSModel, version: BSVersion): Promise<string>{
-        // TODO : Download model to the version
+    public async downloadModel(model: MSModel, version: BSVersion): Promise<string>{
+        
+        const modelFolder = await this.getModelFolderPath(model.type, version);
+        const modelDest = path.join(modelFolder, path.basename(model.download));
+
+        return this.request.downloadFile(model.download, modelDest);
+
     }
 
     public async oneClickDownloadModel(model: MSModel): Promise<void>{
 
+        if(!model){ return; }
+
+        const versions = await this.localVersion.getInstalledVersions();
+
+        if(versions?.length === 0){ return; }
+
+        const fisrtVersion = versions.shift();
+
+        const downloaded = await this.downloadModel(model, fisrtVersion);
+
+        for(const version of versions){
+
+            const modelDest = path.join(await this.getModelFolderPath(model.type, version), path.basename(downloaded));
+
+            copyFileSync(downloaded, modelDest);
+
+        }
+
+    }
+
+    public enableDeepLinks(): boolean{
+        return Array.from(Object.values(this.DEEP_LINKS)).every(link => this.deepLink.registerDeepLink(link));
+    }
+
+    public disableDeepLinks(): boolean{
+        return Array.from(Object.values(this.DEEP_LINKS)).every(link => this.deepLink.unRegisterDeepLink(link));
+    }
+
+    public isDeepLinksEnabled(): boolean{
+        return Array.from(Object.values(this.DEEP_LINKS)).every(link => this.deepLink.isDeepLinkRegistred(link));
     }
 
 }