Download published prefab version only if data is not locally available

Nfactor26 · Nfactor26 · commit 49c019d852bb · 2022-11-26T18:50:50.000+05:30
diff --git a/src/Pixel.Automation.Core/Models/VersionInfo.cs b/src/Pixel.Automation.Core/Models/VersionInfo.cs
@@ -28,6 +28,12 @@ public abstract class VersionInfo
         [DataMember(IsRequired = false, Order = 30)]
         public string DataModelAssembly { get; set; }
 
+        /// <summary>
+        /// DateTime when the version was publisheds
+        /// </summary>
+        [DataMember(IsRequired = false, Order = 40)]
+        public DateTime? PublishedOn { get; set; }
+
         /// <summary>
         /// Description 
         /// </summary>
@@ -46,6 +52,12 @@ public override bool Equals(object obj)
             return false;
         }
 
+        ///</inheritdoc>
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(this.Version, this.IsActive);
+        }
+
         ///</inheritdoc>
         public override string ToString()
         {
diff --git a/src/Pixel.Automation.Designer.ViewModels/AppBootStrapper.cs b/src/Pixel.Automation.Designer.ViewModels/AppBootStrapper.cs
@@ -63,8 +63,7 @@ protected override void OnStartup(object sender, StartupEventArgs e)
                             logger.Information("Downloading project information now");
                             await projectDataManager.DownloadProjectsAsync();
                             logger.Information("Download of project information completed");
-                            await prefabDataManager.DownloadPrefabsAsync();
-                            logger.Information("Download of prefabs completed");
+                            await prefabDataManager.DownloadPrefabsAsync();                           
                         }
                         catch (Exception ex)
                         {
diff --git a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/AutomationProjectManager.cs b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/AutomationProjectManager.cs
@@ -53,8 +53,7 @@ public async  Task<Entity> Load(AutomationProject activeProject, VersionInfo ver
 
             foreach(var prefabReference in this.referenceManager.GetPrefabReferences().References)
             {
-                await this.prefabDataManager.DownloadPrefabDataAsync(new PrefabProject() { ApplicationId = prefabReference.ApplicationId, PrefabId = prefabReference.PrefabId },
-                    prefabReference.Version);
+                await this.prefabDataManager.DownloadPrefabDataAsync(prefabReference.ApplicationId, prefabReference.PrefabId, prefabReference.Version.ToString());
             }
 
             this.entityManager.SetCurrentFileSystem(this.fileSystem);
diff --git a/src/Pixel.Automation.Test.Runner/ProjectManager.cs b/src/Pixel.Automation.Test.Runner/ProjectManager.cs
@@ -107,12 +107,7 @@ public async Task LoadProjectAsync(string projectId, string projectVersion, stri
 
             foreach (var prefabReference in this.referenceManager.GetPrefabReferences().References)
             {
-                await this.prefabDataManager.DownloadPrefabDataAsync(new Core.Models.PrefabProject()
-                {
-                    ApplicationId = prefabReference.ApplicationId,
-                    PrefabId = prefabReference.PrefabId
-                },
-                prefabReference.Version);
+                await this.prefabDataManager.DownloadPrefabDataAsync( prefabReference.ApplicationId, prefabReference.PrefabId, prefabReference.Version.ToString());
             }
          
             this.entityManager.SetCurrentFileSystem(this.projectFileSystem);
diff --git a/src/Pixel.Persistence.Core/Models/VersionInfo.cs b/src/Pixel.Persistence.Core/Models/VersionInfo.cs
@@ -27,6 +27,11 @@ public abstract class VersionInfo
     [DataMember(IsRequired = false, Order = 30)]
     public string DataModelAssembly { get; set; }
 
+
+    [DataMember(IsRequired = false, Order = 40)]
+    public DateTime? PublishedOn { get; set; }
+
+
     public override bool Equals(object obj)
     {
         if(obj is VersionInfo versionInfo)
@@ -38,7 +43,7 @@ public override bool Equals(object obj)
 
     public override int GetHashCode()
     {
-        return HashCode.Combine(Version, IsActive, DataModelAssembly);
+        return HashCode.Combine(Version, IsActive);
     }
 
     public override string ToString()
diff --git a/src/Pixel.Persistence.Respository/PrefabsRepository.cs b/src/Pixel.Persistence.Respository/PrefabsRepository.cs
@@ -80,7 +80,9 @@ public async Task AddPrefabVersionAsync(string prefabId, PrefabVersion newVersio
             var projectVersions = (await this.prefabsCollection.FindAsync<List<PrefabVersion>>(filter, new FindOptions<PrefabProject, List<PrefabVersion>>()
             {
                 Projection = Builders<PrefabProject>.Projection.Expression(u => u.AvailableVersions)
-            })).ToList().FirstOrDefault();
+            }))
+            .ToList().FirstOrDefault();
+            
             if (projectVersions?.Contains(newVersion) ?? false)
             {
                 throw new InvalidOperationException($"Version {newVersion} already exists for prefab {prefabId}");
@@ -113,6 +115,10 @@ public async Task UpdatePrefabVersionAsync(string prefabId, PrefabVersion prefab
 
             if (prefabVersions?.Contains(prefabVersion) ?? false)
             {
+                if(!prefabVersion.IsActive && prefabVersion.PublishedOn is null)
+                {
+                    prefabVersion.PublishedOn = DateTime.UtcNow;
+                }
                 var update = Builders<PrefabProject>.Update.Set(x => x.AvailableVersions[-1], prefabVersion);
                 await this.prefabsCollection.UpdateOneAsync(filter, update);
                 logger.LogInformation("Project version {0} was updated for project : {1}", prefabVersion, prefabId);
diff --git a/src/Pixel.Persistence.Respository/ProjectsRepository.cs b/src/Pixel.Persistence.Respository/ProjectsRepository.cs
@@ -146,10 +146,15 @@ public async Task UpdateProjectVersionAsync(string projectId, ProjectVersion pro
             var projectVersions = (await this.projectsCollection.FindAsync<List<ProjectVersion>>(filter, new FindOptions<AutomationProject, List<ProjectVersion>>()
             {
                 Projection = Builders<AutomationProject>.Projection.Expression(u => u.AvailableVersions)
-            })).ToList().FirstOrDefault();
+            }))
+            .ToList().FirstOrDefault();
 
             if (projectVersions?.Contains(projectVersion) ?? false)
             {
+                if (!projectVersion.IsActive && projectVersion.PublishedOn is null)
+                {
+                    projectVersion.PublishedOn = DateTime.UtcNow;
+                }
                 var update = Builders<AutomationProject>.Update.Set(x => x.AvailableVersions[-1], projectVersion);
                 await this.projectsCollection.UpdateOneAsync(filter, update);
                 logger.LogInformation("Project version {0} was updated for project : {1}", projectVersion, projectId);
diff --git a/src/Pixel.Persistence.Services.Client/DataManagers/PrefabDataManager.cs b/src/Pixel.Persistence.Services.Client/DataManagers/PrefabDataManager.cs
@@ -26,6 +26,15 @@ public class PrefabDataManager : IPrefabDataManager
 
     bool IsOnlineMode => !this.applicationSettings.IsOfflineMode;
    
+    /// <summary>
+    /// constructor
+    /// </summary>
+    /// <param name="applicationSettings"></param>
+    /// <param name="serializer"></param>
+    /// <param name="applicationFileSystem"></param>
+    /// <param name="prefabsRepositoryClient"></param>
+    /// <param name="filesRepositoryClient"></param>
+    /// <param name="referencesRepositoryClient"></param>
     public PrefabDataManager(ApplicationSettings applicationSettings, ISerializer serializer, IApplicationFileSystem applicationFileSystem, 
         IPrefabsRepositoryClient prefabsRepositoryClient, IPrefabFilesRepositoryClient filesRepositoryClient, IReferencesRepositoryClient referencesRepositoryClient)
     {
@@ -37,6 +46,7 @@ public PrefabDataManager(ApplicationSettings applicationSettings, ISerializer se
         this.applicationFileSystem = Guard.Argument(applicationFileSystem).NotNull().Value;
     }
 
+    ///<inheritdoc/>
     public IEnumerable<PrefabProject> GetAllPrefabs(string applicationId)
     {
         if (!prefabsCache.ContainsKey(applicationId))
@@ -46,6 +56,7 @@ public IEnumerable<PrefabProject> GetAllPrefabs(string applicationId)
         return prefabsCache[applicationId];
     }
 
+    ///<inheritdoc/>
     public IEnumerable<PrefabProject> GetPrefabsForScreen(ApplicationDescription applicationDescription, string screenName)
     {
         if (applicationDescription.AvailablePrefabs.ContainsKey(screenName))
@@ -63,15 +74,38 @@ public IEnumerable<PrefabProject> GetPrefabsForScreen(ApplicationDescription app
         yield break;
     }
 
+    ///<inheritdoc/>
+    public async Task DownloadPrefabDataAsync(string applicationId, string prefabId, string prefabVersion)
+    {
+        Guard.Argument(applicationId, nameof(applicationId)).NotNull().NotEmpty();
+        Guard.Argument(prefabId, nameof(prefabId)).NotNull().NotEmpty();
+        Guard.Argument(prefabVersion, nameof(prefabVersion)).NotNull().NotEmpty();       
+        var prefabProject = LoadPrefabFromLocalStorage(applicationId, prefabId);
+        var versionToDownload = prefabProject.AvailableVersions.FirstOrDefault(a => a.Version.ToString().Equals(prefabVersion))
+            ?? throw new ArgumentException($"Version {prefabVersion} doesn't exist for prefab {prefabProject.PrefabName}");
+        await DownloadPrefabDataAsync(prefabProject, versionToDownload);
+    }
+
+    ///<inheritdoc/>
     public async Task DownloadPrefabDataAsync(PrefabProject prefabProject, PrefabVersion prefabVersion)
     {
+        Guard.Argument(prefabProject, nameof(prefabProject)).NotNull();
+        Guard.Argument(prefabVersion, nameof(prefabVersion)).NotNull();
+
         var prefabsDirectory = Path.Combine(this.applicationFileSystem.GetPrefabProjectDirectory(prefabProject), prefabVersion.ToString());
-        if(!Directory.Exists(prefabsDirectory))
+        if (!Directory.Exists(prefabsDirectory))
         {
             Directory.CreateDirectory(prefabsDirectory);
-        }        
+        }    
+      
         if(IsOnlineMode)
-        {
+        {           
+            if(HasMostRecentDataAlreadyAvailable())
+            {
+                logger.Information("Skip download of version {0} of prefab project {1}. Data already available.", prefabVersion, prefabProject.PrefabName);
+                return;
+            }
+            
             //Download project references data
             var projectReferences = await this.referencesRepositoryClient.GetProjectReferencesAsync(prefabProject.PrefabId, prefabVersion.ToString());
             if (projectReferences != null)
@@ -80,9 +114,27 @@ public async Task DownloadPrefabDataAsync(PrefabProject prefabProject, PrefabVer
                 this.serializer.Serialize(prefabReferencesFile, projectReferences);
             }
             await DownloadFilesWithTagsAsync(prefabProject, prefabVersion, new[] { prefabProject.PrefabId });
+            logger.Information("Download completed for version {0} of prefab project {1}", prefabVersion, prefabProject.PrefabName);
+        }
+
+        bool HasMostRecentDataAlreadyAvailable()
+        {
+            string lastUpdatedDataFile = Path.Combine(prefabsDirectory, Constants.LastUpdatedFileName);
+            DateTime lastUpdated = DateTime.MinValue.ToUniversalTime();
+            if (File.Exists(lastUpdatedDataFile))
+            {
+                if (!DateTime.TryParse(File.ReadAllText(lastUpdatedDataFile), out lastUpdated))
+                {
+                    throw new Exception($"Failed to read last updated data from file : {lastUpdatedDataFile}");
+                }
+                File.Delete(lastUpdatedDataFile);
+            }
+            File.WriteAllText(lastUpdatedDataFile, DateTime.Now.ToUniversalTime().ToString("O"));
+            return (prefabVersion.IsPublished && prefabVersion.PublishedOn < lastUpdated);           
         }
     }
 
+    ///<inheritdoc/>
     public async Task DownloadPrefabsAsync()
     {
         if (IsOnlineMode)
@@ -102,10 +154,11 @@ public async Task DownloadPrefabsAsync()
                 }
                 serializer.Serialize(prefabFile, prefab);
             }
+            logger.Information("Download of Prefabs completed");
         }
     }
 
-
+    ///<inheritdoc/>
     public async Task AddPrefabAsync(PrefabProject prefabProject)
     {
         if (IsOnlineMode)
@@ -127,6 +180,8 @@ public async Task AddPrefabAsync(PrefabProject prefabProject)
             {
                 await AddOrUpdateDataFileAsync(prefabProject, prefabProject.LatestActiveVersion, file, prefabProject.PrefabId);
             }
+
+            logger.Information("Prefab project {@prefabProject} was added.", prefabProject);
         }
 
         ////when a new prefab is created , add it to the prefabs cache
@@ -159,6 +214,7 @@ await this.filesClient.AddProjectDataFile(new Core.Models.ProjectDataFile()
                 FilePath = Path.GetRelativePath(prefabsDirectory, filePath),
                 Tag = tag,
             }, filePath);
+            logger.Information("File {0} belonging to version {1} of prefab project {2} was added/updated.", Path.GetFileName(filePath), prefabVersion.ToString(), prefabProject.PrefabName);
         }
     }
 
@@ -173,8 +229,10 @@ public async Task DeleteDataFileAsync(PrefabProject prefabProject, PrefabVersion
         {
             File.Delete(fileToDelete);
         }
+        logger.Information("File {0} belonging to version {1} of prefab project {2} was deleted.", Path.GetFileName(fileToDelete), prefabVersion.ToString(), prefabProject.PrefabName);
     }
 
+    ///<inheritdoc/>
     public async Task AddPrefabVersionAsync(PrefabProject prefabProject, PrefabVersion newVersion, PrefabVersion cloneFrom)
     {
         if (IsOnlineMode)
@@ -197,7 +255,6 @@ void CopyAll(DirectoryInfo source, DirectoryInfo target)
                 {
                     fi.CopyTo(Path.Combine(target.FullName, fi.Name), true);
                 }
-
                 // Copy each subdirectory using recursion.
                 foreach (DirectoryInfo diSourceSubDir in source.GetDirectories())
                 {
@@ -207,13 +264,13 @@ void CopyAll(DirectoryInfo source, DirectoryInfo target)
             }
         }
 
-
         prefabProject.AvailableVersions.Add(newVersion);
         string prefabDescriptionFile = this.applicationFileSystem.GetPrefabProjectFile(prefabProject);
         serializer.Serialize<PrefabProject>(prefabDescriptionFile, prefabProject);
-
+        logger.Information("Added new version {0} of prefab {1} from version {2}.", newVersion.ToString(), prefabProject.PrefabName, cloneFrom.ToString());
     }
 
+    ///<inheritdoc/>
     public async Task UpdatePrefabVersionAsync(PrefabProject prefabProject, PrefabVersion prefabVersion)
     {
         if (IsOnlineMode)
@@ -222,37 +279,41 @@ public async Task UpdatePrefabVersionAsync(PrefabProject prefabProject, PrefabVe
         }
         string prefabDescriptionFile = this.applicationFileSystem.GetPrefabProjectFile(prefabProject);
         serializer.Serialize<PrefabProject>(prefabDescriptionFile, prefabProject);
+        logger.Information("Version {0} of prefab {1} was updated.", prefabVersion.ToString(), prefabProject.PrefabName);
     }
-    
-    public async Task SavePrefabDataAsync(PrefabProject prefabProject, PrefabVersion prefabVerssion)
+
+    ///<inheritdoc/>
+    public async Task SavePrefabDataAsync(PrefabProject prefabProject, PrefabVersion prefabVersion)
     {
         if (IsOnlineMode)
         {
-            string projectDirectory = Path.Combine(this.applicationFileSystem.GetPrefabProjectDirectory(prefabProject), prefabVerssion.ToString());
+            string projectDirectory = Path.Combine(this.applicationFileSystem.GetPrefabProjectDirectory(prefabProject), prefabVersion.ToString());
             
             string processsFile = Path.Combine(projectDirectory, Constants.PrefabProcessFileName);
-            await AddOrUpdateDataFileAsync(prefabProject, prefabVerssion, processsFile, prefabProject.PrefabId);
+            await AddOrUpdateDataFileAsync(prefabProject, prefabVersion, processsFile, prefabProject.PrefabId);
 
             string templateFile = Path.Combine(projectDirectory, Constants.PrefabTemplateFileName);
             if(File.Exists(templateFile))
             {
-                await AddOrUpdateDataFileAsync(prefabProject, prefabVerssion, templateFile, prefabProject.PrefabId);
+                await AddOrUpdateDataFileAsync(prefabProject, prefabVersion, templateFile, prefabProject.PrefabId);
             }
                        
             foreach (var file in Directory.EnumerateFiles(Path.Combine(projectDirectory, Constants.ReferencesDirectory), "*.*"))
             {
-                await AddOrUpdateDataFileAsync(prefabProject, prefabVerssion, file, prefabProject.PrefabId);
+                await AddOrUpdateDataFileAsync(prefabProject, prefabVersion, file, prefabProject.PrefabId);
             }            
 
             foreach (var file in Directory.EnumerateFiles(Path.Combine(projectDirectory, Constants.DataModelDirectory), "*.cs"))
             {
-                await AddOrUpdateDataFileAsync(prefabProject, prefabVerssion, file, prefabProject.PrefabId);
+                await AddOrUpdateDataFileAsync(prefabProject, prefabVersion, file, prefabProject.PrefabId);
             }
 
             foreach (var file in Directory.EnumerateFiles(Path.Combine(projectDirectory, Constants.ScriptsDirectory), "*.csx"))
             {
-                await AddOrUpdateDataFileAsync(prefabProject, prefabVerssion, file, prefabProject.PrefabId);
+                await AddOrUpdateDataFileAsync(prefabProject, prefabVersion, file, prefabProject.PrefabId);
             }
+
+            logger.Information("Data for version {0} of prefab {1} was saved.", prefabVersion.ToString(), prefabProject.PrefabName);
         }
     }
 
@@ -300,4 +361,15 @@ private List<PrefabProject> LoadPrefabsFromLocalStorage(string applicationId)
         return prefabProjects;
     }
 
+    private PrefabProject LoadPrefabFromLocalStorage(string applicationId, string prefabId)
+    {        
+        var prefabProjectFile = Path.Combine(this.applicationFileSystem.GetApplicationPrefabsDirectory(applicationId), prefabId, $"{prefabId}.atm");      
+        if (File.Exists(prefabProjectFile))
+        {
+            PrefabProject prefabProject = serializer.Deserialize<PrefabProject>(prefabProjectFile);
+            return prefabProject;
+        }
+        throw new FileNotFoundException($"File {prefabProjectFile} doesn't exist.");
+    }
+
 }
diff --git a/src/Pixel.Persistence.Services.Client/DataManagers/ProjectDataManager.cs b/src/Pixel.Persistence.Services.Client/DataManagers/ProjectDataManager.cs
@@ -11,7 +11,6 @@
 using System.IO.Compression;
 using System.Linq;
 using System.Threading.Tasks;
-using static System.Net.Mime.MediaTypeNames;
 
 namespace Pixel.Persistence.Services.Client;
 
diff --git a/src/Pixel.Persistence.Services.Client/Interfaces/IPrefabDataManager.cs b/src/Pixel.Persistence.Services.Client/Interfaces/IPrefabDataManager.cs
@@ -27,6 +27,15 @@ public interface IPrefabDataManager
     /// <returns></returns>
     Task DownloadPrefabsAsync();
 
+    /// <summary>
+    /// Download data files for a given version of prefab
+    /// </summary>
+    /// <param name="applicationId"></param>
+    /// <param name="prefabId"></param>
+    /// <param name="prefabVersion"></param>
+    /// <returns></returns>
+    Task DownloadPrefabDataAsync(string applicationId, string prefabId, string prefabVersion);
+
     /// <summary>
     /// Download data files for a given version of Prefab
     /// </summary>

Original file line number	Diff line number	Diff line change
`@@ -63,8 +63,7 @@ protected override void OnStartup(object sender, StartupEventArgs e)`
`63`	`63`	`logger.Information("Downloading project information now");`
`64`	`64`	`await projectDataManager.DownloadProjectsAsync();`
`65`	`65`	`logger.Information("Download of project information completed");`
`66`		`- await prefabDataManager.DownloadPrefabsAsync();`
`67`		`- logger.Information("Download of prefabs completed");`
	`66`	`+ await prefabDataManager.DownloadPrefabsAsync();`
`68`	`67`	`}`
`69`	`68`	`catch (Exception ex)`
`70`	`69`	`{`
Original file line number	Diff line number	Diff line change
`@@ -53,8 +53,7 @@ public async Task<Entity> Load(AutomationProject activeProject, VersionInfo ver`
`53`	`53`
`54`	`54`	`foreach(var prefabReference in this.referenceManager.GetPrefabReferences().References)`
`55`	`55`	`{`
`56`		`- await this.prefabDataManager.DownloadPrefabDataAsync(new PrefabProject() { ApplicationId = prefabReference.ApplicationId, PrefabId = prefabReference.PrefabId },`
`57`		`- prefabReference.Version);`
	`56`	`+ await this.prefabDataManager.DownloadPrefabDataAsync(prefabReference.ApplicationId, prefabReference.PrefabId, prefabReference.Version.ToString());`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`this.entityManager.SetCurrentFileSystem(this.fileSystem);`
Original file line number	Diff line number	Diff line change
`@@ -107,12 +107,7 @@ public async Task LoadProjectAsync(string projectId, string projectVersion, stri`
`107`	`107`
`108`	`108`	`foreach (var prefabReference in this.referenceManager.GetPrefabReferences().References)`
`109`	`109`	`{`
`110`		`- await this.prefabDataManager.DownloadPrefabDataAsync(new Core.Models.PrefabProject()`
`111`		`- {`
`112`		`- ApplicationId = prefabReference.ApplicationId,`
`113`		`- PrefabId = prefabReference.PrefabId`
`114`		`- },`
`115`		`- prefabReference.Version);`
	`110`	`+ await this.prefabDataManager.DownloadPrefabDataAsync( prefabReference.ApplicationId, prefabReference.PrefabId, prefabReference.Version.ToString());`
`116`	`111`	`}`
`117`	`112`
`118`	`113`	`this.entityManager.SetCurrentFileSystem(this.projectFileSystem);`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,11 @@ public abstract class VersionInfo`
`27`	`27`	`[DataMember(IsRequired = false, Order = 30)]`
`28`	`28`	`public string DataModelAssembly { get; set; }`
`29`	`29`
	`30`	`+`
	`31`	`+ [DataMember(IsRequired = false, Order = 40)]`
	`32`	`+ public DateTime? PublishedOn { get; set; }`
	`33`	`+`
	`34`	`+`
`30`	`35`	`public override bool Equals(object obj)`
`31`	`36`	`{`
`32`	`37`	`if(obj is VersionInfo versionInfo)`
`@@ -38,7 +43,7 @@ public override bool Equals(object obj)`
`38`	`43`
`39`	`44`	`public override int GetHashCode()`
`40`	`45`	`{`
`41`		`- return HashCode.Combine(Version, IsActive, DataModelAssembly);`
	`46`	`+ return HashCode.Combine(Version, IsActive);`
`42`	`47`	`}`
`43`	`48`
`44`	`49`	`public override string ToString()`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,15 @@ public class PrefabDataManager : IPrefabDataManager`
`26`	`26`
`27`	`27`	`bool IsOnlineMode => !this.applicationSettings.IsOfflineMode;`
`28`	`28`
	`29`	`+ /// <summary>`
	`30`	`+ /// constructor`
	`31`	`+ /// </summary>`
	`32`	`+ /// <param name="applicationSettings"></param>`
	`33`	`+ /// <param name="serializer"></param>`
	`34`	`+ /// <param name="applicationFileSystem"></param>`
	`35`	`+ /// <param name="prefabsRepositoryClient"></param>`
	`36`	`+ /// <param name="filesRepositoryClient"></param>`
	`37`	`+ /// <param name="referencesRepositoryClient"></param>`
`29`	`38`	`public PrefabDataManager(ApplicationSettings applicationSettings, ISerializer serializer, IApplicationFileSystem applicationFileSystem,`
`30`	`39`	`IPrefabsRepositoryClient prefabsRepositoryClient, IPrefabFilesRepositoryClient filesRepositoryClient, IReferencesRepositoryClient referencesRepositoryClient)`
`31`	`40`	`{`
`@@ -37,6 +46,7 @@ public PrefabDataManager(ApplicationSettings applicationSettings, ISerializer se`
`37`	`46`	`this.applicationFileSystem = Guard.Argument(applicationFileSystem).NotNull().Value;`
`38`	`47`	`}`
`39`	`48`
	`49`	`+ ///<inheritdoc/>`
`40`	`50`	`public IEnumerable<PrefabProject> GetAllPrefabs(string applicationId)`
`41`	`51`	`{`
`42`	`52`	`if (!prefabsCache.ContainsKey(applicationId))`
`@@ -46,6 +56,7 @@ public IEnumerable<PrefabProject> GetAllPrefabs(string applicationId)`
`46`	`56`	`return prefabsCache[applicationId];`
`47`	`57`	`}`
`48`	`58`
	`59`	`+ ///<inheritdoc/>`
`49`	`60`	`public IEnumerable<PrefabProject> GetPrefabsForScreen(ApplicationDescription applicationDescription, string screenName)`
`50`	`61`	`{`
`51`	`62`	`if (applicationDescription.AvailablePrefabs.ContainsKey(screenName))`
`@@ -63,15 +74,38 @@ public IEnumerable<PrefabProject> GetPrefabsForScreen(ApplicationDescription app`
`63`	`74`	`yield break;`
`64`	`75`	`}`
`65`	`76`
	`77`	`+ ///<inheritdoc/>`
	`78`	`+ public async Task DownloadPrefabDataAsync(string applicationId, string prefabId, string prefabVersion)`
	`79`	`+ {`
	`80`	`+ Guard.Argument(applicationId, nameof(applicationId)).NotNull().NotEmpty();`
	`81`	`+ Guard.Argument(prefabId, nameof(prefabId)).NotNull().NotEmpty();`
	`82`	`+ Guard.Argument(prefabVersion, nameof(prefabVersion)).NotNull().NotEmpty();`
	`83`	`+ var prefabProject = LoadPrefabFromLocalStorage(applicationId, prefabId);`
	`84`	`+ var versionToDownload = prefabProject.AvailableVersions.FirstOrDefault(a => a.Version.ToString().Equals(prefabVersion))`
	`85`	`+ ?? throw new ArgumentException($"Version {prefabVersion} doesn't exist for prefab {prefabProject.PrefabName}");`
	`86`	`+ await DownloadPrefabDataAsync(prefabProject, versionToDownload);`
	`87`	`+ }`
	`88`	`+`
	`89`	`+ ///<inheritdoc/>`
`66`	`90`	`public async Task DownloadPrefabDataAsync(PrefabProject prefabProject, PrefabVersion prefabVersion)`
`67`	`91`	`{`
	`92`	`+ Guard.Argument(prefabProject, nameof(prefabProject)).NotNull();`
	`93`	`+ Guard.Argument(prefabVersion, nameof(prefabVersion)).NotNull();`
	`94`	`+`
`68`	`95`	`var prefabsDirectory = Path.Combine(this.applicationFileSystem.GetPrefabProjectDirectory(prefabProject), prefabVersion.ToString());`
`69`		`- if(!Directory.Exists(prefabsDirectory))`
	`96`	`+ if (!Directory.Exists(prefabsDirectory))`
`70`	`97`	`{`
`71`	`98`	`Directory.CreateDirectory(prefabsDirectory);`
`72`		`- }`
	`99`	`+ }`
	`100`	`+`
`73`	`101`	`if(IsOnlineMode)`
`74`		`- {`
	`102`	`+ {`
	`103`	`+ if(HasMostRecentDataAlreadyAvailable())`
	`104`	`+ {`
	`105`	`+ logger.Information("Skip download of version {0} of prefab project {1}. Data already available.", prefabVersion, prefabProject.PrefabName);`
	`106`	`+ return;`
	`107`	`+ }`
	`108`	`+`
`75`	`109`	`//Download project references data`
`76`	`110`	`var projectReferences = await this.referencesRepositoryClient.GetProjectReferencesAsync(prefabProject.PrefabId, prefabVersion.ToString());`
`77`	`111`	`if (projectReferences != null)`
`@@ -80,9 +114,27 @@ public async Task DownloadPrefabDataAsync(PrefabProject prefabProject, PrefabVer`
`80`	`114`	`this.serializer.Serialize(prefabReferencesFile, projectReferences);`
`81`	`115`	`}`
`82`	`116`	`await DownloadFilesWithTagsAsync(prefabProject, prefabVersion, new[] { prefabProject.PrefabId });`
	`117`	`+ logger.Information("Download completed for version {0} of prefab project {1}", prefabVersion, prefabProject.PrefabName);`
	`118`	`+ }`
	`119`	`+`
	`120`	`+ bool HasMostRecentDataAlreadyAvailable()`
	`121`	`+ {`
	`122`	`+ string lastUpdatedDataFile = Path.Combine(prefabsDirectory, Constants.LastUpdatedFileName);`
	`123`	`+ DateTime lastUpdated = DateTime.MinValue.ToUniversalTime();`
	`124`	`+ if (File.Exists(lastUpdatedDataFile))`
	`125`	`+ {`
	`126`	`+ if (!DateTime.TryParse(File.ReadAllText(lastUpdatedDataFile), out lastUpdated))`
	`127`	`+ {`
	`128`	`+ throw new Exception($"Failed to read last updated data from file : {lastUpdatedDataFile}");`
	`129`	`+ }`
	`130`	`+ File.Delete(lastUpdatedDataFile);`
	`131`	`+ }`
	`132`	`+ File.WriteAllText(lastUpdatedDataFile, DateTime.Now.ToUniversalTime().ToString("O"));`
	`133`	`+ return (prefabVersion.IsPublished && prefabVersion.PublishedOn < lastUpdated);`
`83`	`134`	`}`
`84`	`135`	`}`
`85`	`136`
	`137`	`+ ///<inheritdoc/>`
`86`	`138`	`public async Task DownloadPrefabsAsync()`
`87`	`139`	`{`
`88`	`140`	`if (IsOnlineMode)`
`@@ -102,10 +154,11 @@ public async Task DownloadPrefabsAsync()`
`102`	`154`	`}`
`103`	`155`	`serializer.Serialize(prefabFile, prefab);`
`104`	`156`	`}`
	`157`	`+ logger.Information("Download of Prefabs completed");`
`105`	`158`	`}`
`106`	`159`	`}`
`107`	`160`
`108`		`-`
	`161`	`+ ///<inheritdoc/>`
`109`	`162`	`public async Task AddPrefabAsync(PrefabProject prefabProject)`
`110`	`163`	`{`
`111`	`164`	`if (IsOnlineMode)`
`@@ -127,6 +180,8 @@ public async Task AddPrefabAsync(PrefabProject prefabProject)`
`127`	`180`	`{`
`128`	`181`	`await AddOrUpdateDataFileAsync(prefabProject, prefabProject.LatestActiveVersion, file, prefabProject.PrefabId);`
`129`	`182`	`}`
	`183`	`+`
	`184`	`+ logger.Information("Prefab project {@prefabProject} was added.", prefabProject);`
`130`	`185`	`}`
`131`	`186`
`132`	`187`	`////when a new prefab is created , add it to the prefabs cache`
`@@ -159,6 +214,7 @@ await this.filesClient.AddProjectDataFile(new Core.Models.ProjectDataFile()`
`159`	`214`	`FilePath = Path.GetRelativePath(prefabsDirectory, filePath),`
`160`	`215`	`Tag = tag,`
`161`	`216`	`}, filePath);`
	`217`	`+ logger.Information("File {0} belonging to version {1} of prefab project {2} was added/updated.", Path.GetFileName(filePath), prefabVersion.ToString(), prefabProject.PrefabName);`
`162`	`218`	`}`
`163`	`219`	`}`
`164`	`220`
`@@ -173,8 +229,10 @@ public async Task DeleteDataFileAsync(PrefabProject prefabProject, PrefabVersion`
`173`	`229`	`{`
`174`	`230`	`File.Delete(fileToDelete);`
`175`	`231`	`}`
	`232`	`+ logger.Information("File {0} belonging to version {1} of prefab project {2} was deleted.", Path.GetFileName(fileToDelete), prefabVersion.ToString(), prefabProject.PrefabName);`
`176`	`233`	`}`
`177`	`234`
	`235`	`+ ///<inheritdoc/>`
`178`	`236`	`public async Task AddPrefabVersionAsync(PrefabProject prefabProject, PrefabVersion newVersion, PrefabVersion cloneFrom)`
`179`	`237`	`{`
`180`	`238`	`if (IsOnlineMode)`
`@@ -197,7 +255,6 @@ void CopyAll(DirectoryInfo source, DirectoryInfo target)`
`197`	`255`	`{`
`198`	`256`	`fi.CopyTo(Path.Combine(target.FullName, fi.Name), true);`
`199`	`257`	`}`
`200`		`-`
`201`	`258`	`// Copy each subdirectory using recursion.`
`202`	`259`	`foreach (DirectoryInfo diSourceSubDir in source.GetDirectories())`
`203`	`260`	`{`
`@@ -207,13 +264,13 @@ void CopyAll(DirectoryInfo source, DirectoryInfo target)`
`207`	`264`	`}`
`208`	`265`	`}`
`209`	`266`
`210`		`-`
`211`	`267`	`prefabProject.AvailableVersions.Add(newVersion);`
`212`	`268`	`string prefabDescriptionFile = this.applicationFileSystem.GetPrefabProjectFile(prefabProject);`
`213`	`269`	`serializer.Serialize<PrefabProject>(prefabDescriptionFile, prefabProject);`
`214`		`-`
	`270`	`+ logger.Information("Added new version {0} of prefab {1} from version {2}.", newVersion.ToString(), prefabProject.PrefabName, cloneFrom.ToString());`
`215`	`271`	`}`
`216`	`272`
	`273`	`+ ///<inheritdoc/>`
`217`	`274`	`public async Task UpdatePrefabVersionAsync(PrefabProject prefabProject, PrefabVersion prefabVersion)`
`218`	`275`	`{`
`219`	`276`	`if (IsOnlineMode)`
`@@ -222,37 +279,41 @@ public async Task UpdatePrefabVersionAsync(PrefabProject prefabProject, PrefabVe`
`222`	`279`	`}`
`223`	`280`	`string prefabDescriptionFile = this.applicationFileSystem.GetPrefabProjectFile(prefabProject);`
`224`	`281`	`serializer.Serialize<PrefabProject>(prefabDescriptionFile, prefabProject);`
	`282`	`+ logger.Information("Version {0} of prefab {1} was updated.", prefabVersion.ToString(), prefabProject.PrefabName);`
`225`	`283`	`}`
`226`		`-`
`227`		`- public async Task SavePrefabDataAsync(PrefabProject prefabProject, PrefabVersion prefabVerssion)`
	`284`	`+`
	`285`	`+ ///<inheritdoc/>`
	`286`	`+ public async Task SavePrefabDataAsync(PrefabProject prefabProject, PrefabVersion prefabVersion)`
`228`	`287`	`{`
`229`	`288`	`if (IsOnlineMode)`
`230`	`289`	`{`
`231`		`- string projectDirectory = Path.Combine(this.applicationFileSystem.GetPrefabProjectDirectory(prefabProject), prefabVerssion.ToString());`
	`290`	`+ string projectDirectory = Path.Combine(this.applicationFileSystem.GetPrefabProjectDirectory(prefabProject), prefabVersion.ToString());`
`232`	`291`
`233`	`292`	`string processsFile = Path.Combine(projectDirectory, Constants.PrefabProcessFileName);`
`234`		`- await AddOrUpdateDataFileAsync(prefabProject, prefabVerssion, processsFile, prefabProject.PrefabId);`
	`293`	`+ await AddOrUpdateDataFileAsync(prefabProject, prefabVersion, processsFile, prefabProject.PrefabId);`
`235`	`294`
`236`	`295`	`string templateFile = Path.Combine(projectDirectory, Constants.PrefabTemplateFileName);`
`237`	`296`	`if(File.Exists(templateFile))`
`238`	`297`	`{`
`239`		`- await AddOrUpdateDataFileAsync(prefabProject, prefabVerssion, templateFile, prefabProject.PrefabId);`
	`298`	`+ await AddOrUpdateDataFileAsync(prefabProject, prefabVersion, templateFile, prefabProject.PrefabId);`
`240`	`299`	`}`
`241`	`300`
`242`	`301`	`foreach (var file in Directory.EnumerateFiles(Path.Combine(projectDirectory, Constants.ReferencesDirectory), "."))`
`243`	`302`	`{`
`244`		`- await AddOrUpdateDataFileAsync(prefabProject, prefabVerssion, file, prefabProject.PrefabId);`
	`303`	`+ await AddOrUpdateDataFileAsync(prefabProject, prefabVersion, file, prefabProject.PrefabId);`
`245`	`304`	`}`
`246`	`305`
`247`	`306`	`foreach (var file in Directory.EnumerateFiles(Path.Combine(projectDirectory, Constants.DataModelDirectory), "*.cs"))`
`248`	`307`	`{`
`249`		`- await AddOrUpdateDataFileAsync(prefabProject, prefabVerssion, file, prefabProject.PrefabId);`
	`308`	`+ await AddOrUpdateDataFileAsync(prefabProject, prefabVersion, file, prefabProject.PrefabId);`
`250`	`309`	`}`
`251`	`310`
`252`	`311`	`foreach (var file in Directory.EnumerateFiles(Path.Combine(projectDirectory, Constants.ScriptsDirectory), "*.csx"))`
`253`	`312`	`{`
`254`		`- await AddOrUpdateDataFileAsync(prefabProject, prefabVerssion, file, prefabProject.PrefabId);`
	`313`	`+ await AddOrUpdateDataFileAsync(prefabProject, prefabVersion, file, prefabProject.PrefabId);`
`255`	`314`	`}`
	`315`	`+`
	`316`	`+ logger.Information("Data for version {0} of prefab {1} was saved.", prefabVersion.ToString(), prefabProject.PrefabName);`
`256`	`317`	`}`
`257`	`318`	`}`
`258`	`319`
`@@ -300,4 +361,15 @@ private List<PrefabProject> LoadPrefabsFromLocalStorage(string applicationId)`
`300`	`361`	`return prefabProjects;`
`301`	`362`	`}`
`302`	`363`
	`364`	`+ private PrefabProject LoadPrefabFromLocalStorage(string applicationId, string prefabId)`
	`365`	`+ {`
	`366`	`+ var prefabProjectFile = Path.Combine(this.applicationFileSystem.GetApplicationPrefabsDirectory(applicationId), prefabId, $"{prefabId}.atm");`
	`367`	`+ if (File.Exists(prefabProjectFile))`
	`368`	`+ {`
	`369`	`+ PrefabProject prefabProject = serializer.Deserialize<PrefabProject>(prefabProjectFile);`
	`370`	`+ return prefabProject;`
	`371`	`+ }`
	`372`	`+ throw new FileNotFoundException($"File {prefabProjectFile} doesn't exist.");`
	`373`	`+ }`
	`374`	`+`
`303`	`375`	`}`