/// <summary> /// Triggered when the set of linked nodes of 'node' changes. This includes unlinking as well as linking. /// </summary> private void NodeLinked(ConversationNode node) { Action <NodeTypeData> categoryAction = category => { }; //Can't link categories to anything Action <IntegerData> integerAction = data => { }; //Can't link integer definitions to anything Action <DecimalData> decimalAction = data => { }; //Can't link decimal definitions to anything Action <LocalizedStringData> localizedStringAction = data => { }; //Can't link localized string definitions to anything Action <DynamicEnumerationData> dynamicEnumAction = data => { }; //Can't link dynamic enum definitions to anything Action <LocalDynamicEnumerationData> localDynamicEnumAction = data => { }; //Can't link local dynamic enum definitions to anything Action <EnumerationData> enumAction = data => { m_datasource.UpdateEnumeration(data); //m_conversationDatasource.UpdateEnumeration(data); }; Action <EnumerationData> enumValueAction = data => { }; //It's only possible to link to an enum definition and that's already handled by enumAction Action <NodeData> nodeAction = data => { //Doesn't affect the domain domain //m_conversationDatasource.NodeDefinitionModified(data); }; Action <ConnectorDefinitionData> connectorAction = data => { m_datasource.ModifyConnector(data); //update conversation datasource when connector definition is linked to a parameter }; Action <ConnectionDefinitionData> connectionAction = data => { }; //Can't line connection definitions to anything DomainDomain.ForEachNode(node.Only(), categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); ConversationDomainModified.Execute(); //No need to be picky about false positives }
/// <summary> /// /// </summary> /// <param name="nodes"></param> /// <param name="groups"></param> /// <param name="rawData">Represents the current contents of the file. Reference is not held. A copy is made.</param> /// <param name="file"></param> /// <param name="errors"></param> /// <param name="datasource"></param> /// <param name="serializer"></param> /// <param name="nodeFactory"></param> /// <param name="domainUsage"></param> /// <param name="getDocumentSource"></param> /// <param name="autoCompletePatterns"></param> public DomainFile(IEnumerable <GraphAndUI <NodeUIData> > nodes, IEnumerable <NodeGroup> groups, MemoryStream rawData, Id <FileInProject> file, DocumentPath path, ReadOnlyCollection <LoadError> errors, DomainDomain datasource, ISerializer <TData> serializer, INodeFactory nodeFactory, Func <IDomainUsage <ConversationNode, TransitionNoduleUIInfo> > domainUsage, Func <IDynamicEnumParameter, object, DynamicEnumParameter.Source> getDocumentSource, IEnumerable <IAutoCompletePattern> autoCompletePatterns, UpToDateFile.BackEnd backEnd) : base(nodes, groups, errors, nodeFactory, null, getDocumentSource, NoAudio.Instance) { Id = file; m_file = new SaveableFileUndoable(rawData, path.FileInfo, SaveTo, backEnd); m_domainUsage = domainUsage; foreach (var node in m_nodes) { var n = node; node.Modified += () => NodeModified(n); node.Data.Linked += () => NodeLinked(n); } m_nodes.Inserting += (n) => { AddToData(n.Data.Only(), m_datasource); ConversationDomainModified.Execute(); //No need to be picky about false positives n.Modified += () => NodeModified(n); n.Data.Linked += () => NodeLinked(n); }; m_nodes.Removing += RemoveFromData; m_nodes.Clearing += ClearData; //Currently nothing clears the list m_datasource = datasource; //m_conversationDatasource = conversationDataSource; m_serializer = serializer; m_autoCompletePatterns = new List <IAutoCompletePattern>(autoCompletePatterns); }
public static DomainFile CreateEmpty(DirectoryInfo directory, DomainDomain datasource, ISerializer <TData> serializer, Func <FileInfo, bool> pathOk, INodeFactory nodeFactory, Func <IDomainUsage <ConversationNode, TransitionNoduleUIInfo> > domainUsage, Func <IDynamicEnumParameter, object, DynamicEnumParameter.Source> getDocumentSource, UpToDateFile.BackEnd backEnd, DirectoryInfo origin) { //Create a stream under an available filename FileInfo path = null; for (int i = 0; path == null; i++) { path = new FileInfo(directory.FullName + Path.DirectorySeparatorChar + "New Domain " + i + ".dom"); if (!pathOk(path)) { path = null; } } using (MemoryStream m = new MemoryStream()) { using (var stream = Util.LoadFileStream(path, FileMode.CreateNew, FileAccess.Write)) { serializer.Write(SerializationUtils.MakeDomainData(Enumerable.Empty <ConversationNode>(), new ConversationEditorData()), m); m.CopyTo(stream); } var result = new DomainFile(new List <GraphAndUI <NodeUIData> >(), new List <NodeGroup>(), m, Id <FileInProject> .New(), DocumentPath.FromPath(path, origin), new ReadOnlyCollection <LoadError>(new LoadError[0]), datasource, serializer, nodeFactory, domainUsage, getDocumentSource, new List <IAutoCompletePattern>(), backEnd); result.m_file.Save(); //Make sure the file starts life as a valid xml document return(result); } }
/// <summary> /// Remove the node's content from the domain and conversation datasources. /// </summary> protected override void RemoveFromData(ConversationNode node) { Action <NodeTypeData> categoryAction = category => { m_datasource.RemoveCategory(category.Guid); //m_conversationDatasource.RemoveCategory(category.Guid); }; Action <IntegerData> integerAction = data => { m_datasource.RemoveType(BaseType.Integer, data.TypeId); //m_conversationDatasource.RemoveType(data.TypeID); }; Action <DecimalData> decimalAction = data => { m_datasource.RemoveType(BaseType.Decimal, data.TypeId); //m_conversationDatasource.RemoveType(data.TypeID); }; Action <LocalizedStringData> localizedStringAction = data => { m_datasource.RemoveType(BaseType.LocalizedString, data.TypeId); }; Action <DynamicEnumerationData> dynamicEnumAction = data => { m_datasource.RemoveType(BaseType.DynamicEnumeration, data.TypeId); //m_conversationDatasource.RemoveType(data.TypeID); }; Action <LocalDynamicEnumerationData> localDynamicEnumAction = data => { m_datasource.RemoveType(BaseType.LocalDynamicEnumeration, data.TypeId); //m_conversationDatasource.RemoveType(data.TypeID); }; Action <EnumerationData> enumAction = data => { m_datasource.RemoveType(BaseType.Enumeration, data.TypeId); //m_conversationDatasource.RemoveType(data.TypeID); }; Action <EnumerationData> enumValueAction = data => { m_datasource.UpdateEnumeration(data); //m_conversationDatasource.UpdateEnumeration(data); }; Action <NodeData> nodeAction = data => { //Doesn't affect domain domain //m_conversationDatasource.RemoveNodeType(data.Guid); }; Action <ConnectorDefinitionData> connectorAction = data => { m_datasource.RemoveConnector(data); //m_conversationDatasource.RemoveConnector(data.Id); }; Action <ConnectionDefinitionData> connectionAction = data => { //Doesn't affect domain domain }; DomainDomain.ForEachNode(node.Only(), categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); ConversationDomainModified.Execute(); //No need to be picky about false positives }
internal static Node Make(IEnumParameter parameter, DomainDomain source) { var options = source.GetEnumOptions(parameter.Value).Select(o => o.Name); return(new Count { Min = 1, Max = 1, Subjects = options.Select(o => new String { Value = o, Next = new Node[0] }).ToArray() }); }
private static void AddToData(IEnumerable <IConversationNodeData> nodes, DomainDomain datasource) { Action <NodeTypeData> categoryAction = category => { datasource.AddCategory(category.Name, category.Guid); //conversationDatasource.AddCategory(category); }; Action <IntegerData> integerAction = data => { datasource.AddIntegerType(data); //conversationDatasource.AddIntegerType(data); }; Action <DecimalData> decimalAction = data => { datasource.AddDecimalType(data); //conversationDatasource.AddDecimalType(data); }; Action <LocalizedStringData> localizedStringAction = data => { datasource.AddLocalizedStringType(data); }; Action <DynamicEnumerationData> dynamicEnumAction = data => { datasource.AddDynamicEnumType(data); //conversationDatasource.AddDynamicEnumType(data); }; Action <LocalDynamicEnumerationData> localDynamicEnumAction = data => { datasource.AddLocalDynamicEnumType(data); //conversationDatasource.AddLocalDynamicEnumType(data); }; Action <EnumerationData> enumAction = data => { datasource.AddEnumType(data); datasource.UpdateEnumeration(data); //conversationDatasource.AddEnumType(data); }; Action <EnumerationData> enumValueAction = data => { }; //No action required here. We'll let the enumeration definition node handle it Action <NodeData> nodeAction = data => { //conversationDatasource.AddNodeType(data); }; //No action required as it doesn't affect the domain domain Action <ConnectorDefinitionData> connectorAction = data => { datasource.AddConnector(data); //conversationDatasource.AddConnector(data); }; Action <ConnectionDefinitionData> connectionAction = data => { //No action required as it doesn't affect the domain domain }; DomainDomain.ForEachNode(nodes, categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); }
public static IEnumerable <Tuple <IEnumerable <ConversationNode>, IEnumerable <NodeGroup <ConversationNode> >, FileStream> > Load(List <FileStream> domainStreams, DomainDomain source, NodeFactory nodeFactory) { IEnumerable <ConversationNode> allNodes = Enumerable.Empty <ConversationNode>(); foreach (FileStream stream in domainStreams) { //Read out all the data. Some may be corrupted. ConversationDeserializerGUI serializer = new ConversationDeserializerGUI(source, nodeFactory); var data = serializer.Read(stream); var nodes = data.Item1.Evaluate(); var groups = data.Item2.Evaluate(); yield return(Tuple.Create(nodes, groups, stream)); } }
private static Either <Node, IError> Process(IConversationNodeData node, DomainDomain source, int depth) { if (node == null) { return(null); } depth++; if (depth > 100) { return(new OverRecursionError()); } var c = Children(node).Select(n => Process(n, source, depth)); var cc = Either.Split(c); var ne = Next(node).Select(n => Process(n, source, depth)); var nene = Either.Split(ne); if (cc.Item2.Any()) { return(new Either <Node, IError>(cc.Item2.First())); } else if (nene.Item2.Any()) { return(new Either <Node, IError>(nene.Item2.First())); } Node[] children = cc.Item1.ToArray(); Node[] nexts = nene.Item1.ToArray(); //Node child = (children.Length == 0) ? null : children.Length == 1 ? children[0] : new OneOf() { Next = null, Options = children }; //Node next = (nexts.Length == 0) ? null : nexts.Length == 1 ? nexts[0] : new OneOf() { Next = null, Options = nexts }; if (node.NodeTypeId == DomainIDs.AutoComplete.ExactlyOne) { return(new Count() { Min = 1, Max = 1, Subjects = children, Next = nexts }); } else if (node.NodeTypeId == DomainIDs.AutoComplete.OneOrMore) { return(new Count() { Min = 1, Max = int.MaxValue, Subjects = children, Next = nexts }); } else if (node.NodeTypeId == DomainIDs.AutoComplete.ZeroOrMore) { return(new Count() { Min = 0, Max = int.MaxValue, Subjects = children, Next = nexts }); } else if (node.NodeTypeId == DomainIDs.AutoComplete.ZeroOrOne) { return(new Count() { Min = 0, Max = 1, Subjects = children, Next = nexts }); } else if (node.NodeTypeId == DomainIDs.AutoComplete.String) { return(new String() { Next = nexts, Value = node.Parameters.Single(p => p.Id == DomainIDs.AutoComplete.StringParameter).ValueAsString() }); } else if (node.NodeTypeId == DomainIDs.AutoComplete.Character) { var result = Character.Make(node.Parameters.Single(p => p.Id == DomainIDs.AutoComplete.CharacterParameter).ValueAsString()); result.Next = nexts; return(result); } else if (node.NodeTypeId == DomainIDs.AutoComplete.EnumerationValue) { var result = EnumerationValue.Make(node.Parameters.Single() as IEnumParameter, source); result.Next = nexts; return(result); } else if (node.NodeTypeId == DomainIDs.AutoComplete.DynamicEnumerationValue) { return(new DynamicEnumerationValue(node.Parameters.Single() as IEnumParameter) { Next = nexts }); } else if (node.NodeTypeId == DomainIDs.AutoComplete.LocalDynamicEnumerationValue) { return(new DynamicEnumerationValue(node.Parameters.Single() as IEnumParameter) { Next = nexts }); } else { return(null);//TODO: Not sure what effect this would have } }
internal static IEnumerable <IAutoCompletePattern> Generate(XmlGraphData <NodeUIData, ConversationEditorData> nodeData, DomainDomain source) { List <IAutoCompletePattern> result = new List <IAutoCompletePattern>(); List <IError> errors = new List <IError>(); var startNodes = nodeData.Nodes.Select(n => n.GraphData).Where(n => !HasParent(n) && !HasPrevious(n)); foreach (var startNode in startNodes) { var processed = Process(startNode, source, 0); processed.Do(a => result.Add(a), b => errors.Add(b)); } //TODO: How to expose errors to the user? return(result); }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="data"></param> /// <param name="conversationNodeFactory"></param> /// <param name="domainNodeFactory"></param> /// <param name="initialContent">Represents the current contents of the file. Reference is not held. A copy is made.</param> /// <param name="projectFile"></param> /// <param name="serializer"></param> /// <param name="conversationSerializer"></param> /// <param name="conversationSerializerDeserializerFactory"></param> /// <param name="domainSerializer"></param> /// <param name="pluginsConfig"></param> /// <param name="audioCustomization"></param> public Project(ILocalizationContext context, TData data, INodeFactory conversationNodeFactory, INodeFactory domainNodeFactory, MemoryStream initialData, FileInfo projectFile, ISerializer <TData> serializer, ISerializer <TConversationData> conversationSerializer, ConversationSerializerDeserializerFactory conversationSerializerDeserializerFactory, ISerializer <TDomainData> domainSerializer, PluginsConfig pluginsConfig, Func <IAudioProviderCustomization> audioCustomization, UpToDateFile.BackEnd backend) { AssertUniqueFileIds(data); AssertUniqueLocalizationSetNames(data); AssertUniqueFilePaths(data); m_upToDateFileBackend = backend; Action <Stream> saveTo = stream => { Write(GetFilePath, Conversations.Select(x => (x.Id)), LocalizationFiles.Select(x => (x.Id)), DomainFiles.Select(x => (x.Id)), AudioFiles.Select(x => (x.Id)), Localizer.LocalizationSets, stream, m_serializer); }; m_file = new SaveableFileNotUndoable(initialData, projectFile, saveTo, backend); ConversationNodeFactory = conversationNodeFactory; DomainNodeFactory = domainNodeFactory; m_serializer = serializer; ConversationSerializer = conversationSerializer; m_conversationSerializerFactory = conversationSerializerDeserializerFactory; m_domainSerializer = domainSerializer; m_filePaths = data.Conversations.Concat(data.Localizations).Concat(data.Domains).Concat(data.Audios).ToDictionary(f => f.Id, f => f.Path); IEnumerable <Id <FileInProject> > conversationIds = data.Conversations.Select(f => f.Id); IEnumerable <Id <FileInProject> > localizerIds = data.Localizations.Select(f => f.Id); IEnumerable <Id <FileInProject> > domainIds = data.Domains.Select(f => f.Id); IEnumerable <Id <FileInProject> > audioIds = data.Audios.Select(f => f.Id); m_audioProvider = new AudioProvider(new FileInfo(projectFile.FullName), GetFilePath, s => CheckFolder(s, Origin), this, audioCustomization()); using (m_audioProvider.SuppressUpdates()) { { m_audioProvider.AudioFiles.Load(audioIds); } { //Dictionary<IDynamicEnumParameter, DynamicEnumParameter.Source> domainEnumSource = new Dictionary<IDynamicEnumParameter, DynamicEnumParameter.Source>(); Func <IDynamicEnumParameter, object, DynamicEnumParameter.Source> getDomainEnumSource = (k, o) => { return(null); //Nothing should need a source (but the system will ask anyway) //if (!domainEnumSource.ContainsKey(k)) //domainEnumSource[k] = new DynamicEnumParameter.Source(); //return domainEnumSource[k]; }; m_domainDataSource = new DomainDomain(pluginsConfig); Func <IEnumerable <Tuple <Id <FileInProject>, DocumentPath> >, IEnumerable <IDomainFile> > loader = paths => { var result = DomainFile.Load(paths, m_domainDataSource, DomainSerializerDeserializer.Make, DomainNodeFactory, () => DomainUsage, getDomainEnumSource, backend).Evaluate(); result.ForAll(a => a.ConversationDomainModified += ConversationDatasourceModified); return(result); }; Func <DirectoryInfo, DomainFile> makeEmpty = path => DomainFile.CreateEmpty(path, m_domainDataSource, m_domainSerializer, pathOk, DomainNodeFactory, () => DomainUsage, getDomainEnumSource, backend, Origin); m_domainFiles = new ProjectElementList <IDomainFile>(GetFilePath, s => CheckFolder(s, Origin), loader, makeEmpty); m_domainFiles.Load(domainIds); } m_conversationDataSource = new ConversationDataSource(m_domainFiles.Select(df => df.Data)); if (m_conversationDataSource.DomainErrors.Any()) { MessageBox.Show(string.Join("\n", m_conversationDataSource.DomainErrors.Select(error => error.Message))); } { m_localizer = new LocalizationEngine(GetFilePath, data.LocalizationSets, context, UsedLocalizations, ShouldContract, pathOk, s => CheckFolder(s, Origin), backend, Origin); m_localizer.Localizers.Load(localizerIds); context.CurrentLocalization.Value = m_localizer.LocalizationSets.FirstOrDefault() ?? Project.TData.LocalizerSetData.Empty; m_localizer.LocalizationSetsChanged += () => { m_file.Change(); }; } { GenerateAudio audio = (c) => { return(m_audioProvider.Generate(new AudioGenerationParameters(c.File.File, this.File.File))); }; //This can be called from multiple threads simultaneously and in arbitrary orders by design of //ConversationDataSource and the underlying ConstantTypeSet and DynamicEnumParameter.Source Func <IDynamicEnumParameter, object, DynamicEnumParameter.Source> getSource = (localEnum, newSourceID) => { return(m_conversationDataSource.GetSource(localEnum.TypeId, newSourceID)); }; Func <IEnumerable <Tuple <Id <FileInProject>, DocumentPath> >, IEnumerable <IConversationFile> > loadConversations = files => { ISerializerDeserializer <XmlGraphData <NodeUIData, ConversationEditorData> > conversationSerializerDeserializer = m_conversationSerializerFactory(m_conversationDataSource); // _/ _/ _/ X _/ X _/ //return files.Select(file => ConversationFile.Load(file, ConversationNodeFactory, conversationSerializerDeserializer, audio, getSource, m_audioProvider, backend)); //TODO: AUDIO: This is ok as long as we're not using audio parameters at all return(ParallelEnumerable.Select(files.AsParallel(), file => ConversationFile.Load(file.Item1, file.Item2, ConversationNodeFactory, conversationSerializerDeserializer, audio, getSource, m_audioProvider, backend))); }; Func <DirectoryInfo, ConversationFile> makeEmpty = path => ConversationFile.CreateEmpty(path, this, ConversationNodeFactory, audio, getSource, m_audioProvider, backend, Origin); m_conversations = new ProjectElementList <IConversationFile>(GetFilePath, s => CheckFolder(s, Origin), loadConversations, makeEmpty); m_conversations.Load(conversationIds); } RefreshCallbacks(m_conversations, m_actionsOnRefreshCallbacksConversations); RefreshCallbacks(m_audioProvider.AudioFiles, m_actionsOnRefreshCallbacksAudios); RefreshCallbacks(m_localizer.Localizers, m_actionsOnRefreshCallbacksLocalizations); RefreshCallbacks(m_domainFiles, m_actionsOnRefreshCallbacksDomains); m_conversations.GotChanged += GotChanged; m_audioProvider.AudioFiles.GotChanged += GotChanged; m_localizer.Localizers.GotChanged += GotChanged; m_domainFiles.GotChanged += GotChanged; m_conversations.GotChanged += () => RefreshCallbacks(m_conversations, m_actionsOnRefreshCallbacksConversations); m_audioProvider.AudioFiles.GotChanged += () => RefreshCallbacks(m_audioProvider.AudioFiles, m_actionsOnRefreshCallbacksAudios); m_localizer.Localizers.GotChanged += () => RefreshCallbacks(m_localizer.Localizers, m_actionsOnRefreshCallbacksLocalizations); m_domainFiles.GotChanged += () => RefreshCallbacks(m_domainFiles, m_actionsOnRefreshCallbacksDomains); m_domainFiles.GotChanged += ConversationDatasourceModified; Action <IDomainFile> MaybeConversationDatasourceModified = file => { if (!file.File.Changed()) { ConversationDatasourceModified(); } }; m_domainFiles.Added += argument => { argument.File.SaveStateChanged += () => MaybeConversationDatasourceModified(argument); }; m_domainFiles.Reloaded += (_, argument) => { argument.File.SaveStateChanged += () => MaybeConversationDatasourceModified(argument); }; m_domainFiles.ForAll(d => d.File.SaveStateChanged += () => MaybeConversationDatasourceModified(d)); //m_domainFiles.Added += argument => { argument.File.SaveStateChanged += () => { if (!argument.File.Changed) ReloadDatasource(); }; }; //m_domainFiles.Reloaded += (from, to) => { to.File.SaveStateChanged += () => { if (!to.File.Changed) ReloadDatasource(); }; }; //m_domainFiles.ForAll(d => d.File.SaveStateChanged += () => { if (!d.File.Changed) ReloadDatasource(); }); m_domainFiles.Added += file => m_filePaths[file.Id] = DocumentPath.FromAbsolutePath(file.File.File.FullName, Origin); m_conversations.Added += file => m_filePaths[file.Id] = DocumentPath.FromAbsolutePath(file.File.File.FullName, Origin); m_audioProvider.AudioFiles.Added += file => m_filePaths[file.Id] = DocumentPath.FromAbsolutePath(file.File.File.FullName, Origin); m_localizer.Localizers.Added += file => m_filePaths[file.Id] = DocumentPath.FromAbsolutePath(file.File.File.FullName, Origin); m_domainFiles.Removed += file => m_filePaths.Remove(file.Id); m_conversations.Removed += file => m_filePaths.Remove(file.Id); m_audioProvider.AudioFiles.Removed += file => m_filePaths.Remove(file.Id); m_localizer.Localizers.Removed += file => m_filePaths.Remove(file.Id); //Files being moved is setup in RefreshCallbacks() DomainUsage = new DomainUsage(this); m_audioProvider.UpdateUsage(); } }
internal static IEnumerable <IDomainFile> Load(IEnumerable <Tuple <Id <FileInProject>, DocumentPath> > paths, DomainDomain source, Func <DomainDomain, DomainSerializerDeserializer> serializerdeserializer, INodeFactory nodeFactory, Func <IDomainUsage <ConversationNode, TransitionNoduleUIInfo> > domainUsage, Func <IDynamicEnumParameter, object, DynamicEnumParameter.Source> getDocumentSource, UpToDateFile.BackEnd backend) { var streamsAndPaths = paths.Select((x) => { var fileId = x.Item1; DocumentPath path = x.Item2; try { using (var stream = Util.LoadFileStream(path.FileInfo, FileMode.Open, FileAccess.Read)) { return((Either <Tuple <MemoryStream, Id <FileInProject>, DocumentPath>, MissingDomainFile>)Tuple.Create(StreamUtil.Copy(stream), fileId, path)); } } catch (MyFileLoadException e) { Console.Out.WriteLine(e.Message); Console.Out.WriteLine(e.StackTrace); Console.Out.WriteLine(e.InnerException.Message); Console.Out.WriteLine(e.InnerException.StackTrace); if (path.Exists) { MessageBox.Show("File: " + path.AbsolutePath + " could not be accessed"); } else { MessageBox.Show("File: " + path.AbsolutePath + " does not exist"); } MissingDomainFile temp = null; try { temp = new MissingDomainFile(fileId, path); Either <Tuple <MemoryStream, Id <FileInProject>, DocumentPath>, MissingDomainFile> result = temp; return(result); } catch { temp?.Dispose(); throw; } } }).Evaluate(); var validStreamsAndPaths = Either.Split(streamsAndPaths).Item1; //TODO: Use this in the below cases where we currently use streamsAndPaths IReadOnlyCollection <Guid> nonUniqueGuids = serializerdeserializer(source).CheckUniqueIds(validStreamsAndPaths.Select(x => x.Item1)); if (nonUniqueGuids.Any()) { //TODO: Provide feedback to the user as to why these failed to load. //TODO: Unit test this return(streamsAndPaths.Select(x => x.Transformed(a => new MissingDomainFile(a.Item2, a.Item3), a => a))); } //We make the, hopefully, valid assumption here that the deserializers for the various concepts within a domain file have the same version requirements. Dictionary <DocumentPath, DeserializerVersionMismatchException> failedToParseFiles = new Dictionary <DocumentPath, DeserializerVersionMismatchException>(); foreach (var sp in streamsAndPaths) { sp.Do(stream => { try { var categoryData = serializerdeserializer(source).CategoriesDeserializer.Read(stream.Item1); DomainFile.AddToData(categoryData.Nodes.Select(n => n.GraphData), source); } catch (DeserializerVersionMismatchException e) { failedToParseFiles[stream.Item3] = e; } }, a => { }); } foreach (var sp in streamsAndPaths) { sp.Do(stream => { try { var typeData = serializerdeserializer(source).TypesDeserializer.Read(stream.Item1); DomainFile.AddToData(typeData.Nodes.Select(n => n.GraphData), source); } catch (DeserializerVersionMismatchException e) { failedToParseFiles[stream.Item3] = e; } }, a => { }); } foreach (var sp in streamsAndPaths) { sp.Do(stream => { try { var connectorData = serializerdeserializer(source).ConnectorsDeserializer.Read(stream.Item1); DomainFile.AddToData(connectorData.Nodes.Select(n => n.GraphData), source); } catch (DeserializerVersionMismatchException e) { failedToParseFiles[stream.Item3] = e; } }, a => { }); } foreach (var sp in streamsAndPaths) { sp.Do(stream => { try { var nodeData = serializerdeserializer(source).NodesDeserializer.Read(stream.Item1); DomainFile.AddToData(nodeData.Nodes.Select(n => n.GraphData), source); } catch (DeserializerVersionMismatchException e) { failedToParseFiles[stream.Item3] = e; } }, a => { }); } { var result = streamsAndPaths.Select(a => a.Transformed <IDomainFile>(stream => { try { var editorData = serializerdeserializer(source).EditorDataDeserializer.Read(stream.Item1); DomainFile.AddToData(editorData.Nodes.Select(n => n.GraphData), source); var allData = serializerdeserializer(source).EverythingDeserializer.Read(stream.Item1); List <IAutoCompletePattern> autoCompletePatterns = new List <IAutoCompletePattern>(); var nodeData = serializerdeserializer(source).AutoCompleteSuggestionsDeserializer.Read(stream.Item1); autoCompletePatterns.AddRange(AutoCompletePattern.Generate(nodeData, source)); return(new DomainFile(allData.Nodes.ToList(), editorData.EditorData.Groups.ToList(), stream.Item1, stream.Item2, stream.Item3, allData.Errors, source, serializerdeserializer(source).Serializer, nodeFactory, domainUsage, getDocumentSource, autoCompletePatterns, backend)); } catch (DeserializerVersionMismatchException e) { failedToParseFiles[stream.Item3] = e; return(new MissingDomainFile(stream.Item2, stream.Item3)); } }, b => b)); if (failedToParseFiles.Any()) { //TODO: expose this to the user in a consistent way with other errors (missing files, duplicated or missing guids) StringBuilder message = new StringBuilder("Failed to parse files:\n"); foreach (var kvp in failedToParseFiles) { message.Append("\n"); message.Append(kvp.Key.RelativePath); message.Append(": "); message.Append(kvp.Value.Message); } MessageBox.Show(message.ToString()); } return(result); } }
private void NodeModified(ConversationNode node) { Action <NodeTypeData> categoryAction = category => { //m_conversationDatasource.RenameCategory(category); m_datasource.RenameCategory(category.Name, category.Guid); }; Action <IntegerData> integerAction = data => { //m_conversationDatasource.ModifyIntegerType(data); m_datasource.RenameType(BaseType.Integer, data.Name, data.TypeId); }; Action <DecimalData> decimalAction = data => { //m_conversationDatasource.ModifyDecimalType(data); m_datasource.RenameType(BaseType.Decimal, data.Name, data.TypeId); }; Action <LocalizedStringData> localizedStringAction = data => { m_datasource.RenameType(BaseType.LocalizedString, data.Name, data.TypeId); }; Action <DynamicEnumerationData> dynamicEnumAction = data => { //There's no data that the conversation domain needs m_datasource.RenameType(BaseType.DynamicEnumeration, data.Name, data.TypeId); }; Action <LocalDynamicEnumerationData> localDynamicEnumAction = data => { //There's no data that the conversation domain needs m_datasource.RenameType(BaseType.LocalDynamicEnumeration, data.Name, data.TypeId); }; Action <EnumerationData> enumAction = data => { //No impact on the conversation datasource m_datasource.RenameType(BaseType.Enumeration, data.Name, data.TypeId); }; Action <EnumerationData> enumValueAction = data => { //m_conversationDatasource.UpdateEnumeration(data); m_datasource.UpdateEnumeration(data); }; Action <NodeData> nodeAction = data => { //m_conversationDatasource.NodeDefinitionModified(data); //Doesn't affect the domain domain }; Action <ConnectorDefinitionData> connectorAction = data => { //Update conversation datasource? m_datasource.ModifyConnector(data); }; Action <ConnectionDefinitionData> connectionAction = data => { //Doesn't affect the domain domain }; if (m_datasource.IsConnector(node.Data.NodeTypeId)) { var nodeConnector = node.Data.Connectors.Single(c => c.Definition.Id == DomainIDs.ConnectorOutputDefinition.Id); var nodes = nodeConnector.Connections.Select(c => c.Parent).Where(n => n.NodeTypeId == DomainIDs.NodeGuid); DomainDomain.ForEachNode(nodes, categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); } else if (m_datasource.IsParameter(node.Data.NodeTypeId)) { var nodeConnector = node.Data.Connectors.Single(c => c.Definition.Id == DomainIDs.ParameterOutputDefinition.Id); var nodes = nodeConnector.Connections.Select(c => c.Parent).Where(n => n.NodeTypeId == DomainIDs.NodeGuid); DomainDomain.ForEachNode(nodes, categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); } else if (m_datasource.IsConfig(node.Data.NodeTypeId)) { var nodeConnector = node.Data.Connectors.Single(c => c.Definition.Id == DomainIDs.ConfigOutputDefinition.Id); var connected = nodeConnector.Connections.Select(c => c.Parent); var nodes = connected.Where(n => n.NodeTypeId == DomainIDs.NodeGuid); DomainDomain.ForEachNode(nodes, categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); //Don't currently need to handle parameter config affecting nodes //var parameters = connected.Where(n => m_datasource.IsParameter(n.NodeTypeID)); //var nodes2 = parameters.SelectMany(p=>p.Connectors.Where(c=>c.m_definition.Id == DomainIDs.PARAMETER_OUTPUT_DEFINITION.Id)) //DomainDomain.ForEachNode } else { DomainDomain.ForEachNode(node.Only(), categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); } ConversationDomainModified.Execute(); //No need to be picky about false positives }