Beispiel #1
0
        //todo: commands only in context and create context using ActivatorUtilities.CreateInstance

        public MergeGraphSyncer(
            IEnumerable <IContentItemGraphSyncer> itemSyncers,
            IGraphSyncPartGraphSyncer graphSyncPartGraphSyncer,
            ISyncNameProvider syncNameProvider,
            IMergeNodeCommand mergeNodeCommand,
            IReplaceRelationshipsCommand replaceRelationshipsCommand,
            IContentItemVersionFactory contentItemVersionFactory,
            IPublishedContentItemVersion publishedContentItemVersion,
            IPreviewContentItemVersion previewContentItemVersion,
            IServiceProvider serviceProvider,
            IGraphCluster graphCluster,
            IContentItemsService contentItemsService,
            ILogger <MergeGraphSyncer> logger)
        {
            _itemSyncers = itemSyncers.OrderByDescending(s => s.Priority);
            _graphSyncPartGraphSyncer    = graphSyncPartGraphSyncer;
            _syncNameProvider            = syncNameProvider;
            MergeNodeCommand             = mergeNodeCommand;
            _replaceRelationshipsCommand = replaceRelationshipsCommand;
            _contentItemVersionFactory   = contentItemVersionFactory;
            _publishedContentItemVersion = publishedContentItemVersion;
            _previewContentItemVersion   = previewContentItemVersion;
            _serviceProvider             = serviceProvider;
            _graphCluster        = graphCluster;
            _contentItemsService = contentItemsService;
            _logger = logger;

            _graphMergeContext = null;
            _incomingPreviewContentPickerRelationships = null;
        }
Beispiel #2
0
        public GraphMergeContext(
            IMergeGraphSyncer mergeGraphSyncer,
            ISyncNameProvider syncNameProvider,
            IGraphReplicaSet graphReplicaSet,
            IMergeNodeCommand mergeNodeCommand,
            IReplaceRelationshipsCommand replaceRelationshipsCommand,
            ContentItem contentItem,
            IContentManager contentManager,
            IContentItemVersionFactory contentItemVersionFactory,
            IGraphMergeContext?parentGraphMergeContext,
            IServiceProvider serviceProvider)
            : base(
                contentItem,
                syncNameProvider,
                contentManager,
                contentItemVersionFactory.Get(graphReplicaSet.Name),
                parentGraphMergeContext,
                serviceProvider.GetRequiredService <ILogger <GraphMergeContext> >())
        {
            MergeGraphSyncer            = mergeGraphSyncer;
            GraphReplicaSet             = graphReplicaSet;
            MergeNodeCommand            = mergeNodeCommand;
            ReplaceRelationshipsCommand = replaceRelationshipsCommand;

            ExtraCommands = new List <ICommand>();
        }
 public static T AddProperty <T>(
     this IMergeNodeCommand mergeNodeCommand,
     string propertyName,
     JObject content)
 {
     return(mergeNodeCommand.AddProperty <T>(propertyName, content, propertyName));
 }
Beispiel #4
0
        private async Task <List <CommandRelationship> > GetRequiredRelationshipsAndOptionallySync(
            JArray?contentItems,
            IGraphMergeContext context,
            IAllowSync?allowSync = null)
        {
            ContentItem[] embeddedContentItems = ConvertToContentItems(contentItems);

            List <CommandRelationship> requiredRelationships = new List <CommandRelationship>();

            int relationshipOrdinal = 0;

            foreach (ContentItem contentItem in embeddedContentItems)
            {
                IMergeGraphSyncer?mergeGraphSyncer;

                if (allowSync == null)
                {
                    // we're actually syncing, not checking if it's allowed
                    mergeGraphSyncer = await context.MergeGraphSyncer.SyncEmbedded(contentItem);
                }
                else
                {
                    mergeGraphSyncer = GetNewMergeGraphSyncer();

                    IAllowSync embeddedAllowSync = await mergeGraphSyncer.SyncAllowed(context.GraphReplicaSet, contentItem, context.ContentManager, context);

                    allowSync.AddRelated(embeddedAllowSync);
                    if (embeddedAllowSync.Result != AllowSyncResult.Allowed)
                    {
                        continue;
                    }
                }

                //todo: check embedded items with no graphsyncpart attached
                if (mergeGraphSyncer == null)
                {
                    continue;
                }

                IMergeNodeCommand containedContentMergeNodeCommand = mergeGraphSyncer.MergeNodeCommand;
                containedContentMergeNodeCommand.CheckIsValid();

                string relationshipType = await RelationshipType(contentItem.ContentType);

                var properties = await GetRelationshipProperties(contentItem, relationshipOrdinal, context.SyncNameProvider);

                ++relationshipOrdinal;

                requiredRelationships.Add(new CommandRelationship(
                                              relationshipType,
                                              await TwoWayIncomingRelationshipType(contentItem.ContentType),
                                              properties,
                                              containedContentMergeNodeCommand.NodeLabels,
                                              containedContentMergeNodeCommand.IdPropertyName !,
                                              Enumerable.Repeat(containedContentMergeNodeCommand.Properties[containedContentMergeNodeCommand.IdPropertyName !], 1)));
        public static T AddProperty <T>(
            this IMergeNodeCommand mergeNodeCommand,
            string nodePropertyName,
            JObject content,
            string contentPropertyName)
        {
            T value;

            JValue?jvalue = (JValue?)content[contentPropertyName];

            if (jvalue == null)
            {
                return(default);