Example #1
0
 public virtual void Collect(ITransferContentData transferContentData)
 {
     if (transferContentData.IsComposerPage())
     {
         transferContentData.ForAllContent(Collect);
     }
 }
        public virtual bool Transform(ITransferContentData transferContentData)
        {
            var pageType = transferContentData.RawContentData.PageType();

            // Don't import certain system page types
            if (SystemPageTypes.Contains(pageType))
            {
                return false;
            }

            // Don't import Personalization Containers
            if (transferContentData.RawContentData.GetProperty(ComposerProperties.PersonalizationData) != null)
            {
                return false;
            }

            // Don't import empty ComposerContainers
            if (transferContentData.IsComposerContainer())
            {
                var parent = _contentMap.GetParentPage(transferContentData.RawContentData.PageGuid());
                if (parent == null)
                {
                    return false;
                }
            }

            return true;
        }
        public virtual void Collect(ITransferContentData transferContentData)
        {
            // We only care about master content as Containers only exist in one language.
            var rawContent = transferContentData.RawContentData;

            // All Personalization Containers has the PersonalizationData property
            var personalizationProperty = rawContent.GetProperty(ComposerProperties.PersonalizationData);

            if (personalizationProperty == null)
            {
                return;
            }

            // Collect GUIDs of all Personalization Containers - even if they are empty!
            _contentMap.AddPersonalisationContainer(rawContent.PageGuid());

            if (personalizationProperty.IsNull)
            {
                return;
            }

            // Collect Visitor Group mappings
            foreach (var item in _serializer.Deserialize(personalizationProperty.Value))
            {
                if (item.VisitorGroupList != null && item.VisitorGroupList.Any())
                {
                    _contentMap.AddVisitorGroupMap(item.ContainerID, item.VisitorGroupList.Select(vg => vg.VisitorGroupID).ToArray());
                }
                if (item.IsDefaultContent)
                {
                    _contentMap.AddVisitorGroupMap(item.ContainerID);
                }
            }
        }
 public virtual void Collect(ITransferContentData transferContentData)
 {
     if (transferContentData.IsComposerPage())
     {
         transferContentData.ForAllContent(Collect);
     }
 }
Example #5
0
        private void ImportContents <T>(XmlTextReader reader) where T : ITransferContentData
        {
            reader.Read(); // Read away
            while (reader.IsStartElement(typeof(T).Name) && (!_context.IsAborting || _context.ContinueOnError))
            {
                try
                {
                    XmlSerializer        xml     = new XmlSerializer(typeof(T));
                    ITransferContentData content = xml.Deserialize(reader) as ITransferContentData;
                    if (content.RawContentData == null)
                    {
                        continue;
                    }

                    OnContentScanned(new ContentScanEventArgs(content, null /*_context.Importer*/));
                }
                catch (Exception e)
                {
                    _context.Abort();
                    if (!_context.ContinueOnError)
                    {
                        throw;
                    }
                    //Importer.Log.Error(String.Format("Failed to Import Content. Reason is {0}", e.Message), e);
                }
            }

            reader.ReadEndElement(); // Contents
        }
Example #6
0
        public virtual bool Transform(ITransferContentData transferContentData)
        {
            var pageType = transferContentData.RawContentData.PageType();

            // Don't import certain system page types
            if (SystemPageTypes.Contains(pageType))
            {
                return(false);
            }

            // Don't import Personalization Containers
            if (transferContentData.RawContentData.GetProperty(ComposerProperties.PersonalizationData) != null)
            {
                return(false);
            }

            // Don't import empty ComposerContainers
            if (transferContentData.IsComposerContainer())
            {
                var parent = _contentMap.GetParentPage(transferContentData.RawContentData.PageGuid());
                if (parent == null)
                {
                    return(false);
                }
            }

            return(true);
        }
        public virtual void Collect(ITransferContentData transferContentData)
        {
            // We only care about master content as Containers only exist in one language.
            var rawContent = transferContentData.RawContentData;

            // All Personalization Containers has the PersonalizationData property
            var personalizationProperty = rawContent.GetProperty(ComposerProperties.PersonalizationData);

            if (personalizationProperty == null)
            {
                return;
            }

            // Collect GUIDs of all Personalization Containers - even if they are empty!
            _contentMap.AddPersonalisationContainer(rawContent.PageGuid());

            if (personalizationProperty.IsNull)
            {
                return;
            }

            // Collect Visitor Group mappings
            foreach (var item in _serializer.Deserialize(personalizationProperty.Value))
            {
                if (item.VisitorGroupList != null && item.VisitorGroupList.Any())
                {
                    _contentMap.AddVisitorGroupMap(item.ContainerID, item.VisitorGroupList.Select(vg => vg.VisitorGroupID).ToArray());
                }
                if (item.IsDefaultContent)
                {
                    _contentMap.AddVisitorGroupMap(item.ContainerID);
                }
            }
        }
Example #8
0
        protected virtual void ExportContentWithVerion(XmlTextWriter xml
                                                       , ContentReference contentToExport
                                                       , IContentTransferContext context
                                                       , ITransferContentData transferContent
                                                       , Action <XmlTextWriter, ContentReference, IContentTransferContext, ITransferContentData> callBackAction)
        {
            var rawContentInfo = _rawContentRetiever.CreateRawContentInfo(contentToExport, string.Empty);

            ContentVersion latestPublishedMasterVersion;
            var            versions = GetContentVersions(contentToExport
                                                         , rawContentInfo
                                                         , out latestPublishedMasterVersion).ToList();

            var rawContentRetieverEx = _rawContentRetiever as IRawContentRetrieverEx;

            if (versions == null || versions.Any() == false || latestPublishedMasterVersion == null)
            {
                callBackAction.Invoke(xml, contentToExport, context, transferContent);
                return;
            }

            foreach (var version in versions)
            {
                var versionTransferData = BuildRawTransferContent(context
                                                                  , null
                                                                  , rawContentRetieverEx
                                                                  , version);

                new XmlSerializer(typeof(TransferContentData)).Serialize(xml, versionTransferData, null);
            }
        }
 public virtual bool Transform(ITransferContentData transferContentData)
 {
     if (transferContentData.IsComposerContent())
     {
         transferContentData.ForAllContent(TransformContentAreas);
     }
     return true;
 }
 public virtual bool Transform(ITransferContentData transferContentData)
 {
     if (transferContentData.IsComposerFunction())
     {
         transferContentData.ForAllContent(TransformDynamicFunction);
     }
     return(true);
 }
 public virtual bool Transform(ITransferContentData transferContentData)
 {
     if (transferContentData.IsComposerFunction())
     {
         transferContentData.ForAllContent(TransformDynamicFunction);
     }
     return true;
 }
Example #12
0
 public virtual bool Transform(ITransferContentData transferContentData)
 {
     if (transferContentData.IsComposerContent())
     {
         transferContentData.ForAllContent(TransformContentAreas);
     }
     return(true);
 }
        public static void ForAllContent(this ITransferContentData transferContentData, Action <RawContent> action)
        {
            action(transferContentData.RawContentData);

            foreach (var languageContent in transferContentData.RawLanguageData)
            {
                action(languageContent);
            }
        }
Example #14
0
        public virtual bool Transform(ITransferContentData transferContentData)
        {
            var rawContent = transferContentData.RawContentData;

            var functionProperty = rawContent.GetProperty(ComposerProperties.ContentFunction);

            if (functionProperty == null)
            {
                return(true);
            }

            // Deserialize the Extension Function Struct
            var functionInfo = _composerSerializer.Deserialize <ComposerContentFunctionInformation>(functionProperty.Value);

            var isGlobalBlock = functionInfo != null && functionInfo.Type == ComposerContentFunctionCategory.Global;

            var guid   = transferContentData.RawContentData.PageGuid();
            var parent = _contentMap.GetParentPage(guid);

            // If a (non-global) block doesn't have a parent, it's an orphaned block and we won't import it
            if (parent == null && !_includeUnusedBlocks && !isGlobalBlock)
            {
                return(false);
            }

            // Move all Global and Unused blocks to the GlobalBlockFolder
            if (isGlobalBlock || parent == null)
            {
                rawContent.SetPropertyValue(MetaDataProperties.PageParentLink, _exportLinkResolver.GetExportableLink(ContentReference.GlobalBlockFolder));
            }

            // Update the PageName to a more friendly name
            var property = rawContent.GetProperty(MetaDataProperties.PageName);

            if (property != null)
            {
                var friendlyName = CreateFriendlyName(rawContent, functionInfo);
                if (!string.IsNullOrEmpty(friendlyName))
                {
                    property.Value = friendlyName;
                }
            }

            // Don't change language of Global Blocks
            if (!isGlobalBlock && parent != null)
            {
                rawContent.Language(parent.Language);
                rawContent.MasterLanguage(parent.Language);
            }

            return(true);
        }
Example #15
0
 protected override void ExportContent(XmlTextWriter xml
                                       , ContentReference contentToExport
                                       , IContentTransferContext context
                                       , ITransferContentData transferContent)
 {
     if (_transferExportOptionsEx.ExportVersion)
     {
         ExportContentWithVerion(xml, contentToExport, context, transferContent, base.ExportContent);
     }
     else
     {
         base.ExportContent(xml, contentToExport, context, transferContent);
     }
 }
Example #16
0
        protected virtual bool RunContentTransforms(DataImporter dataImporter, ITransferContentData content)
        {
            var transformers = ServiceLocator.Current.GetAllInstances <IImportTransform>();

            Logger.Trace("Running transforms on content");
            foreach (var transformer in transformers)
            {
                if (!transformer.Transform(content))
                {
                    return(false);
                }
            }

            return(true);
        }
        public virtual bool Transform(ITransferContentData transferContentData)
        {
            if (!transferContentData.IsComposerContainer())
            {
                return(true);
            }

            var parent = _contentMap.GetParentPage(transferContentData.RawContentData.PageGuid());

            if (parent == null && !_includeUnusedBlocks)
            {
                return(false);
            }

            transferContentData.ForAllContent(c => TransformContainer(c, parent));

            return(true);
        }
        public virtual bool Transform(ITransferContentData transferContentData)
        {
            if (!transferContentData.IsComposerContainer())
            {
                return true;
            }

            var parent = _contentMap.GetParentPage(transferContentData.RawContentData.PageGuid());

            if (parent == null && !_includeUnusedBlocks)
            {
                return false;
            }

            transferContentData.ForAllContent(c => TransformContainer(c, parent));

            return true;
        }
 /// <summary>
 /// Checks if the current content is a composer block.
 /// </summary>
 public static bool IsComposerFunction(this ITransferContentData transferContentData)
 {
     return(transferContentData.RawContentData.IsComposerFunction());
 }
Example #20
0
 public virtual bool Transform(ITransferContentData transferContentData)
 {
     transferContentData.ForAllContent(FilterProperties);
     return(true);
 }
        public virtual bool Transform(ITransferContentData transferContentData)
        {
            var rawContent = transferContentData.RawContentData;

            var functionProperty = rawContent.GetProperty(ComposerProperties.ContentFunction);
            if (functionProperty == null)
            {
                return true;
            }

            // Deserialize the Extension Function Struct
            var functionInfo = _composerSerializer.Deserialize<ComposerContentFunctionInformation>(functionProperty.Value);

            var isGlobalBlock = functionInfo != null && functionInfo.Type == ComposerContentFunctionCategory.Global;

            var guid = transferContentData.RawContentData.PageGuid();
            var parent = _contentMap.GetParentPage(guid);

            // If a (non-global) block doesn't have a parent, it's an orphaned block and we won't import it
            if (parent == null && !_includeUnusedBlocks && !isGlobalBlock)
            {
                return false;
            }

            // Move all Global and Unused blocks to the GlobalBlockFolder
            if (isGlobalBlock || parent == null)
            {
                rawContent.SetPropertyValue(MetaDataProperties.PageParentLink, _exportLinkResolver.GetExportableLink(ContentReference.GlobalBlockFolder));
            }

            // Update the PageName to a more friendly name
            var property = rawContent.GetProperty(MetaDataProperties.PageName);
            if (property != null)
            {
                var friendlyName = CreateFriendlyName(rawContent, functionInfo);
                if (!string.IsNullOrEmpty(friendlyName))
                {
                    property.Value = friendlyName;
                }
            }

            // Don't change language of Global Blocks
            if (!isGlobalBlock && parent != null)
            {
                rawContent.Language(parent.Language);
                rawContent.MasterLanguage(parent.Language);
            }

            return true;
        }
 public virtual bool Transform(ITransferContentData transferContentData)
 {
     transferContentData.ForAllContent(TransformTypeNames);
     return true;
 }
        protected virtual bool RunContentTransforms(DataImporter dataImporter, ITransferContentData content)
        {
            var transformers = ServiceLocator.Current.GetAllInstances<IImportTransform>();

            Logger.Info("Running transforms on content");
            foreach (var transformer in transformers)
            {
                if (!transformer.Transform(content))
                {
                    return false;
                }
            }

            return true;
        }
 public virtual bool Transform(ITransferContentData transferContentData)
 {
     transferContentData.ForAllContent(TransformTypeNames);
     return(true);
 }
 public ContentScanEventArgs(ITransferContentData transferContentData, IContentTransferContext transferContext)
 {
     _transferContentData = transferContentData;
     _transferContext     = transferContext;
 }
 public ContentScanEventArgs(ITransferContentData transferContentData, IContentTransferContext transferContext)
 {
     _transferContentData = transferContentData;
     _transferContext = transferContext;
 }
 public virtual bool Transform(ITransferContentData transferContentData)
 {
     transferContentData.ForAllContent(FilterProperties);
     return true;
 }
 /// <summary>
 /// Checks if the current content is a Composer Container page
 /// </summary>
 public static bool IsComposerContainer(this ITransferContentData transferContentData)
 {
     return(transferContentData.RawContentData.IsComposerContainer());
 }