Merge pull request #190 from Nfactor26/download-latest-data-model-and-initialize-script-files-before-editing

Nfactor26 · web-flow · commit 29bed631ec3c · 2022-12-04T16:17:16.000+05:30
Download latest data model and initialize script files before editing
diff --git a/src/Pixel.Automation.AppExplorer.ViewModels/Pixel.Automation.AppExplorer.ViewModels.csproj b/src/Pixel.Automation.AppExplorer.ViewModels/Pixel.Automation.AppExplorer.ViewModels.csproj
@@ -24,7 +24,6 @@
 		<ProjectReference Include="..\Pixel.Automation.Editor.Notifications\Pixel.Automation.Editor.Notifications.csproj" />
 		<ProjectReference Include="..\Pixel.Persistence.Services.Client\Pixel.Persistence.Services.Client.csproj" />
 		<ProjectReference Include="..\Pixel.Scripting.Editor.Core\Pixel.Scripting.Editor.Core.csproj" />
-		<ProjectReference Include="..\Pixel.Scripting.Reference.Manager\Pixel.Scripting.Reference.Manager.csproj" />
 	</ItemGroup>
 
 	<ItemGroup>
diff --git a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/AutomationEditorViewModel.cs b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/AutomationEditorViewModel.cs
@@ -99,6 +99,7 @@ public override async Task EditDataModelAsync()
             try
             {
                 logger.Information($"Opening code editor for editing data model for project : {this.CurrentProject.Name}");
+                await this.projectManager.DownloadDataModelFilesAsync();
                 var editorFactory = this.EntityManager.GetServiceOfType<ICodeEditorFactory>();
                 var projectFileSystem = this.projectManager.GetProjectFileSystem();
                 using (var editor = editorFactory.CreateMultiCodeEditorScreen())
@@ -160,6 +161,7 @@ public async Task EditScriptAsync()
         {
             try
             {
+                await this.projectManager.DownloadFileByNameAsync(Constants.InitializeEnvironmentScript);
                 var entityManager = this.EntityManager;
                 var fileSystem = entityManager.GetCurrentFileSystem();
                 var scriptFile = Path.Combine(fileSystem.ScriptsDirectory, Constants.InitializeEnvironmentScript);             
diff --git a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/AutomationProjectManager.cs b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/AutomationProjectManager.cs
@@ -25,6 +25,23 @@ public class AutomationProjectManager : ProjectManager, IAutomationProjectManage
         private AutomationProject activeProject;
         private VersionInfo loadedVersion;     
 
+        /// <summary>
+        /// constructor
+        /// </summary>
+        /// <param name="serializer"></param>
+        /// <param name="entityManager"></param>
+        /// <param name="projectFileSystem"></param>
+        /// <param name="typeProvider"></param>
+        /// <param name="argumentTypeProvider"></param>
+        /// <param name="codeEditorFactory"></param>
+        /// <param name="scriptEditorFactory"></param>
+        /// <param name="scriptEngineFactory"></param>
+        /// <param name="codeGenerator"></param>
+        /// <param name="applicationDataManager"></param>
+        /// <param name="referenceManagerFactory"></param>
+        /// <param name="projectDataManager"></param>
+        /// <param name="prefabDataManager"></param>
+        /// <param name="projectAssetDataManager"></param>
         public AutomationProjectManager(ISerializer serializer, IEntityManager entityManager, IProjectFileSystem projectFileSystem, ITypeProvider typeProvider, IArgumentTypeProvider argumentTypeProvider,
             ICodeEditorFactory codeEditorFactory, IScriptEditorFactory scriptEditorFactory, IScriptEngineFactory scriptEngineFactory, ICodeGenerator codeGenerator, IApplicationDataManager applicationDataManager,
             IReferenceManagerFactory referenceManagerFactory, IProjectDataManager projectDataManager, IPrefabDataManager prefabDataManager, IProjectAssetsDataManager projectAssetDataManager) 
@@ -37,7 +54,7 @@ public AutomationProjectManager(ISerializer serializer, IEntityManager entityMan
             this.prefabDataManager = Guard.Argument(prefabDataManager, nameof(prefabDataManager)).NotNull().Value;
         }
 
-        #region Load Project
+        #region methods
 
         public async  Task<Entity> Load(AutomationProject activeProject, VersionInfo versionToLoad)
         {
@@ -141,9 +158,7 @@ private Entity DeserializeProject()
         {                     
             var entity = this.Load<Entity>(this.projectFileSystem.ProcessFile);         
             return entity;
-        }       
-
-        #endregion Load Project
+        }
 
         /// <summary>
         /// Save and load project again. Update services to use new data model . One time registration of services is skipped unlike load.
@@ -154,35 +169,43 @@ private Entity DeserializeProject()
         /// <param name="entityManager"></param>
         /// <returns></returns>
         public override async Task Reload()
-        {        
+        {
 
             logger.Information($"{this.GetProjectName()} will be re-loaded");
             var reference = this.fileSystem.LoadFile<ProjectReferences>(this.fileSystem.ReferencesFile);
             this.referenceManager.SetProjectReferences(reference);
             var dataModel = CompileAndCreateDataModel(Constants.AutomationProcessDataModelName);
             ConfigureScriptEngine(this.referenceManager, dataModel);
-            ConfigureScriptEditor(this.referenceManager, dataModel);          
+            ConfigureScriptEditor(this.referenceManager, dataModel);
             this.entityManager.Arguments = dataModel;
             SetupInitializationScriptProject(dataModel);
-            await ExecuteInitializationScript();        
+            await ExecuteInitializationScript();
             ConfigureArgumentTypeProvider(this.entityManager.Arguments.GetType().Assembly);
             this.RootEntity.ResetHierarchy();
-            serializer.Serialize(this.projectFileSystem.ProcessFile, this.RootEntity, typeProvider.GetKnownTypes());            
-                   
+            serializer.Serialize(this.projectFileSystem.ProcessFile, this.RootEntity, typeProvider.GetKnownTypes());
+
             var rootEntity = DeserializeProject();
             //we don't want any launched applications to be lost. Copy over ApplicationDetails from each ApplicationEntity in to newly loaded root entity.
-            foreach(var applicationEntity in this.entityManager.RootEntity.GetComponentsOfType<ApplicationEntity>(SearchScope.Descendants))
+            foreach (var applicationEntity in this.entityManager.RootEntity.GetComponentsOfType<ApplicationEntity>(SearchScope.Descendants))
             {
                 var newApplicationEntity = rootEntity.GetComponentById(applicationEntity.Id, SearchScope.Descendants) as IApplicationEntity;
                 newApplicationEntity.SetTargetApplicationDetails(applicationEntity.GetTargetApplicationDetails());
-            }         
+            }
             this.RootEntity = rootEntity;
             RestoreParentChildRelation(this.RootEntity);
             await Task.CompletedTask;
             logger.Information($"Reload completed for project {this.GetProjectName()}");
 
         }
 
+        ///<inheritdoc/>
+        public async Task DownloadFileByNameAsync(string fileName)
+        {
+            await this.projectDataManager.DownloadProjectDataFileByNameAsync(this.activeProject, this.loadedVersion as ProjectVersion, fileName);
+        }
+
+        #endregion methods
+
         #region overridden methods
 
         ///<inheritdoc/>
@@ -197,6 +220,12 @@ public override async Task DeleteDataFileAsync(string fileToDelete)
             await this.projectDataManager.DeleteDataFileAsync(this.activeProject, this.loadedVersion as ProjectVersion, fileToDelete);
         }
 
+        ///<inheritdoc/>
+        public override async Task DownloadDataModelFilesAsync()
+        {
+            await this.projectDataManager.DownloadDataModelFilesAsync(this.activeProject, this.loadedVersion as ProjectVersion);
+        }
+
         ///<inheritdoc/>
         protected override string GetProjectName()
         {
diff --git a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabEditorViewModel.cs b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabEditorViewModel.cs
@@ -61,6 +61,7 @@ public async Task DoLoad(PrefabProject prefabProject, VersionInfo versionToLoad
         /// <returns></returns>
         public override async Task EditDataModelAsync()
         {
+            await this.projectManager.DownloadDataModelFilesAsync();
             var editorFactory = this.EntityManager.GetServiceOfType<ICodeEditorFactory>();
             var prefabFileSystem = this.projectManager.GetProjectFileSystem();
             using (var editor = editorFactory.CreateMultiCodeEditorScreen())
diff --git a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabProjectManager.cs b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabProjectManager.cs
@@ -222,6 +222,12 @@ public override async Task DeleteDataFileAsync(string fileToDelete)
             await this.prefabDataManager.DeleteDataFileAsync(this.prefabProject, this.loadedVersion, fileToDelete);
         }
 
+        ///<inheritdoc/>
+        public override async Task DownloadDataModelFilesAsync()
+        {
+            await this.prefabDataManager.DownloadDataModelFilesAsync(this.prefabProject, this.loadedVersion);
+        }
+
         /// <inheritdoc/>       
         protected override string GetProjectName()
         {
diff --git a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/ProjectManager.cs b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/ProjectManager.cs
@@ -73,6 +73,9 @@ public ProjectManager(ISerializer serializer, IEntityManager entityManager, IFil
         ///<inheritdoc/>
         public abstract Task DeleteDataFileAsync(string fileToDelete);
 
+        ///<inheritdoc/>
+        public abstract Task DownloadDataModelFilesAsync();
+
         ///<inheritdoc/>
         public abstract Task Save();
 
diff --git a/src/Pixel.Automation.Editor.Core/Interfaces/IProjectManager.cs b/src/Pixel.Automation.Editor.Core/Interfaces/IProjectManager.cs
@@ -34,6 +34,12 @@ public interface IProjectManager
         /// <returns></returns>
         Task DeleteDataFileAsync(string fileToDelete);
 
+        /// <summary>
+        /// Download the data model files (*.cs) belonging the the loaded version of project
+        /// </summary>
+        /// <returns></returns>
+        Task DownloadDataModelFilesAsync();
+
         /// <summary>
         /// Deserialize the contents of a file to given type while ensuring that any references to data model assembly in file are replaced with current session's
         /// data model assembly. Use this to load a process file, prefab file or a test file.
@@ -58,7 +64,9 @@ public interface IProjectManager
 
     public interface IAutomationProjectManager: IProjectManager
     {
-        Task<Entity> Load(AutomationProject activeProject, VersionInfo versionToLoad);       
+        Task<Entity> Load(AutomationProject activeProject, VersionInfo versionToLoad);
+
+        Task DownloadFileByNameAsync(string fileName);
     }
     
 
diff --git a/src/Pixel.Automation.RunTime/Pixel.Automation.RunTime.csproj b/src/Pixel.Automation.RunTime/Pixel.Automation.RunTime.csproj
@@ -31,8 +31,7 @@
 		<ProjectReference Include="..\Pixel.Automation.Core.Components\Pixel.Automation.Core.Components.csproj">
 			<Private>false</Private>
 		</ProjectReference>
-		<ProjectReference Include="..\Pixel.Automation.Reference.Manager\Pixel.Automation.Reference.Manager.csproj" />
-		<ProjectReference Include="..\Pixel.Scripting.Reference.Manager\Pixel.Scripting.Reference.Manager.csproj" />		
+		<ProjectReference Include="..\Pixel.Automation.Reference.Manager\Pixel.Automation.Reference.Manager.csproj" />		
 	</ItemGroup>
 
 </Project>
diff --git a/src/Pixel.Persistence.Respository/FilesRepository.cs b/src/Pixel.Persistence.Respository/FilesRepository.cs
@@ -112,7 +112,8 @@ public async Task<ProjectDataFile> GetFileAsync(string projectId, string project
                     ProjectId = projectId,
                     ProjectVersion = projectVersion,
                     FileName = fileInfo.Filename,
-                    FilePath = fileInfo.Metadata[this.filePathField].AsString
+                    FilePath = fileInfo.Metadata[this.filePathField].AsString,
+                    Bytes = fileData
                 };
             }          
         }
@@ -158,6 +159,41 @@ public async IAsyncEnumerable<ProjectDataFile> GetFilesAsync(string projectId, s
         }
     }
 
+    /// <inheritdoc/>   
+    public async IAsyncEnumerable<ProjectDataFile> GetFilesOfTypeAsync(string projectId, string projectVersion, string fileExtension)
+    {
+        Guard.Argument(projectId, nameof(projectId)).NotNull().NotEmpty();
+        Guard.Argument(projectVersion, nameof(projectVersion)).NotNull().NotEmpty();
+        Guard.Argument(fileExtension, nameof(fileExtension)).NotNull().NotEmpty();
+
+        var filter = Builders<GridFSFileInfo>.Filter.Eq(x => x.Metadata[this.IdField], projectId) &
+                     Builders<GridFSFileInfo>.Filter.Eq(x => x.Metadata[this.versionField], projectVersion) &
+                     Builders<GridFSFileInfo>.Filter.Regex(x => x.Filename, $"({fileExtension})$");     
+
+        var sort = Builders<GridFSFileInfo>.Sort.Descending(x => x.UploadDateTime);
+        var options = new GridFSFindOptions
+        {
+            Sort = sort
+        };
+
+        using (var cursor = await bucket.FindAsync(filter, options))
+        {
+            foreach (var file in (await cursor.ToListAsync()))
+            {
+                var fileData = await bucket.DownloadAsBytesAsync(file.Id);
+                yield return new ProjectDataFile()
+                {
+                    ProjectId = projectId,
+                    ProjectVersion = projectVersion,
+                    FileName = file.Filename,
+                    FilePath = file.Metadata[this.filePathField].AsString,
+                    Tag = file.Metadata[this.tagField].AsString,
+                    Bytes = fileData
+                };
+            }
+        }
+    }
+
     /// <inheritdoc/>   
     public async Task AddOrUpdateFileAsync(string projectId, string projectVersion, ProjectDataFile dataFile)
     {
diff --git a/src/Pixel.Persistence.Respository/Interfaces/IFilesRepository.cs b/src/Pixel.Persistence.Respository/Interfaces/IFilesRepository.cs
@@ -25,14 +25,23 @@ public interface IFilesRepository
     /// <returns></returns>
     IAsyncEnumerable<ProjectDataFile> GetFilesAsync(string projectId, string projectVersion, string[] tags);
 
+    /// <summary>
+    /// Get all the files with a matching extension
+    /// </summary>
+    /// <param name="projectId"></param>
+    /// <param name="projectVersion"></param>
+    /// <param name="fileExtension"></param>
+    /// <returns></returns>
+    IAsyncEnumerable<ProjectDataFile> GetFilesOfTypeAsync(string projectId, string projectVersion, string fileExtension);
+
     /// <summary>
     /// Get a file by name for a given version of project
     /// </summary>
     /// <param name="projectId"></param>
     /// <param name="projectVersion"></param>
     /// <param name="fileName"></param>
     /// <returns></returns>
-    Task<ProjectDataFile> GetFileAsync(string projectId, string projectVersion, string fileName);
+    Task<ProjectDataFile> GetFileAsync(string projectId, string projectVersion, string fileName); 
 
     /// <summary>
     /// Add a new file to a given version of project
diff --git a/src/Pixel.Persistence.Services.Api/Controllers/FilesController.cs b/src/Pixel.Persistence.Services.Api/Controllers/FilesController.cs
@@ -68,7 +68,7 @@ public async Task<ActionResult> GetFileByName(string projectId, string projectve
                 var file = await filesRepository.GetFileAsync(projectId, projectversion, fileName);
                 if(file != null)
                 {
-                    return File(file.Bytes, file.Type, file.FileName);
+                    return Ok(file);
                 }
                 return NotFound();
 
@@ -117,6 +117,37 @@ public async Task<ActionResult> GetFilesWithTag(string projectId, string project
             }
         }
 
+        [HttpGet("{projectId}/{projectVersion}/type/{fileExtension}")]
+        public async Task<ActionResult> GetFilesOfType(string projectId, string projectVersion, string fileExtension)
+        {
+            try
+            {
+                using (var stream = new MemoryStream())
+                {
+                    using (var zipArchive = new ZipArchive(stream, ZipArchiveMode.Create))
+                    {
+                        await foreach (var file in this.filesRepository.GetFilesOfTypeAsync(projectId, projectVersion, fileExtension))
+                        {
+                            var zipEntry = zipArchive.CreateEntry(Path.Combine(file.FilePath));
+                            using (var zipEntryStream = zipEntry.Open())
+                            {
+                                zipEntryStream.Write(file.Bytes);
+                            }
+                        }
+                    }
+                    return File(stream.ToArray(), "application/zip", $"{projectId}.zip");
+
+                }
+
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, ex.Message);
+                return Problem(ex.Message, statusCode: StatusCodes.Status500InternalServerError);
+            }
+        }
+
+
         /// <summary>
         /// Add a new file to a given version of project
         /// </summary>
diff --git a/src/Pixel.Persistence.Services.Client/DataManagers/PrefabDataManager.cs b/src/Pixel.Persistence.Services.Client/DataManagers/PrefabDataManager.cs
@@ -134,6 +134,33 @@ bool HasMostRecentDataAlreadyAvailable()
         }
     }
 
+    /// <inheritdoc/> 
+    public async Task DownloadDataModelFilesAsync(PrefabProject prefabProject, PrefabVersion prefabVersion)
+    {
+        Guard.Argument(prefabProject, nameof(prefabProject)).NotNull();
+        Guard.Argument(prefabVersion, nameof(prefabVersion)).NotNull();
+
+        if (IsOnlineMode)
+        {
+            var dataModelsDirectory = Path.Combine(this.applicationFileSystem.GetPrefabProjectWorkingDirectory(prefabProject, prefabVersion), Constants.DataModelDirectory);
+            if (Directory.Exists(dataModelsDirectory))
+            {
+                Directory.Delete(dataModelsDirectory, true);
+            }
+            Directory.CreateDirectory(dataModelsDirectory);
+            var zippedContent = await this.filesClient.DownloadProjectDataFilesOfType(prefabProject.PrefabId, prefabVersion.ToString(), "cs");
+            if (zippedContent.Length > 0)
+            {
+                string versionDirectory = this.applicationFileSystem.GetPrefabProjectWorkingDirectory(prefabProject, prefabVersion);
+                using (var memoryStream = new MemoryStream(zippedContent, false))
+                {
+                    var zipArchive = new ZipArchive(memoryStream, ZipArchiveMode.Read);
+                    zipArchive.ExtractToDirectory(versionDirectory, true);
+                }
+            }
+        }
+    }
+
     ///<inheritdoc/>
     public async Task DownloadPrefabsAsync()
     {
diff --git a/src/Pixel.Persistence.Services.Client/DataManagers/ProjectDataManager.cs b/src/Pixel.Persistence.Services.Client/DataManagers/ProjectDataManager.cs
diff --git a/src/Pixel.Persistence.Services.Client/FilesRepositoryClient.cs b/src/Pixel.Persistence.Services.Client/FilesRepositoryClient.cs
diff --git a/src/Pixel.Persistence.Services.Client/Interfaces/IFilesRepositoryClient.cs b/src/Pixel.Persistence.Services.Client/Interfaces/IFilesRepositoryClient.cs
diff --git a/src/Pixel.Persistence.Services.Client/Interfaces/IPrefabDataManager.cs b/src/Pixel.Persistence.Services.Client/Interfaces/IPrefabDataManager.cs
diff --git a/src/Pixel.Persistence.Services.Client/Interfaces/IProjectDataManager.cs b/src/Pixel.Persistence.Services.Client/Interfaces/IProjectDataManager.cs
diff --git a/src/Pixel.Scripting.Engine.CSharp/Pixel.Scripting.Engine.CSharp.csproj b/src/Pixel.Scripting.Engine.CSharp/Pixel.Scripting.Engine.CSharp.csproj

Original file line number	Diff line number	Diff line change
`@@ -99,6 +99,7 @@ public override async Task EditDataModelAsync()`
`99`	`99`	`try`
`100`	`100`	`{`
`101`	`101`	`logger.Information($"Opening code editor for editing data model for project : {this.CurrentProject.Name}");`
	`102`	`+ await this.projectManager.DownloadDataModelFilesAsync();`
`102`	`103`	`var editorFactory = this.EntityManager.GetServiceOfType<ICodeEditorFactory>();`
`103`	`104`	`var projectFileSystem = this.projectManager.GetProjectFileSystem();`
`104`	`105`	`using (var editor = editorFactory.CreateMultiCodeEditorScreen())`
`@@ -160,6 +161,7 @@ public async Task EditScriptAsync()`
`160`	`161`	`{`
`161`	`162`	`try`
`162`	`163`	`{`
	`164`	`+ await this.projectManager.DownloadFileByNameAsync(Constants.InitializeEnvironmentScript);`
`163`	`165`	`var entityManager = this.EntityManager;`
`164`	`166`	`var fileSystem = entityManager.GetCurrentFileSystem();`
`165`	`167`	`var scriptFile = Path.Combine(fileSystem.ScriptsDirectory, Constants.InitializeEnvironmentScript);`
Original file line number	Diff line number	Diff line change
`@@ -61,6 +61,7 @@ public async Task DoLoad(PrefabProject prefabProject, VersionInfo versionToLoad`
`61`	`61`	`/// <returns></returns>`
`62`	`62`	`public override async Task EditDataModelAsync()`
`63`	`63`	`{`
	`64`	`+ await this.projectManager.DownloadDataModelFilesAsync();`
`64`	`65`	`var editorFactory = this.EntityManager.GetServiceOfType<ICodeEditorFactory>();`
`65`	`66`	`var prefabFileSystem = this.projectManager.GetProjectFileSystem();`
`66`	`67`	`using (var editor = editorFactory.CreateMultiCodeEditorScreen())`
Original file line number	Diff line number	Diff line change
`@@ -222,6 +222,12 @@ public override async Task DeleteDataFileAsync(string fileToDelete)`
`222`	`222`	`await this.prefabDataManager.DeleteDataFileAsync(this.prefabProject, this.loadedVersion, fileToDelete);`
`223`	`223`	`}`
`224`	`224`
	`225`	`+ ///<inheritdoc/>`
	`226`	`+ public override async Task DownloadDataModelFilesAsync()`
	`227`	`+ {`
	`228`	`+ await this.prefabDataManager.DownloadDataModelFilesAsync(this.prefabProject, this.loadedVersion);`
	`229`	`+ }`
	`230`	`+`
`225`	`231`	`/// <inheritdoc/>`
`226`	`232`	`protected override string GetProjectName()`
`227`	`233`	`{`