Allow prefabs to be deleted

Nfactor26 · Nfactor26 · commit 2fb744b7f908 · 2022-12-11T19:43:24.000+05:30
1. Prefabs can be deleted if they are not in use by any project.
2. Added checks to prevent usage of prefab from clients with stale data if a prefab has already been deleted by other clients.
diff --git a/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabExplorerViewModel.cs b/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabExplorerViewModel.cs
@@ -11,6 +11,7 @@
 using Pixel.Persistence.Services.Client.Interfaces;
 using Serilog;
 using System.ComponentModel;
+using System.Windows;
 using System.Windows.Data;
 
 namespace Pixel.Automation.AppExplorer.ViewModels.Prefab
@@ -113,6 +114,10 @@ private List<PrefabProjectViewModel> LoadPrefabs(ApplicationDescriptionViewModel
                     var prefabs = this.prefabDataManager.GetPrefabsForScreen(applicationDescriptionViewModel.Model, screenName).ToList();
                     foreach (var prefab in prefabs)
                     {
+                        if(prefab.IsDeleted)
+                        {
+                            continue;
+                        }
                         var prefabProjectViewModel = new PrefabProjectViewModel(prefab);
                         applicationDescriptionViewModel.AddPrefab(prefabProjectViewModel, screenName);
                         prefabsList.Add(prefabProjectViewModel);
@@ -231,6 +236,26 @@ public async Task ManagePrefab(PrefabProjectViewModel targetPrefab)
             }
         }
 
+        /// <summary>
+        /// Delete the prefab
+        /// </summary>
+        /// <param name="prefabToDelete"></param>
+        public async Task DeletePrefabAsync(PrefabProjectViewModel prefabToDelete)
+        {
+            try
+            {
+                Guard.Argument(prefabToDelete, nameof(prefabToDelete)).NotNull();
+                await this.prefabDataManager.DeletePrefbAsync(prefabToDelete.PrefabProject);
+                this.Prefabs.Remove(prefabToDelete);
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex, "There was an error while trying to delete prefab : {0}", prefabToDelete.PrefabName);
+                MessageBox.Show($"Error while deleting prefab : {prefabToDelete.PrefabName}", "Delete Error", MessageBoxButton.OK, MessageBoxImage.Error);
+            }
+        }
+
+
         /// <summary>
         /// Broadcast a FilterTestMessage which is processed by Test explorer view to filter and show only those test cases
         /// which uses this prefab
diff --git a/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionManagerViewModel.cs b/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionManagerViewModel.cs
@@ -8,6 +8,7 @@
 using Pixel.Persistence.Services.Client.Interfaces;
 using Pixel.Scripting.Editor.Core.Contracts;
 using Serilog;
+using System.Windows;
 
 namespace Pixel.Automation.AppExplorer.ViewModels.Prefab
 {
@@ -61,7 +62,8 @@ public PrefabVersionManagerViewModel(PrefabProject prefabProject, IWorkspaceMana
         public async Task PublishAsync(PrefabVersionViewModel prefabVersionViewModel)
         {
             try
-            {              
+            {
+                Guard.Argument(prefabVersionViewModel, nameof(prefabVersionViewModel)).NotNull();           
                 if (!prefabVersionViewModel.IsPublished)
                 {                  
                     bool isLatestActieVersion = prefabProject.LatestActiveVersion.Version.Equals(prefabVersionViewModel.Version);
@@ -75,7 +77,8 @@ public async Task PublishAsync(PrefabVersionViewModel prefabVersionViewModel)
             }
             catch (Exception ex)
             {
-                logger.Error(ex, ex.Message);
+                logger.Error(ex, "There was an error while trying to publish verion : {0} of prefab : {1}", prefabVersionViewModel.Version, prefabVersionViewModel.PrefabName);
+                MessageBox.Show($"Error while publishing version {prefabVersionViewModel.Version} of prefab {prefabVersionViewModel.PrefabName}", "Publish Error", MessageBoxButton.OK, MessageBoxImage.Error);
             }
         }
 
@@ -87,6 +90,7 @@ public async Task CloneAsync(PrefabVersionViewModel prefabVersionViewModel)
         {
             try
             {
+                Guard.Argument(prefabVersionViewModel, nameof(prefabVersionViewModel)).NotNull();
                 if (prefabVersionViewModel.IsPublished)
                 {               
                     PrefabVersion newVersion = await prefabVersionViewModel.CloneAsync(this.prefabDataManager);
@@ -98,7 +102,8 @@ public async Task CloneAsync(PrefabVersionViewModel prefabVersionViewModel)
             }
             catch (Exception ex)
             {
-                logger.Error(ex, ex.Message);
+                logger.Error(ex, "There was an error while trying to create a new verion of prefab : {0} from version : {1}", prefabVersionViewModel.PrefabName, prefabVersionViewModel.Version);
+                MessageBox.Show($"Error while cloning version {prefabVersionViewModel.Version} of prefab {prefabVersionViewModel.PrefabName}", "Clone Error", MessageBoxButton.OK, MessageBoxImage.Error);
             }
         }
 
diff --git a/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionViewModel.cs b/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionViewModel.cs
@@ -20,6 +20,11 @@ public class PrefabVersionViewModel : PropertyChangedBase
         private readonly IPrefabFileSystem fileSystem;
         private readonly Lazy<IReferenceManager> referenceManager;
 
+        public string PrefabName
+        {
+            get => prefabProject.PrefabName;
+        }
+
         public Version Version
         {
             get => prefabVersion.Version;
diff --git a/src/Pixel.Automation.AppExplorer.ViewModels/PrefabDropHandler/PrefabVersionSelectorViewModel.cs b/src/Pixel.Automation.AppExplorer.ViewModels/PrefabDropHandler/PrefabVersionSelectorViewModel.cs
@@ -7,8 +7,10 @@
 using Pixel.Automation.Editor.Core.ViewModels;
 using Pixel.Automation.Reference.Manager;
 using Pixel.Automation.Reference.Manager.Contracts;
+using Pixel.Persistence.Services.Client.Interfaces;
 using Serilog;
 using System.IO;
+using System.Windows;
 
 namespace Pixel.Automation.AppExplorer.ViewModels.PrefabDropHandler
 {
@@ -86,13 +88,13 @@ public string OutputMappingScriptFile
         /// <param name="prefabProjectViewModel">Prefab which needs to be added to automation process</param>
         /// <param name="dropTarget">EntityComponentViewModel wrapping an Entity to which Prefab needs to be added</param>
         public PrefabVersionSelectorViewModel(IProjectFileSystem projectFileSystem, IPrefabFileSystem prefabFileSystem,
-            IReferenceManager projectReferenceManager,  PrefabEntity prefabEntity,
+            IReferenceManager projectReferenceManager, PrefabEntity prefabEntity,
             PrefabProjectViewModel prefabProjectViewModel, EntityComponentViewModel dropTarget)
         {
             this.DisplayName = "(1/3) Select prefab version and mapping scripts";
             this.projectFileSystem = projectFileSystem;
             this.prefabFileSystem = prefabFileSystem;
-            this.projectReferenceManager = projectReferenceManager;
+            this.projectReferenceManager = projectReferenceManager;          
             this.prefabEntity = prefabEntity;
             this.prefabProject = prefabProjectViewModel.PrefabProject;
             this.dropTarget = dropTarget;          
@@ -142,16 +144,24 @@ public void PickOutputMappingScriptFile()
         /// <inheritdoc/>   
         public override async Task<bool> TryProcessStage()
         {
-            //TODO : Can we make this asyc ?
-            if(this.SelectedVersion != null && !dropTarget.ComponentCollection.Any(a => a.Model.Equals(prefabEntity)))
+            try
             {
-                await UpdatePrefabReferencesAsync();
-                await UpdateControlReferencesAsync();
-                dropTarget.AddComponent(prefabEntity);
-                this.CanChangeVersion = false;
-                logger.Information("Added version {0} of {1} to {2}.", this.SelectedVersion, this.prefabProject, this.dropTarget);
-            }          
-            return true;        
+                if (this.SelectedVersion != null && !dropTarget.ComponentCollection.Any(a => a.Model.Equals(prefabEntity)))
+                {
+                    await UpdatePrefabReferencesAsync();
+                    await UpdateControlReferencesAsync();
+                    dropTarget.AddComponent(prefabEntity);
+                    this.CanChangeVersion = false;
+                    logger.Information("Added version {0} of {1} to {2}.", this.SelectedVersion, this.prefabProject, this.dropTarget);
+                }
+                return true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex, "There was an error while trying to process stage for the prefab version selector screen");
+                MessageBox.Show("Error while trying to add prefab", "Add Prefab Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                return false;
+            }  
         }
 
         /// <summary>
diff --git a/src/Pixel.Automation.AppExplorer.Views/Prefab/PrefabExplorerView.xaml b/src/Pixel.Automation.AppExplorer.Views/Prefab/PrefabExplorerView.xaml
@@ -93,6 +93,7 @@
                                               cal:Action.TargetWithoutContext="{Binding Path=DataContext, RelativeSource={RelativeSource AncestorType={x:Type Grid}, AncestorLevel=2}}" cal:Message.Attach="[Event Click] = [Action ManagePrefab($dataContext)]"></MenuItem>
                                     <MenuItem x:Name="ShowUsage" Header="Show Usage" cal:Action.TargetWithoutContext="{Binding Path=DataContext, RelativeSource={RelativeSource AncestorType={x:Type Grid}, AncestorLevel=2}}" cal:Message.Attach="[Event Click] = [Action ShowUsage($dataContext)]"></MenuItem>
                                     <MenuItem x:Name="MoveToScreen" Header="Move To Screen" cal:Action.TargetWithoutContext="{Binding Path=DataContext, RelativeSource={RelativeSource AncestorType={x:Type Grid}, AncestorLevel=2}}" cal:Message.Attach="[Event Click] = [Action MoveToScreen($dataContext)]"></MenuItem>
+                                    <MenuItem x:Name="Delete" Header="Delete" cal:Action.TargetWithoutContext="{Binding Path=DataContext, RelativeSource={RelativeSource AncestorType={x:Type Grid}, AncestorLevel=2}}" cal:Message.Attach="[Event Click] = [Action DeletePrefabAsync($dataContext)]" ></MenuItem>
                                 </StackPanel>
                             </ControlTemplate>
                         </ContextMenu.Template>
diff --git a/src/Pixel.Automation.Core/Models/PrefabProject.cs b/src/Pixel.Automation.Core/Models/PrefabProject.cs
@@ -49,6 +49,12 @@ public class PrefabProject : ICloneable
         [DataMember(Order = 70)]
         public string GroupName { get; set; } = "Default";
 
+        /// <summary>
+        /// Indicates if Prefab project is marked deleted.
+        /// </summary>
+        [DataMember(Order = 1000)]
+        public bool IsDeleted { get; set; }
+
         /// <summary>
         /// Get all the versions that are active.
         /// </summary>
diff --git a/src/Pixel.Persistence.Respository/Interfaces/IControlRepository.cs b/src/Pixel.Persistence.Respository/Interfaces/IControlRepository.cs
@@ -52,7 +52,7 @@ public interface IControlRepository
     Task<bool> IsControlDeleted(string applicationId, string controlId);
 
     /// <summary>
-    /// Set IsDeleted flag on all versionf of control to true.
+    /// Set IsDeleted flag on all versions of control to true.
     /// </summary>
     /// <param name="applicationId"></param>
     /// <param name="controlId"></param>
diff --git a/src/Pixel.Persistence.Respository/Interfaces/IPrefabsRepository.cs b/src/Pixel.Persistence.Respository/Interfaces/IPrefabsRepository.cs
@@ -59,5 +59,19 @@ public interface IPrefabsRepository
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
         Task UpdatePrefabVersionAsync(string prefabId, PrefabVersion version, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Check if a Prefab is marked deleted
+        /// </summary>
+        /// <param name="prefabId"></param>
+        /// <returns></returns>
+        Task<bool> IsPrefabDeleted(string prefabId);
+
+        /// <summary>
+        /// Mark prefab as deleted.
+        /// </summary>
+        /// <param name="prefabId"></param>
+        /// <returns></returns>
+        Task DeletePrefabAsync(string prefabId);
     }
 }
diff --git a/src/Pixel.Persistence.Respository/Interfaces/IReferencesRepository.cs b/src/Pixel.Persistence.Respository/Interfaces/IReferencesRepository.cs
@@ -59,6 +59,23 @@ public interface IReferencesRepository
     /// <returns></returns>
     Task UpdateControlReference(string projectId, string projectVersion, ControlReference controlReference);
 
+
+    /// <summary>
+    /// Check if any version of prefab is in use by any version of any project
+    /// </summary>
+    /// <param name="prefabId"></param>
+    /// <returns></returns>
+    Task<bool> IsPrefabInUse(string prefabId);
+
+    /// <summary>
+    /// Check if any of the projets has a reference to any version of this prefab
+    /// </summary>
+    /// <param name="projectId"></param>
+    /// <param name="projectVersion"></param>
+    /// <param name="controlReference"></param>
+    /// <returns></returns>
+    //Task<bool> HasPrefabReference(string projectId, string projectVersion, PrefabReference prefabReference);
+
     /// <summary>
     /// Add or update PrefabReferences for a given version of project
     /// </summary>
diff --git a/src/Pixel.Persistence.Respository/PrefabsRepository.cs b/src/Pixel.Persistence.Respository/PrefabsRepository.cs
@@ -17,7 +17,7 @@ namespace Pixel.Persistence.Respository
     public class PrefabsRepository : IPrefabsRepository
     {
         private readonly ILogger logger;
-        private readonly IMongoCollection<PrefabProject> prefabsCollection;
+        private readonly IMongoCollection<PrefabProject> prefabsCollection;     
         private readonly IPrefabFilesRepository prefabFilesRepossitory;
         private readonly IReferencesRepository referencesRepository;
         private static readonly InsertOneOptions InsertOneOptions = new InsertOneOptions();
@@ -105,7 +105,9 @@ public async Task AddPrefabVersionAsync(string prefabId, PrefabVersion newVersio
             }
 
             filter = Builders<PrefabProject>.Filter.Eq(x => x.PrefabId, prefabId);
-            var push = Builders<PrefabProject>.Update.Push(t => t.AvailableVersions, newVersion);
+            var push = Builders<PrefabProject>.Update.Push(t => t.AvailableVersions, newVersion)
+                .Set(t => t.LastUpdated, DateTime.UtcNow)
+                .Inc(t => t.Revision, 1);
             await this.prefabsCollection.UpdateOneAsync(filter, push);
         }
 
@@ -125,12 +127,39 @@ public async Task UpdatePrefabVersionAsync(string prefabId, PrefabVersion prefab
                 {
                     prefabVersion.PublishedOn = DateTime.UtcNow;
                 }
-                var update = Builders<PrefabProject>.Update.Set(x => x.AvailableVersions[-1], prefabVersion);
+                var update = Builders<PrefabProject>.Update.Set(x => x.AvailableVersions[-1], prefabVersion)
+                     .Set(t => t.LastUpdated, DateTime.UtcNow)
+                     .Inc(t => t.Revision, 1); ;
                 await this.prefabsCollection.UpdateOneAsync(filter, update);
                 logger.LogInformation("Project version {0} was updated for project : {1}", prefabVersion, prefabId);
                 return;
             }
             throw new InvalidOperationException($"Version {prefabVersion} doesn't exist on prefab {prefabId}");
         }
+
+        ///<inheritdoc/>
+        public async Task<bool> IsPrefabDeleted(string prefabId)
+        {
+            Guard.Argument(prefabId, nameof(prefabId)).NotNull().NotEmpty();
+            var filter = Builders<PrefabProject>.Filter.Eq(x => x.PrefabId, prefabId) &
+                Builders<PrefabProject>.Filter.Eq(x => x.IsDeleted, true);
+            long count = await this.prefabsCollection.CountDocumentsAsync(filter, new CountOptions() { Limit = 1 });
+            return count > 0;
+        }
+
+        /// <inheritdoc/>
+        public async Task DeletePrefabAsync(string prefabId)
+        {
+            Guard.Argument(prefabId, nameof(prefabId)).NotNull();
+            if(await this.referencesRepository.IsPrefabInUse(prefabId))
+            {
+                throw new InvalidOperationException("Prefab is in use across one or more projects");
+            }
+            var updateFilter = Builders<PrefabProject>.Filter.Eq(x => x.PrefabId, prefabId);
+            var updateDefinition = Builders<PrefabProject>.Update.Set(x => x.IsDeleted, true)
+                .Set(x => x.LastUpdated, DateTime.UtcNow)
+                .Inc(t => t.Revision, 1);
+            await this.prefabsCollection.FindOneAndUpdateAsync<PrefabProject>(updateFilter, updateDefinition);
+        }
     }
 }
diff --git a/src/Pixel.Persistence.Respository/ReferencesRepository.cs b/src/Pixel.Persistence.Respository/ReferencesRepository.cs
@@ -9,6 +9,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using static System.Net.Mime.MediaTypeNames;
 
 namespace Pixel.Persistence.Respository;
 
@@ -80,6 +81,15 @@ public async Task UpdateControlReference(string projectId, string projectVersion
         logger.LogInformation("Control reference {0} was added to project : {1}", controlReference, projectId);
     }
 
+    /// <inheritdoc/>  
+    public async Task<bool> IsPrefabInUse(string prefabId)
+    {
+        var filter = Builders<ProjectReferences>.Filter.ElemMatch(x => x.PrefabReferences,
+               Builders<PrefabReference>.Filter.Eq(x => x.PrefabId, prefabId));
+        long count = await this.referencesCollection.CountDocumentsAsync(filter);
+        return count > 0;
+    }
+
     /// <inheritdoc/>  
     public async Task AddOrUpdatePrefabReference(string projectId, string projectVersion, PrefabReference prefabReference)
     {
diff --git a/src/Pixel.Persistence.Services.Api/Controllers/PrefabsController.cs b/src/Pixel.Persistence.Services.Api/Controllers/PrefabsController.cs
@@ -107,6 +107,11 @@ public async Task<ActionResult<ProjectVersion>> AddPrefabVersionAsync([FromRoute
                 Guard.Argument(request, nameof(request)).NotNull();
                 Guard.Argument(request, nameof(request)).Require(r => r.NewVersion != null, r => "NewVersion is required");
                 Guard.Argument(request, nameof(request)).Require(r => r.CloneFrom != null, r => "CloneFrom is required");
+                
+                if (await prefabsRepository.IsPrefabDeleted(prefabId))
+                {
+                    return Conflict($"Prefab : {prefabId} is marked deleted. New version can't be added.");
+                }
                 await prefabsRepository.AddPrefabVersionAsync(prefabId, request.NewVersion, request.CloneFrom, CancellationToken.None);
                 return Ok(request.NewVersion);
             }
@@ -125,6 +130,10 @@ public async Task<ActionResult<PrefabVersion>> UpdatePrefabVersionAsync([FromRou
             {
                 Guard.Argument(prefabId, nameof(prefabId)).NotNull().NotEmpty();
                 Guard.Argument(prefabVersion, nameof(prefabVersion)).NotNull();
+                if (await prefabsRepository.IsPrefabDeleted(prefabId))
+                {
+                    return Conflict($"Prefab : {prefabId} is marked deleted. Version : {prefabVersion} can't be added.");
+                }
                 await prefabsRepository.UpdatePrefabVersionAsync(prefabId, prefabVersion, CancellationToken.None);
                 return Ok(prefabVersion);
             }
@@ -134,5 +143,27 @@ public async Task<ActionResult<PrefabVersion>> UpdatePrefabVersionAsync([FromRou
                 return Problem(ex.Message, statusCode: StatusCodes.Status500InternalServerError);
             }
         }
+
+
+        [HttpGet("isdeleted/{prefabId}")]
+        public async Task<ActionResult<bool>> IsDeleted(string prefabId)
+        {           
+            bool isDeleted = await this.prefabsRepository.IsPrefabDeleted(prefabId);
+            return Ok(isDeleted);
+        }
+
+        [HttpDelete("{prefabId}")]
+        public async Task<IActionResult> DeletePrefab(string prefabId)
+        {
+            try
+            {             
+                await prefabsRepository.DeletePrefabAsync(prefabId);
+                return Ok();
+            }
+            catch (InvalidOperationException ex)
+            {
+                return Conflict(ex.Message);
+            }
+        }
     }
 }
diff --git a/src/Pixel.Persistence.Services.Api/Controllers/ReferencesController.cs b/src/Pixel.Persistence.Services.Api/Controllers/ReferencesController.cs
diff --git a/src/Pixel.Persistence.Services.Client/DataManagers/PrefabDataManager.cs b/src/Pixel.Persistence.Services.Client/DataManagers/PrefabDataManager.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/IPrefabsRepositoryClient.cs b/src/Pixel.Persistence.Services.Client/Interfaces/IPrefabsRepositoryClient.cs
diff --git a/src/Pixel.Persistence.Services.Client/PrefabsRepositoryClient.cs b/src/Pixel.Persistence.Services.Client/PrefabsRepositoryClient.cs

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`using Pixel.Persistence.Services.Client.Interfaces;`
`9`	`9`	`using Pixel.Scripting.Editor.Core.Contracts;`
`10`	`10`	`using Serilog;`
	`11`	`+using System.Windows;`
`11`	`12`
`12`	`13`	`namespace Pixel.Automation.AppExplorer.ViewModels.Prefab`
`13`	`14`	`{`
`@@ -61,7 +62,8 @@ public PrefabVersionManagerViewModel(PrefabProject prefabProject, IWorkspaceMana`
`61`	`62`	`public async Task PublishAsync(PrefabVersionViewModel prefabVersionViewModel)`
`62`	`63`	`{`
`63`	`64`	`try`
`64`		`- {`
	`65`	`+ {`
	`66`	`+ Guard.Argument(prefabVersionViewModel, nameof(prefabVersionViewModel)).NotNull();`
`65`	`67`	`if (!prefabVersionViewModel.IsPublished)`
`66`	`68`	`{`
`67`	`69`	`bool isLatestActieVersion = prefabProject.LatestActiveVersion.Version.Equals(prefabVersionViewModel.Version);`
`@@ -75,7 +77,8 @@ public async Task PublishAsync(PrefabVersionViewModel prefabVersionViewModel)`
`75`	`77`	`}`
`76`	`78`	`catch (Exception ex)`
`77`	`79`	`{`
`78`		`- logger.Error(ex, ex.Message);`
	`80`	`+ logger.Error(ex, "There was an error while trying to publish verion : {0} of prefab : {1}", prefabVersionViewModel.Version, prefabVersionViewModel.PrefabName);`
	`81`	`+ MessageBox.Show($"Error while publishing version {prefabVersionViewModel.Version} of prefab {prefabVersionViewModel.PrefabName}", "Publish Error", MessageBoxButton.OK, MessageBoxImage.Error);`
`79`	`82`	`}`
`80`	`83`	`}`
`81`	`84`
`@@ -87,6 +90,7 @@ public async Task CloneAsync(PrefabVersionViewModel prefabVersionViewModel)`
`87`	`90`	`{`
`88`	`91`	`try`
`89`	`92`	`{`
	`93`	`+ Guard.Argument(prefabVersionViewModel, nameof(prefabVersionViewModel)).NotNull();`
`90`	`94`	`if (prefabVersionViewModel.IsPublished)`
`91`	`95`	`{`
`92`	`96`	`PrefabVersion newVersion = await prefabVersionViewModel.CloneAsync(this.prefabDataManager);`
`@@ -98,7 +102,8 @@ public async Task CloneAsync(PrefabVersionViewModel prefabVersionViewModel)`
`98`	`102`	`}`
`99`	`103`	`catch (Exception ex)`
`100`	`104`	`{`
`101`		`- logger.Error(ex, ex.Message);`
	`105`	`+ logger.Error(ex, "There was an error while trying to create a new verion of prefab : {0} from version : {1}", prefabVersionViewModel.PrefabName, prefabVersionViewModel.Version);`
	`106`	`+ MessageBox.Show($"Error while cloning version {prefabVersionViewModel.Version} of prefab {prefabVersionViewModel.PrefabName}", "Clone Error", MessageBoxButton.OK, MessageBoxImage.Error);`
`102`	`107`	`}`
`103`	`108`	`}`
`104`	`109`