Merge pull request #2159 from BEXIS2/rc

Rc

Author: DavidBlaa

Components/AAA/BExIS.Security.Services/Utilities/MessageHelper.cs

@@ -38,6 +38,22 @@ public static string GetDeleteDatasetMessage(long datasetid, string userName, st
             return message + ".";
         }
 
+        public static string GetUndoDeleteDatasetHeader(long datasetid, string entityname)
+        {
+            return $"{entityname}: Restore (ID {datasetid})";
+        }
+
+        public static string GetUndoDeleteDatasetMessage(long datasetid, string userName, string entityname)
+        {
+            string message = $"{entityname} with ID <b>{datasetid}</b> was restored";
+
+            if (!string.IsNullOrEmpty(userName))
+
+                return message += $" by <b>{userName}</b>";
+
+            return message + ".";
+        }
+
         public static string GetTryToDeleteDatasetHeader(long datasetid, string entityname)
         {
             return $"{entityname}: Try to delete ID {datasetid}";

Components/DLM/BExIS.Dlm.Services/Data/DatasetManager.cs

@@ -592,6 +592,164 @@ public bool UndoDeleteDataset(Int64 datasetId, string username, bool rollbackChe
             }
         }
 
+        /// <summary>
+        /// Reset data of a dataset
+        /// If the dataset is checked out and the <paramref name="rollbackCheckout"/> is
+        /// True, the dataset's changes will be roll-backed and then the delete operation takes place, but if the <paramref name="rollbackCheckout"/> is false,
+        /// The changes will be checked in as a new version and then the deletion operation is executed.
+        /// </summary>
+        /// <param name="datasetId">The identifier of the dataset to be checked-in.</param>
+        /// <param name="username">The username that performs the check-in, which should be the same as the check-out username.</param>
+        /// <param name="rollbackCheckout">Determines whether latest uncommitted changes should be rolled back or checked in before marking the dataset as deleted.</param>
+        /// <returns>True if the dataset is deleted, False otherwise.</returns>
+        public bool RevertLastVersionOfDataset(Int64 datasetId, string username, bool rollbackCheckout)
+        {
+            string deleteReason = "Revert of entity " + datasetId; // @ToDO replace by variable from UI
+            Contract.Requires(datasetId >= 0);
+
+            using (IUnitOfWork uow = this.GetUnitOfWork())
+            {
+                IRepository<Dataset> datasetRepo = uow.GetRepository<Dataset>();
+                IRepository<DatasetVersion> datasetVersionRepo = uow.GetRepository<DatasetVersion>();
+                IRepository<DataTuple> tupleRepo = uow.GetRepository<DataTuple>();
+                IRepository<DataTupleVersion> tupleVersionRepo = uow.GetRepository<DataTupleVersion>();
+                IRepository<ContentDescriptor> contentDescriptorRepo = uow.GetRepository<ContentDescriptor>();
+
+                //this.DatasetRepo.Evict();
+                //this.DatasetVersionRepo.Evict();
+                //this.DataTupleRepo.Evict();
+                //this.DataTupleVerionRepo.Evict();
+
+                Dataset entity = datasetRepo.Get(datasetId);
+                if (entity.Status == DatasetStatus.Deleted)
+                    return false;
+                /// the dataset must be in CheckedIn state to be deleted
+                /// so if it is checked out, the checkout version (working copy) is removed first
+                if (entity.Status == DatasetStatus.CheckedOut)
+                {
+                    if (rollbackCheckout == true)
+                    {
+                        this.undoCheckout(entity.Id, username, false); // commit and behavior: create|refresh
+                    }
+                    else
+                    {
+                        throw new Exception(string.Format("Dataset {0} is in check out state, which prevents it from being deleted. Rollback the changes or check them in and try again", entity.Id));
+                    }
+                }
+
+                try
+                {
+
+                    // get the latest dataset with data (a)
+                    entity = datasetRepo.Get(entity.Id);
+                    var versions = entity.Versions.OrderBy(v => v.Id);
+
+                    if (versions.Count() <= 1) return false; // can not revert if one 
+
+                    var toDeletedDatasetVersion = versions.ElementAt(entity.Versions.Count - 1); // select the last version to be deleted
+                    var lastDatasetVersion = versions.ElementAt(entity.Versions.Count - 2); // select the second last version to be the new last version
+
+                    // get all old tuples version that go to the datatuples table
+                    var oldTupleVersions = tupleVersionRepo.Query().Where(t =>
+                        t.DatasetVersion.Id.Equals(lastDatasetVersion.Id) &&
+                        t.ActingDatasetVersion.Id.Equals(toDeletedDatasetVersion.Id)
+                        ).ToList();
+
+                    // copy datatuplversions -> datatuples table
+                    List<DataTuple> datatuples = new List<DataTuple>();
+                    foreach (var oldTupleVersion in oldTupleVersions)
+                    {
+                        DataTuple tuple = new DataTuple()
+                        {
+                            TupleAction = TupleAction.Edited,
+                            Extra = oldTupleVersion.Extra,
+                            //Id = orginalTuple.Id,
+                            OrderNo = oldTupleVersion.OrderNo,
+                            Timestamp = oldTupleVersion.Timestamp,
+                            XmlAmendments = oldTupleVersion.XmlAmendments,
+                            JsonVariableValues = oldTupleVersion.JsonVariableValues,
+                            DatasetVersion = oldTupleVersion.DatasetVersion, //latestCheckedInVersion,
+                            Values = oldTupleVersion.Values
+                        };
+
+                        datatuples.Add(tuple);
+                    }
+
+                    if (datatuples != null && datatuples.Count > 0)
+                    {
+                        int batchSize = uow.PersistenceManager.PreferredPushSize;
+                        List<DataTuple> processedTuples = null;
+                        long iterations = datatuples.Count / batchSize;
+                        if (iterations * batchSize < datatuples.Count)
+                            iterations++;
+                        for (int round = 0; round < iterations; round++)
+                        {
+                            processedTuples = datatuples.Skip(round * batchSize).Take(batchSize).ToList();
+                            tupleRepo.Put(processedTuples);
+                            uow.ClearCache(true); //flushes one batch of tuples
+                            processedTuples.Clear();
+                            GC.Collect();
+                        }
+                    }
+
+                    // // delete the old tuple versions
+                    tupleVersionRepo.Delete(oldTupleVersions.Select(v => v.Id).ToList());
+
+
+                    // all new tuples need to be deleted
+                    var newTuples = tupleRepo.Query().Where(t =>
+                       t.DatasetVersion.Id.Equals(toDeletedDatasetVersion.Id)
+                       ).ToList();
+
+                    tupleRepo.Delete(newTuples.Select(v => v.Id).ToList());
+
+                    //uow.Commit(); // commit datatuple changes
+
+                    lastDatasetVersion = datasetVersionRepo.Get(lastDatasetVersion.Id);
+                    lastDatasetVersion.Status = DatasetVersionStatus.CheckedIn;
+                    datasetVersionRepo.Put(lastDatasetVersion);
+
+                    entity.Status = DatasetStatus.CheckedIn;
+
+                    // check content descriptors
+                    if (toDeletedDatasetVersion.ContentDescriptors.Any())
+                    { 
+                        foreach (var contentDescriptor in toDeletedDatasetVersion.ContentDescriptors)
+                        {
+                            // remove the content descriptor from the dataset version
+                            contentDescriptorRepo.Delete(contentDescriptor.Id);
+                        }
+                    }
+
+                    datasetVersionRepo.Delete(toDeletedDatasetVersion.Id);
+                    //entity.Versions.Remove(deletedDatasetVersion);
+
+                    entity = datasetRepo.Get(datasetId); // maybe not needed!
+                    entity.Status = DatasetStatus.CheckedIn;
+                    datasetRepo.Put(entity);
+                    uow.Commit();
+
+                    // if any problem was detected during the commit, an exception will be thrown!
+                    if (entity.DataStructure != null)
+                    {
+                        SyncView(entity.Id, ViewCreationBehavior.Create | ViewCreationBehavior.Refresh);
+                    }
+
+                    LoggerFactory.LogCustom("entity " + datasetId + " returns from last version status");
+
+                    return (true);
+                }
+                catch (Exception ex)
+                {
+                    if (!IsDatasetCheckedIn(datasetId))
+                    {
+                        checkInDataset(entity.Id, "Checked-in after failed revert try!", username, false, ViewCreationBehavior.Create | ViewCreationBehavior.Refresh, "", TagType.None);
+                    }
+                    return false;
+                }
+            }
+        }
+
         /// <summary>
         /// Physically deletes the whole dataset, including its versions and data tuples, from the database.
         /// </summary>

Components/DLM/BExIS.Dlm.Tests/Helpers/DatasetHelper.cs

@@ -302,14 +302,14 @@ public Dataset GenerateTuplesWithRandomValuesForDataset(Dataset dataset, Structu
             }
         }
 
-        public Dataset UpdateOneTupleForDataset(Dataset dataset, StructuredDataStructure dataStructure, long id, int value, DatasetManager datasetManager)
+        public Dataset UpdateOneTupleForDataset(Dataset dataset, StructuredDataStructure dataStructure, long id, int value,string username, DatasetManager datasetManager)
         {
             dataset.Status.Should().Be(DatasetStatus.CheckedIn);
             dataset.Should().NotBeNull();
 
             try
             {
-                if (datasetManager.IsDatasetCheckedOutFor(dataset.Id, "David") || datasetManager.CheckOutDataset(dataset.Id, "David"))
+                if (datasetManager.IsDatasetCheckedOutFor(dataset.Id, username) || datasetManager.CheckOutDataset(dataset.Id, username))
                 {
                     dataset.Status.Should().Be(DatasetStatus.CheckedOut, "Dataset must be in Checkedout status.");