Include ACL during Import, Mirroring and Copy

The standard behavior for Copy, Import and Mirroring is that the AccessControlList (ACL) is inherited from destination page. However the original ACL that the page had at source is included in the export package. In this post I will present a module that will set the ACL to the original value it had instead of inheriting from  destination.

The implementation does not distinguish between the type of importing (Copy, Import or Mirroring). It is possible to distinguish on type if you for example only want ACLs to be preserved during mirroring but not for copy and import.

In this implementation I call importedAcl.Save(SecuritySaveType.Replace); which will replace the inherited ACL. Another option is to call importedAcl.Save(SecuritySaveType.Modify); which will be a merge of the inherited and the imported ACL.

In CMS6 and prior versions the type of entity in the ACE (User or Role) was not included in the package. In that case on import side a check is made if there exist a Role with given name and if so the type is set to Role else it is considered a User. This has been changed in CMS6R2 so the type of entity (now User, Role or VisitorGroup) is included in the package.

The code holds the standard “works on my machine”, that is it has not gone through any solid testing matrix. You are free to use it at own risk without support, however feedback is appreciated.

   [InitializableModule]
    public class AclImporterModule : IInitializableModule
    {
        //The module will be a singleton so it needs to be thread safe
        private object _lockObject = new object();
        private Dictionary<DataImporter, AclImporter> _aclImporters = 
            new Dictionary<DataImporter, AclImporter>();

        public void Initialize(InitializationEngine context)
        {
            DataImporter.Importing += new EventHandler(DataImporter_Importing);
            DataImporter.Imported += new EventHandler(DataImporter_Imported);
            DataImporter.PageImporting += 
                new PageImportingEventHandler(DataImporter_PageImporting);
            DataImporter.PageImported += 
                new PageImportedEventHandler(DataImporter_PageImported);
        }

        void DataImporter_Importing(object sender, EventArgs e)
        {
            lock (_lockObject)
            {
                _aclImporters.Add(sender as DataImporter, 
                    new AclImporter(sender as ITransferContext, 
                        new PermanentLinkMapper()));
            }
        }

        void DataImporter_Imported(object sender, EventArgs e)
        {
            lock (_lockObject)
            {
                _aclImporters.Remove(sender as DataImporter);
            }
        }

        void DataImporter_PageImporting(DataImporter dataImporter, 
            PageImportingEventArgs e)
        {
            AclImporter aclImporter;
            lock (_lockObject)
            {
                aclImporter = _aclImporters[dataImporter];
            }
            aclImporter.ImportingPage(e.RawPage);
            
        }

        void DataImporter_PageImported(DataImporter dataImporter, 
            PageImportedEventArgs e)
        {
            AclImporter aclImporter;
            lock (_lockObject)
            {
                aclImporter = _aclImporters[dataImporter];
            }
            aclImporter.ImportedPage(e.PageData);
        }

        public void Preload(string[] parameters)
        {
        }

        public void Uninitialize(InitializationEngine context)
        {
            DataImporter.Importing -= new EventHandler(DataImporter_Importing);
            DataImporter.Imported -= new EventHandler(DataImporter_Imported);
            DataImporter.PageImporting -= 
                new PageImportingEventHandler(DataImporter_PageImporting);
            DataImporter.PageImported -= 
                new PageImportedEventHandler(DataImporter_PageImported);
        }
    }

    public class AclImporter
    {
        private Dictionary<Guid, RawACE[]> _importedAce = new Dictionary<Guid, RawACE[]>();
        private ITransferContext _context;
        private IPermanentLinkMapper _mapper;

        public AclImporter(ITransferContext context, IPermanentLinkMapper mapper)
        {
            _context = context;
            _mapper = mapper;
        }

        internal void ImportingPage(EPiServer.Core.RawPage rawPage)
        {
            _importedAce[GetPageGuid(rawPage)] = rawPage.ACL;
        }

        internal void ImportedPage(EPiServer.Core.PageData pageData)
        {
            //Only set ACL for "local" pages
            if (!pageData.PageLink.IsRemote())
            {
                //Note: We can not use pageData.PageGuid here since 
                //PageData instance is not complete
                PermanentPageLinkMap pageMap = 
                    _mapper.Find(pageData.PageLink) as PermanentPageLinkMap;
                Guid oldPageGuid = 
                    _context.LinkGuidMap.First(pair => pair.Value == pageMap.Guid).Key;
                RawACE[] aces = _importedAce[oldPageGuid];
                PageAccessControlList importedAcl = 
                    new PageAccessControlList(aces){PageLink = pageData.PageLink};
                importedAcl.Save(SecuritySaveType.Replace);
            }
            
        }

        private Guid GetPageGuid(EPiServer.Core.RawPage rawPage)
        {
            return new Guid(rawPage.Property.Where
                (prop => prop.Name == "PageGUID").Single().Value);
        }
    }