public Neo4JToOwlGeneratorService( IOptionsMonitor <OwlDataGeneratorConfigModel> owlDataGeneratorConfigModel, ISyncNameProvider syncNameProvider) : base(owlDataGeneratorConfigModel) { _syncNameProvider = syncNameProvider; }
protected override async Task <Dictionary <string, object>?> GetRelationshipProperties( ContentItem contentItem, int ordinal, ISyncNameProvider syncNameProvider) { // set the FlowMetaData as the relationship's properties var flowMetaData = new Dictionary <string, object> { { Ordinal, (long)ordinal } }; //todo: do we need more config/method for RelationshipPropertyName (and rename existing NodePropertyName?) //todo: handle nulls? JObject flowMetaDataContent = (JObject)contentItem.Content[FlowMetaData] !; FlowAlignment alignment = (FlowAlignment)(int)flowMetaDataContent[Alignment] !; flowMetaData.Add(await syncNameProvider !.PropertyName(Alignment), alignment.ToString()); flowMetaData.Add(await syncNameProvider !.PropertyName(Size), (long)flowMetaDataContent[Size] !); return(flowMetaData); }
public static ISyncNameProvider GetSyncNameProvider(this IServiceProvider serviceProvider, string contentType) { ISyncNameProvider syncNameProvider = serviceProvider.GetRequiredService <ISyncNameProvider>(); syncNameProvider.ContentType = contentType; return(syncNameProvider); }
public NodeDataModel(INode node, string prefLabel, ISyncNameProvider syncNameProvider) { //todo: we've already calculated the label earlier, so we don't need this logic (if we make it available here) //todo: don't hardcode preexisting nodes string type = node.Labels.FirstOrDefault(l => l == "esco__Occupation" || l == "esco__Skill") ?? node.Labels.First(l => l != "Resource"); const string escoPrefix = "esco__"; if (type.StartsWith(escoPrefix)) { type = type.Substring(escoPrefix.Length); } Id = $"Class{node.Id}"; Key = 1; Type = type; Label = GetPropertyValue(node, new[] { prefLabel, "Description", "FurtherInfo" }); Comment = GetPropertyValue(node, new[] { "Description" }); StaxProperties = node.Properties .Where(p => p.Key != prefLabel) .Select(p => $"{p.Key}:{p.Value}") .ToList(); NodeId = GetNodeId(node.Properties, type, syncNameProvider); }
public ValidateAndRepairGraph(IEnumerable <IContentItemGraphSyncer> itemSyncers, IContentDefinitionManager contentDefinitionManager, IContentManager contentManager, ISession session, IServiceProvider serviceProvider, ISyncNameProvider syncNameProvider, IGraphValidationHelper graphValidationHelper, IContentItemVersionFactory contentItemVersionFactory, IContentItemsService contentItemsService, ILogger <ValidateAndRepairGraph> logger) { _itemSyncers = itemSyncers.OrderByDescending(s => s.Priority); _contentDefinitionManager = contentDefinitionManager; _contentManager = contentManager; _session = session; _serviceProvider = serviceProvider; _syncNameProvider = syncNameProvider; _graphValidationHelper = graphValidationHelper; _contentItemVersionFactory = contentItemVersionFactory; _contentItemsService = contentItemsService; _logger = logger; _currentGraph = default; _graphClusterLowLevel = _serviceProvider.GetRequiredService <IGraphClusterLowLevel>(); }
public CypherToContentStep( IGraphCluster graphCluster, IServiceProvider serviceProvider, IContentItemIdGenerator idGenerator, ICypherToContentCSharpScriptGlobals cypherToContentCSharpScriptGlobals, ISyncNameProvider syncNameProvider, IPublishedContentItemVersion publishedContentItemVersion, ISuperpositionContentItemVersion superpositionContentItemVersion, IEscoContentItemVersion escoContentItemVersion, ISession session, IContentManager contentManager, IContentManagerSession contentManagerSession, ILogger <CypherToContentStep> logger) { _graphCluster = graphCluster; _serviceProvider = serviceProvider; _idGenerator = idGenerator; _cypherToContentCSharpScriptGlobals = cypherToContentCSharpScriptGlobals; _syncNameProvider = syncNameProvider; _publishedContentItemVersion = publishedContentItemVersion; _superpositionContentItemVersion = superpositionContentItemVersion; _escoContentItemVersion = escoContentItemVersion; _session = session; _contentManager = contentManager; _contentManagerSession = contentManagerSession; _logger = logger; }
private async Task <string> RelationshipTypeContentPicker( ContentPickerFieldSettings contentPickerFieldSettings, ISyncNameProvider syncNameProvider) { //todo: handle multiple types string pickedContentType = contentPickerFieldSettings.DisplayedContentTypes[0]; string?relationshipType = null; if (contentPickerFieldSettings.Hint != null) { Match match = _relationshipTypeRegex.Match(contentPickerFieldSettings.Hint); if (match.Success) { relationshipType = $"{match.Groups[1].Value}"; } } if (relationshipType == null) { relationshipType = await syncNameProvider !.RelationshipTypeDefault(pickedContentType); } return(relationshipType); }
public DescribeRelationshipsContext(string sourceNodeIdPropertyName, string sourceNodeId, IEnumerable <string> sourceNodeLabels, ContentItem contentItem, int maxDepthFromHere, ISyncNameProvider graphSyncHelper, IContentManager contentManager, IContentItemVersion contentItemVersion, IDescribeRelationshipsContext?parentContext, IServiceProvider serviceProvider) : base( contentItem, graphSyncHelper, contentManager, contentItemVersion, parentContext, serviceProvider.GetRequiredService <ILogger <GraphDeleteContext> >()) { AvailableRelationships = new List <ContentItemRelationship>(); ServiceProvider = serviceProvider; SourceNodeId = sourceNodeId; SourceNodeLabels = sourceNodeLabels; MaxDepthFromHere = maxDepthFromHere; SourceNodeIdPropertyName = sourceNodeIdPropertyName; CurrentDepth = (parentContext?.CurrentDepth + 1) ?? 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>(); }
//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; }
public FlowPartEmbeddedContentItemsGraphSyncer( IContentDefinitionManager contentDefinitionManager, ISyncNameProvider statelessSyncNameProvider, IServiceProvider serviceProvider, ILogger <FlowPartEmbeddedContentItemsGraphSyncer> logger) : base(contentDefinitionManager, statelessSyncNameProvider, serviceProvider, logger) { }
public async Task <(bool validated, string failureReason)> ValidateSyncComponent( JObject contentItemField, IValidateAndRepairContext context) { //todo: check for null ContentItem?taxonomyContentItem = await GetTaxonomyContentItem( contentItemField, context.ContentItemVersion, context.ContentManager); var taxonomyPartContent = taxonomyContentItem !.Content[nameof(TaxonomyPart)]; string termContentType = taxonomyPartContent[TermContentType]; string termRelationshipType = TermRelationshipType(termContentType); IOutgoingRelationship[] actualRelationships = context.NodeWithOutgoingRelationships.OutgoingRelationships .Where(r => r.Relationship.Type == termRelationshipType) .ToArray(); var contentItemIds = (JArray)contentItemField[TermContentItemIds] !; if (contentItemIds.Count != actualRelationships.Length) { return(false, $"expecting {contentItemIds.Count} relationships of type {termRelationshipType} in graph, but found {actualRelationships.Length}"); } ISyncNameProvider relatedSyncNameProvider = _serviceProvider.GetSyncNameProvider(termContentType); var flattenedTermsContentItems = GetFlattenedTermsContentItems(taxonomyPartContent); foreach (JToken item in contentItemIds) { string contentItemId = (string)item !; object?destinationId = GetNodeId( contentItemId, flattenedTermsContentItems, relatedSyncNameProvider, context.ContentItemVersion) !; (bool validated, string failureReason) = context.GraphValidationHelper.ValidateOutgoingRelationship( context.NodeWithOutgoingRelationships, termRelationshipType, relatedSyncNameProvider !.IdPropertyName(), destinationId); if (!validated) { return(false, failureReason); } // keep a count of how many relationships of a type we expect to be in the graph context.ExpectedRelationshipCounts.IncreaseCount(termRelationshipType); } // return context.GraphValidationHelper.StringArrayContentPropertyMatchesNodeProperty( // TagNames, // contentItemField, // TaxonomyTermsNodePropertyName, // context.NodeWithOutgoingRelationships.SourceNode); return(true, ""); }
public TaxonomyPartEmbeddedContentItemsGraphSyncer( IContentDefinitionManager contentDefinitionManager, //todo: put one in the context?? ISyncNameProvider statelessSyncNameProvider, IServiceProvider serviceProvider, ILogger <TaxonomyPartEmbeddedContentItemsGraphSyncer> logger) : base(contentDefinitionManager, statelessSyncNameProvider, serviceProvider, logger) { }
private object GetNodeId( ContentItem pickedContentItem, ISyncNameProvider syncNameProvider, IContentItemVersion contentItemVersion) { //todo: add GetNodeId support to TaxonomyFieldGraphSyncer return(syncNameProvider.GetNodeIdPropertyValue( pickedContentItem.Content[nameof(GraphSyncPart)], contentItemVersion)); }
private async Task AddSyncComponents(IGraphMergeContext context, JArray?contentItemIdsJArray = null) { ContentPickerFieldSettings contentPickerFieldSettings = context.ContentPartFieldDefinition !.GetSettings <ContentPickerFieldSettings>(); //todo: use pickedContentSyncNameProvider in RelationshipTypeContentPicker? string relationshipType = await RelationshipTypeContentPicker(contentPickerFieldSettings, context.SyncNameProvider); //todo: support multiple pickable content types string pickedContentType = contentPickerFieldSettings.DisplayedContentTypes[0]; ISyncNameProvider pickedContentSyncNameProvider = _serviceProvider.GetSyncNameProvider(pickedContentType); IEnumerable <string> destNodeLabels = await pickedContentSyncNameProvider.NodeLabels(); if (contentItemIdsJArray?.HasValues != true) { context.ReplaceRelationshipsCommand.RemoveAnyRelationshipsTo( relationshipType, destNodeLabels); return; } ContentItem[] foundDestinationContentItems = await GetContentItemsFromIds( contentItemIdsJArray, context.ContentManager, context.ContentItemVersion); if (context.ContentItemVersion.GraphReplicaSetName == GraphReplicaSetNames.Preview && foundDestinationContentItems.Count() != contentItemIdsJArray.Count) { throw new GraphSyncException( $"Missing picked content items. Looked for {string.Join(",", contentItemIdsJArray.Values<string?>())}. Found {string.Join(",", foundDestinationContentItems.Select(i => i.ContentItemId))}. Current merge node command: {context.MergeNodeCommand}."); } // if we're syncing to the published graph, some items may be draft only, // so it's valid to have less found content items than are picked //todo: we could also check when publishing and take into account how many we expect not to find as they are draft only IEnumerable <object> foundDestinationNodeIds = foundDestinationContentItems.Select(ci => GetNodeId(ci !, pickedContentSyncNameProvider, context.ContentItemVersion)); long ordinal = 0; foreach (var item in foundDestinationNodeIds) { context.ReplaceRelationshipsCommand.AddRelationshipsTo( relationshipType, ContentPickerRelationshipProperties.Concat(new[] { new KeyValuePair <string, object>("Ordinal", ordinal++) }), destNodeLabels, pickedContentSyncNameProvider.IdPropertyName(), item); } }
private object?GetNodeId( string termContentItemId, IDictionary <string, ContentItem> taxonomyTerms, ISyncNameProvider termSyncNameProvider, IContentItemVersion contentItemVersion) { ContentItem termContentItem = taxonomyTerms[termContentItemId]; return(termSyncNameProvider.GetNodeIdPropertyValue( (JObject)termContentItem.Content[nameof(GraphSyncPart)] !, contentItemVersion)); }
//todo: contentmanager //todo: taxonomies use reltype*maxdepth ? //todo: for child contexts, do we need anything more than parentcontext, contentitem & relationships? public async Task <IDescribeRelationshipsContext?> BuildRelationships( ContentItem contentItem, string sourceNodeIdPropertyName, string sourceNodeId, IEnumerable <string> sourceNodeLabels, ISyncNameProvider syncNameProvider, IContentManager contentManager, IContentItemVersion contentItemVersion, IDescribeRelationshipsContext?parentContext, IServiceProvider serviceProvider) { var graphSyncPartSettings = syncNameProvider.GetGraphSyncPartSettings(contentItem.ContentType); int maxDepthFromHere; if (parentContext == null) { maxDepthFromHere = Math.Min(graphSyncPartSettings.VisualiserNodeDepth ?? int.MaxValue, //todo: store in root in case changes mid flow? _graphSyncSettings.CurrentValue.MaxVisualiserNodeDepth); } else { if (_encounteredContentTypes.Any(x => x == contentItem.ContentType)) { return(null); } maxDepthFromHere = Math.Min(parentContext.MaxDepthFromHere - 1, graphSyncPartSettings.VisualiserNodeDepth ?? int.MaxValue); } if (maxDepthFromHere <= 0) { return(null); } var context = new DescribeRelationshipsContext( sourceNodeIdPropertyName, sourceNodeId, sourceNodeLabels, contentItem, maxDepthFromHere, syncNameProvider, contentManager, contentItemVersion, parentContext, serviceProvider); foreach (IContentItemGraphSyncer itemSyncer in _contentItemGraphSyncers) { //todo: allow syncers to chain or not? probably not if (itemSyncer.CanSync(context.ContentItem)) { await itemSyncer.AddRelationship(context); } } _encounteredContentTypes.Add(contentItem.ContentType); return(context); }
public DeleteTypeGraphSyncer( IGraphCluster graphCluster, IDeleteNodesByTypeCommand deleteNodesByTypeCommand, ISyncNameProvider syncNameProvider, ISession session, ILogger <DeleteTypeGraphSyncer> logger) { _graphCluster = graphCluster; _deleteNodesByTypeCommand = deleteNodesByTypeCommand; _syncNameProvider = syncNameProvider; _session = session; _logger = logger; }
public VisualiseGraphSyncer( IContentManager contentManager, ISyncNameProvider syncNameProvider, IDescribeContentItemHelper describeContentItemHelper, IGraphCluster neoGraphCluster, IServiceProvider serviceProvider) { _contentManager = contentManager; _syncNameProvider = syncNameProvider; _describeContentItemHelper = describeContentItemHelper; _neoGraphCluster = neoGraphCluster; _serviceProvider = serviceProvider; }
public NodeContentItemLookup( IContentItemVersionFactory contentItemVersionFactory, ISyncNameProvider syncNameProvider, ISuperpositionContentItemVersion superpositionContentItemVersion, IEscoContentItemVersion escoContentItemVersion, ISession session) { _contentItemVersionFactory = contentItemVersionFactory; _syncNameProvider = syncNameProvider; _superpositionContentItemVersion = superpositionContentItemVersion; _escoContentItemVersion = escoContentItemVersion; _session = session; }
public CloneGraphSync( IEnumerable <IContentItemGraphSyncer> itemSyncers, ISyncNameProvider syncNameProvider, IPreviewContentItemVersion previewContentItemVersion, //todo: ?? IServiceProvider serviceProvider, ILogger <CloneGraphSync> logger) { _itemSyncers = itemSyncers.OrderByDescending(s => s.Priority); _syncNameProvider = syncNameProvider; _previewContentItemVersion = previewContentItemVersion; _serviceProvider = serviceProvider; _logger = logger; }
protected GraphSyncContext( ContentItem contentItem, ISyncNameProvider syncNameProvider, IContentManager contentManager, IContentItemVersion contentItemVersion, IGraphSyncContext?parentContext, ILogger logger) : base(contentItem, syncNameProvider, contentManager, contentItemVersion, logger) { ParentContext = parentContext; parentContext?.AddChildContext(this); _childContexts = new List <IGraphSyncContext>(); }
protected GraphOperationContext( ContentItem contentItem, ISyncNameProvider syncNameProvider, IContentManager contentManager, IContentItemVersion contentItemVersion, ILogger logger) { _logger = logger; ContentItem = contentItem; SyncNameProvider = syncNameProvider; ContentManager = contentManager; ContentItemVersion = contentItemVersion; // will be set before any syncers receive a context ContentTypePartDefinition = default !;
protected EmbeddedContentItemsGraphSyncer( IContentDefinitionManager contentDefinitionManager, ISyncNameProvider statelessSyncNameProvider, IServiceProvider serviceProvider, ILogger logger) { _contentDefinitionManager = contentDefinitionManager; _statelessSyncNameProvider = statelessSyncNameProvider; _serviceProvider = serviceProvider; _logger = logger; _contentTypes = contentDefinitionManager .ListTypeDefinitions() .Where(x => x.Parts.Any(p => p.Name == nameof(GraphSyncPart))) .ToDictionary(x => x.Name); }
public EventGridPublishingHandler( IOptionsMonitor <EventGridConfiguration> eventGridConfiguration, IEventGridContentClient eventGridContentClient, ISyncNameProvider syncNameProvider, IPublishedContentItemVersion publishedContentItemVersion, IPreviewContentItemVersion previewContentItemVersion, INeutralEventContentItemVersion neutralEventContentItemVersion, ILogger <EventGridPublishingHandler> logger) { _eventGridConfiguration = eventGridConfiguration; _eventGridContentClient = eventGridContentClient; _syncNameProvider = syncNameProvider; _publishedContentItemVersion = publishedContentItemVersion; _previewContentItemVersion = previewContentItemVersion; _neutralEventContentItemVersion = neutralEventContentItemVersion; _logger = logger; }
public CloneContext( ContentItem contentItem, ICloneGraphSync cloneGraphSync, ISyncNameProvider syncNameProvider, IContentManager contentManager, IContentItemVersion contentItemVersion, IServiceProvider serviceProvider, ICloneContext?parentContext = null) : base( contentItem, syncNameProvider, contentManager, contentItemVersion, parentContext, serviceProvider.GetRequiredService <ILogger <CloneContext> >()) { CloneGraphSync = cloneGraphSync; }
public ValidateAndRepairContext( ContentItem contentItem, IContentManager contentManager, IContentItemVersion contentItemVersion, ISubgraph nodeWithRelationships, ISyncNameProvider syncNameProvider, IGraphValidationHelper graphValidationHelper, IValidateAndRepairGraph validateAndRepairGraph, ILogger logger) : base(contentItem, syncNameProvider, contentManager, contentItemVersion, logger) { ContentItemVersion = contentItemVersion; NodeWithRelationships = nodeWithRelationships; GraphValidationHelper = graphValidationHelper; ValidateAndRepairGraph = validateAndRepairGraph; ExpectedRelationshipCounts = new Dictionary <string, int>(); }
public ValidateAndRepairItemSyncContext( ContentItem contentItem, IContentManager contentManager, IContentItemVersion contentItemVersion, ISubgraph nodeWithRelationships, ISyncNameProvider syncNameProvider, IGraphValidationHelper graphValidationHelper, IValidateAndRepairGraph validateAndRepairGraph, ContentTypeDefinition contentTypeDefinition, object nodeId, IServiceProvider serviceProvider) : base(contentItem, contentManager, contentItemVersion, nodeWithRelationships, syncNameProvider, graphValidationHelper, validateAndRepairGraph, serviceProvider.GetRequiredService <ILogger <ValidateAndRepairItemSyncContext> >()) { ContentTypeDefinition = contentTypeDefinition; NodeId = nodeId; }
public DeleteGraphSyncer( IEnumerable <IContentItemGraphSyncer> itemSyncers, IGraphCluster graphCluster, IDeleteNodeCommand deleteNodeCommand, ISyncNameProvider syncNameProvider, IContentManager contentManager, IServiceProvider serviceProvider, ILogger <DeleteGraphSyncer> logger) { _itemSyncers = itemSyncers.OrderByDescending(s => s.Priority); _graphCluster = graphCluster; _deleteNodeCommand = deleteNodeCommand; _syncNameProvider = syncNameProvider; _contentManager = contentManager; _serviceProvider = serviceProvider; _logger = logger; _graphDeleteItemSyncContext = null; }
public GraphDeleteContext(ContentItem contentItem, IDeleteNodeCommand deleteNodeCommand, IDeleteGraphSyncer deleteGraphSyncer, SyncOperation syncOperation, ISyncNameProvider syncNameProvider, IContentManager contentManager, IContentItemVersion contentItemVersion, IEnumerable <KeyValuePair <string, object> >?deleteIncomingRelationshipsProperties, IGraphDeleteContext?parentGraphDeleteContext, IServiceProvider serviceProvider) : base( contentItem, syncNameProvider, contentManager, contentItemVersion, parentGraphDeleteContext, serviceProvider.GetRequiredService <ILogger <GraphDeleteContext> >()) { DeleteGraphSyncer = deleteGraphSyncer; DeleteNodeCommand = deleteNodeCommand; SyncOperation = syncOperation; DeleteIncomingRelationshipsProperties = deleteIncomingRelationshipsProperties; }