Documentation:Seeing everything that is persisted

There is something called a ChainedPersistenceHandlerBase that you can inherit from and intercept everything that goes to and from the database.

You can use override as you see fit:

1. namespace Eco.Persistence
2. {
3.   // Summary:
4.   //     Base class for persistence handler.
5.   //
6.   // Remarks:
7.   //     Use this class to implement your own IPersistenceHandler override any of
8.   //     the virtual methods to inject your own behaviour and copy the Install-procedure
9.   //     (from the source of this class) for a convenient way to install the new class
10.   //     in the EcoSpace.
11.   public class ChainedPersistenceHandlerBase : IPersistenceHandler
12.   {
13.     public ChainedPersistenceHandlerBase(IEcoTypeSystem typeSystem);
14.  
15.     public bool IsPersistent { get; }
16.     public virtual int MaxSavedVersion { get; }
17.     public IPersistenceHandler NextPersistenceHandler { get; set; }
18.     public bool SupportsSync { get; }
19.     protected IEcoTypeSystem TypeSystem { get; }
20.  
21.     public virtual event LocatorArrayEventHandler ObjectsUpdated;
22.  
23.     public virtual void Fetch(ICollection<Locator> locators, int[] members, FetchStrategy FetchStrategy);
24.     public virtual ICollection<Locator> FetchLinksWithObjects(ICollection<Locator> objects, IAssociationEnd assocEnd);
25.     public virtual ICollection<Locator> GetAllWithCondition(AbstractCondition condition, int maxAnswers, int offset);
26.     public virtual Datablock GetValueWithCondition(AbstractCondition condition, int maxAnswers, int offset);
27.     public virtual void RetrieveChanges(out DBChangeCollection ignoredChanges);
28.     public virtual DateTime TimeForVersion(int version);
29.     public virtual void UpdateDatabaseWithList(ICollection<Locator> locators);
30.     public virtual int VersionAtTime(DateTime time);
31.   }
32. }

Maybe you have a common base class for all classes in your model, and maybe this class implements an Interface ITrackUpdate, then it would be a good thing to catch all updates and set the datetime…

1. public class UpdateHandler : ChainedPersistenceHandlerBase
2. {
3.   private readonly IObjectRepresentationProvider orp;
4.   public UpdateHandler(IObjectRepresentationProvider orp, IEcoTypeSystem typeSystem)
5.     : base(typeSystem)
6.   {
7.     this.orp = orp;
8.   }
9.   public override void UpdateDatabaseWithList(ICollection<Locator> locators)
10.   {
11.     DateTime timestamp = DateTime.Now;
12.     foreach (Locator loc in locators)
13.     {
14.       IObject obj = orp.IObjectForLocator(loc);
15.       if (obj.AsObject is ITrackUpdate)
16.       {
17.         (obj.AsObject as ITrackUpdate).PreUpdate(timestamp);
18.       }
19.     }
20.     base.UpdateDatabaseWithList(locators);
21.   }
22. }

We need to install our ChainedPersistenceHandlerBase baseclass. We do this by mixing it in before the current persistencehandler , we do this in the ecospace – before we go active:

1. // Install the update handler which intercepts all updates and updated the "Modified" attribute
2. UpdateHandler uh = new UpdateHandler(FrontsidePolicy.ObjectRepresentationProvider, TypeSystem);
3. PersistenceServiceImpl ps = Persistence as PersistenceServiceImpl;
4. uh.NextPersistenceHandler = ps.PersistenceHandler;
5. ps.PersistenceHandler = uh;
6. FrontsidePolicy.PersistenceHandler = uh;