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;
}
