public void RefColPropertiesAreChangedToRefseq()
{
var rt = new XElement(SharedConstants.RtTag,
new XAttribute(SharedConstants.Class, "CmPossibility"),
new XAttribute(SharedConstants.GuidStr, "c1ed6dc8-e382-11de-8a39-0800200c9a66"),
new XElement("Restrictions",
BaseDomainServices.CreateObjSurElement("0039739a-7fcf-4838-8b75-566b8815a29f", "r"),
BaseDomainServices.CreateObjSurElement("00b560a2-9af0-4185-bbeb-c0eb3c5e3769", "r")));
var classData = new Dictionary <string, SortedDictionary <string, byte[]> >();
var data = new SortedDictionary <string, byte[]>
{
{ "c1ed6dc8-e382-11de-8a39-0800200c9a66", SharedConstants.Utf8.GetBytes(rt.ToString()) }
};
classData.Add("CmPossibility", data);
var guidToClassMapping = new Dictionary <string, string> {
{ "c1ed6dc8-e382-11de-8a39-0800200c9a66", "CmPossibility" }
};
CmObjectNestingService.NestObject(false, rt,
classData,
guidToClassMapping);
var result = rt.ToString();
Assert.IsTrue(result.Contains(SharedConstants.Refcol));
}
internal static void PushHumptyOffTheWall(IProgress progress, bool writeVerbose, string mainFilePathname)
{
Guard.AgainstNull(progress, "progress");
FileWriterService.CheckFilename(mainFilePathname);
var rootDirectoryName = Path.GetDirectoryName(mainFilePathname);
// NB: This is strictly an ordered list of method calls.
// Don't even 'think' of changing any of them.
CheckForUserCancelRequested(progress);
DeleteOldFiles(rootDirectoryName);
CheckForUserCancelRequested(progress);
WriteVersionFile(mainFilePathname);
// Outer Dict has the class name for its key and a sorted (by guid) dictionary as its value.
// The inner dictionary has a caseless guid as the key and the byte array as the value.
// (Only has current concrete classes.)
var classData = GenerateBasicClassData();
var wellUsedElements = new Dictionary <string, XElement>
{
{ SharedConstants.LangProject, null },
{ SharedConstants.LexDb, null }
};
var guidToClassMapping = WriteOrCacheProperties(mainFilePathname, classData, wellUsedElements);
CheckForUserCancelRequested(progress);
BaseDomainServices.PushHumptyOffTheWall(progress, writeVerbose, rootDirectoryName, wellUsedElements, classData, guidToClassMapping);
#if DEBUG
// Enable ONLY for testing a round trip.
// FLExProjectUnifier.PutHumptyTogetherAgain(progress, writeVerbose, mainFilePathname);
#endif
}
public void OneItemInCollectionRemains()
{
var collData = new XElement("CollectionProperty", BaseDomainServices.CreateObjSurElement("c1ecf889-e382-11de-8a39-0800200c9a66"));
DataSortingService.SortCollectionProperties(collData);
Assert.AreEqual("CollectionProperty", collData.Name.LocalName);
Assert.AreEqual(1, collData.Elements().Count());
Assert.AreEqual("c1ecf889-e382-11de-8a39-0800200c9a66", collData.Element(SharedConstants.Objsur).Attribute(SharedConstants.GuidStr).Value);
}
/// <summary>
/// Flatten an owned object and add an appropriate objsur to the specified property of the owning object.
/// </summary>
internal static void FlattenOwnedObject(string pathname,
SortedDictionary <string, XElement> sortedData,
XElement element, string ownerguid, XContainer owningElement, string propertyName)
{
FlattenObjectCore(pathname, sortedData, element, ownerguid);
// We MUST create the objsur AFTER flattening the object, which may pathologically change its guid.
var guid = element.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant();
BaseDomainServices.RestoreObjsurElement(owningElement, propertyName, BaseDomainServices.CreateObjSurElement(guid));
}
internal static void FlattenContext(
SortedDictionary <string, XElement> highLevelData,
SortedDictionary <string, XElement> sortedData,
string linguisticsBaseDir)
{
var phonologyDir = Path.Combine(linguisticsBaseDir, SharedConstants.Phonology);
if (!Directory.Exists(phonologyDir))
{
return;
}
var langProjElement = highLevelData[SharedConstants.LangProject];
var currentPathname = Path.Combine(phonologyDir, SharedConstants.PhonologyFeaturesFilename);
if (File.Exists(currentPathname))
{
var phoneFeatSysDoc = XDocument.Load(currentPathname);
BaseDomainServices.RestoreElement(
currentPathname,
sortedData,
langProjElement, "PhFeatureSystem",
phoneFeatSysDoc.Root.Element("FsFeatureSystem")); // Owned elment.
}
currentPathname = Path.Combine(phonologyDir, SharedConstants.PhonologicalDataFilename);
if (!File.Exists(currentPathname))
{
return;
}
var phonDataDoc = XDocument.Load(currentPathname);
var phonDataElement = phonDataDoc.Root.Element("PhPhonData");
BaseDomainServices.RestoreElement(
currentPathname,
sortedData,
langProjElement, "PhonologicalData",
phonDataElement); // Owned elment.
// Optional PhonRuleFeats list.
currentPathname = Path.Combine(phonologyDir, SharedConstants.PhonRuleFeaturesFilename);
if (!File.Exists(currentPathname))
{
return;
}
var phonRuleFeatsListDoc = XDocument.Load(currentPathname);
BaseDomainServices.RestoreElement(
currentPathname,
sortedData,
phonDataElement, "PhonRuleFeats",
phonRuleFeatsListDoc.Root.Element(SharedConstants.CmPossibilityList)); // Owned elment.
}
public void CollectionPropertyIsSorted()
{
var collData = new XElement("CollectionProperty",
BaseDomainServices.CreateObjSurElement("c1ecf88b-e382-11de-8a39-0800200c9a66"),
BaseDomainServices.CreateObjSurElement("c1ecf88a-e382-11de-8a39-0800200c9a66"));
DataSortingService.SortCollectionProperties(collData);
Assert.AreEqual("CollectionProperty", collData.Name.LocalName);
Assert.AreEqual(2, collData.Elements().Count());
Assert.AreEqual("c1ecf88a-e382-11de-8a39-0800200c9a66", collData.Elements().ElementAt(0).Attribute(SharedConstants.GuidStr).Value);
Assert.AreEqual("c1ecf88b-e382-11de-8a39-0800200c9a66", collData.Elements().ElementAt(1).Attribute(SharedConstants.GuidStr).Value);
}
internal static void RemoveBoundedContextData(string pathRoot)
{
var generalBaseDir = Path.Combine(pathRoot, SharedConstants.General);
BaseDomainServices.RemoveBoundedContextDataCore(generalBaseDir);
var oldLintPathname = Path.Combine(generalBaseDir, "FLExProject.lint");
if (File.Exists(oldLintPathname + ".ChorusNotes"))
{
File.Delete(oldLintPathname + ".ChorusNotes");
}
}
internal static void NestContext(XElement stylesProperty,
string baseDirectory,
IDictionary <string, SortedDictionary <string, byte[]> > classData,
Dictionary <string, string> guidToClassMapping)
{
var stylesDir = baseDirectory; // Just use main folder. // Path.Combine(baseDirectory, SharedConstants.Styles);
if (!Directory.Exists(stylesDir))
{
Directory.CreateDirectory(stylesDir);
}
BaseDomainServices.NestStylesPropertyElement(classData, guidToClassMapping, stylesProperty, Path.Combine(stylesDir, StyleFilename));
}
private static void DeleteOldFiles(string pathRoot)
{
// Wipe out custom props file, as it will be re-created, even if it only has the root element in it.
var customPropPathname = Path.Combine(pathRoot, SharedConstants.CustomPropertiesFilename);
if (File.Exists(customPropPathname))
{
File.Delete(customPropPathname);
}
// Delete ModelVersion file, but it gets rewritten soon.
var modelVersionPathname = Path.Combine(pathRoot, SharedConstants.ModelVersionFilename);
if (File.Exists(modelVersionPathname))
{
File.Delete(modelVersionPathname);
}
// Deletes all files in new locations, except the current ChorusNotes files.
BaseDomainServices.RemoveDomainData(pathRoot);
}
public void RefColElementsRestoredToObjsurElements()
{
using (var tempFile = new TempFile())
{
var sortedData = new SortedDictionary <string, XElement>();
var possibilityElement = new XElement("CmPossibility",
new XAttribute(SharedConstants.GuidStr, "c1ed6dc8-e382-11de-8a39-0800200c9a66"),
new XElement("Restrictions",
new XElement(SharedConstants.Refcol,
BaseDomainServices.CreateAttributes("0039739a-7fcf-4838-8b75-566b8815a29f", "r"),
new XElement(SharedConstants.Refcol,
BaseDomainServices.CreateAttributes("00b560a2-9af0-4185-bbeb-c0eb3c5e3769", "r")))));
CmObjectFlatteningService.FlattenOwnerlessObject(
tempFile.Path,
sortedData,
possibilityElement);
var restored = sortedData["c1ed6dc8-e382-11de-8a39-0800200c9a66"];
Assert.IsTrue(restored.ToString().Contains(SharedConstants.Objsur));
}
}
internal static void RemoveBoundedContextData(string pathRoot)
{
var linguisticsBaseDir = Path.Combine(pathRoot, SharedConstants.Linguistics);
BaseDomainServices.RemoveBoundedContextDataCore(linguisticsBaseDir);
// Remove ChorusNotes files for old lexicon file and old WFI file.
// Lexicon.lexdb
var lexiconDir = Path.Combine(linguisticsBaseDir, SharedConstants.Lexicon);
var oldNotesPathname = Path.Combine(lexiconDir, "Lexicon.lexdb.ChorusNotes");
if (File.Exists(oldNotesPathname))
{
File.Delete(oldNotesPathname);
}
// WordformInventory.inventory
var inventoryDir = Path.Combine(linguisticsBaseDir, SharedConstants.WordformInventoryRootFolder);
oldNotesPathname = Path.Combine(inventoryDir, "WordformInventory.inventoryChorusNotes");
if (File.Exists(oldNotesPathname))
{
File.Delete(oldNotesPathname);
}
}
private void AddOwnedObjects()
{
// Add two entries, the first one having a nested entry.
var rtGuid = _rt.Attribute(SharedConstants.GuidStr).Value;
var data = new SortedDictionary <string, byte[]>();
var entry1 = new XElement(SharedConstants.RtTag,
new XAttribute(SharedConstants.Class, "ReversalIndexEntry"),
new XAttribute(SharedConstants.GuidStr, "0039739a-7fcf-4838-8b75-566b8815a29f"),
new XAttribute(SharedConstants.OwnerGuid, rtGuid));
data.Add("0039739a-7fcf-4838-8b75-566b8815a29f", SharedConstants.Utf8.GetBytes(entry1.ToString()));
_guidToClassMapping.Add("0039739a-7fcf-4838-8b75-566b8815a29f", "ReversalIndexEntry");
var subentry1 = new XElement(SharedConstants.RtTag,
new XAttribute(SharedConstants.Class, "ReversalIndexEntry"),
new XAttribute(SharedConstants.GuidStr, "14a6b4bc-1bb3-4c67-b70c-5a195e411e27"),
new XAttribute(SharedConstants.OwnerGuid, "0039739a-7fcf-4838-8b75-566b8815a29f"));
data.Add("14a6b4bc-1bb3-4c67-b70c-5a195e411e27", SharedConstants.Utf8.GetBytes(subentry1.ToString()));
_guidToClassMapping.Add("14a6b4bc-1bb3-4c67-b70c-5a195e411e27", "ReversalIndexEntry");
var entry2 = new XElement(SharedConstants.RtTag,
new XAttribute(SharedConstants.Class, "ReversalIndexEntry"),
new XAttribute(SharedConstants.GuidStr, "00b560a2-9af0-4185-bbeb-c0eb3c5e3769"),
new XAttribute(SharedConstants.OwnerGuid, rtGuid));
data.Add("00b560a2-9af0-4185-bbeb-c0eb3c5e3769", SharedConstants.Utf8.GetBytes(entry2.ToString()));
_guidToClassMapping.Add("00b560a2-9af0-4185-bbeb-c0eb3c5e3769", "ReversalIndexEntry");
_classData.Add("ReversalIndexEntry", data);
var entriesElement = new XElement("Entries",
BaseDomainServices.CreateObjSurElement("0039739a-7fcf-4838-8b75-566b8815a29f"),
BaseDomainServices.CreateObjSurElement("00b560a2-9af0-4185-bbeb-c0eb3c5e3769"));
_rt.Add(entriesElement);
entriesElement = new XElement("Subentries",
BaseDomainServices.CreateObjSurElement("14a6b4bc-1bb3-4c67-b70c-5a195e411e27"));
entry1.Add(entriesElement);
// Add the POS list, with two possibilities (own-seq prop).
const string posListGuid = "fb5e83e5-6576-455d-aba0-0b7a722b9b5d";
var posList = new XElement(SharedConstants.RtTag,
new XAttribute(SharedConstants.Class, SharedConstants.CmPossibilityList),
new XAttribute(SharedConstants.GuidStr, posListGuid),
new XAttribute(SharedConstants.OwnerGuid, rtGuid));
var pos1 = new XElement(SharedConstants.RtTag,
new XAttribute(SharedConstants.Class, "PartOfSpeech"),
new XAttribute(SharedConstants.GuidStr, "c1ed6dc6-e382-11de-8a39-0800200c9a66"),
new XAttribute(SharedConstants.OwnerGuid, posListGuid),
new XElement("DateCreated", new XAttribute(SharedConstants.Val, "created")));
var pos2 = new XElement(SharedConstants.RtTag,
new XAttribute(SharedConstants.Class, "PartOfSpeech"),
new XAttribute(SharedConstants.GuidStr, "c1ed6dc7-e382-11de-8a39-0800200c9a66"),
new XAttribute(SharedConstants.OwnerGuid, posListGuid),
new XElement("DateCreated", new XAttribute(SharedConstants.Val, "created")));
entriesElement = new XElement("Possibilities",
BaseDomainServices.CreateObjSurElement("c1ed6dc6-e382-11de-8a39-0800200c9a66"),
BaseDomainServices.CreateObjSurElement("c1ed6dc7-e382-11de-8a39-0800200c9a66"));
_guidToClassMapping.Add("c1ed6dc6-e382-11de-8a39-0800200c9a66", "PartOfSpeech");
_guidToClassMapping.Add("c1ed6dc7-e382-11de-8a39-0800200c9a66", "PartOfSpeech");
data = new SortedDictionary <string, byte[]>
{
{ "c1ed6dc6-e382-11de-8a39-0800200c9a66", SharedConstants.Utf8.GetBytes(pos1.ToString()) },
{ "c1ed6dc7-e382-11de-8a39-0800200c9a66", SharedConstants.Utf8.GetBytes(pos2.ToString()) }
};
_classData.Add("PartOfSpeech", data);
posList.Add(entriesElement);
entriesElement = new XElement("PartsOfSpeech",
BaseDomainServices.CreateObjSurElement(posListGuid));
_guidToClassMapping.Add(posListGuid, SharedConstants.CmPossibilityList);
data = new SortedDictionary <string, byte[]>
{
{ posListGuid, SharedConstants.Utf8.GetBytes(posList.ToString()) }
};
_classData.Add(SharedConstants.CmPossibilityList, data);
_rt.Add(entriesElement);
}
internal static void NestContext(string linguisticsBaseDir,
IDictionary <string, XElement> wellUsedElements,
IDictionary <string, SortedDictionary <string, byte[]> > classData,
Dictionary <string, string> guidToClassMapping)
{
var textCorpusBaseDir = Path.Combine(linguisticsBaseDir, SharedConstants.TextCorpus);
if (!Directory.Exists(textCorpusBaseDir))
{
Directory.CreateDirectory(textCorpusBaseDir);
}
var langProjElement = wellUsedElements[SharedConstants.LangProject];
// Write Genre list (owning atomic CmPossibilityList)
FileWriterService.WriteNestedListFileIfItExists(classData, guidToClassMapping,
langProjElement, SharedConstants.GenreList,
Path.Combine(textCorpusBaseDir, SharedConstants.GenreListFilename));
// Write text markup tags list (owning atomic CmPossibilityList)
FileWriterService.WriteNestedListFileIfItExists(classData, guidToClassMapping,
langProjElement, SharedConstants.TextMarkupTags,
Path.Combine(textCorpusBaseDir, SharedConstants.TextMarkupTagsListFilename));
// Handle the LP TranslationTags prop (OA-CmPossibilityList), if it exists.
FileWriterService.WriteNestedListFileIfItExists(classData, guidToClassMapping,
langProjElement, SharedConstants.TranslationTags,
Path.Combine(textCorpusBaseDir, SharedConstants.TranslationTagsListFilename));
var texts = classData["Text"];
if (texts.Count == 0)
{
return; // No texts to process.
}
if (MetadataCache.MdCache.ModelVersion < 7000059)
{
// Backwards compatible code.
var textGuidsInLangProj = BaseDomainServices.GetGuids(langProjElement, "Texts");
if (textGuidsInLangProj.Count == 0)
{
return; // None owned by lang project. (Some can be owned by RnGenericRec.)
}
foreach (var textGuid in textGuidsInLangProj)
{
var rootElement = new XElement("TextInCorpus");
var textElement = Utilities.CreateFromBytes(texts[textGuid]);
rootElement.Add(textElement);
CmObjectNestingService.NestObject(
false,
textElement,
classData,
guidToClassMapping);
FileWriterService.WriteNestedFile(
Path.Combine(textCorpusBaseDir, "Text_" + textGuid.ToLowerInvariant() + "." + SharedConstants.TextInCorpus),
rootElement);
}
// Remove child objsur nodes from owning LangProg
langProjElement.Element("Texts").RemoveNodes();
}
else
{
foreach (var textGuid in texts.Keys.ToArray()) // Needs a copy, since the dictionary is changed.
{
var rootElement = new XElement("TextInCorpus");
var textElement = Utilities.CreateFromBytes(texts[textGuid]);
rootElement.Add(textElement);
CmObjectNestingService.NestObject(
false,
textElement,
classData,
guidToClassMapping);
FileWriterService.WriteNestedFile(
Path.Combine(textCorpusBaseDir, "Text_" + textGuid.ToLowerInvariant() + "." + SharedConstants.TextInCorpus),
rootElement);
}
}
}
internal static void NestContext(string generalBaseDir,
IDictionary <string, XElement> wellUsedElements,
IDictionary <string, SortedDictionary <string, byte[]> > classData,
Dictionary <string, string> guidToClassMapping)
{
var langProjElement = wellUsedElements[SharedConstants.LangProject];
// LP AnnotationDefs (OA-CmPossibilityList). AnnotationDefs.list]
FileWriterService.WriteNestedListFileIfItExists(classData,
guidToClassMapping,
langProjElement, SharedConstants.AnnotationDefs,
Path.Combine(generalBaseDir, SharedConstants.AnnotationDefsListFilename));
// LP Styles (OC-StStyle) is used by everyone, but Scripture, so they go here.
BaseDomainServices.NestStylesPropertyElement(
classData,
guidToClassMapping,
langProjElement.Element(SharedConstants.Styles),
Path.Combine(generalBaseDir, SharedConstants.FLExStylesFilename));
// LP Filters (OC) can go into one filters file here. (FLExFilters.filter: new ext)
var owningPropElement = langProjElement.Element(SharedConstants.Filters);
if (owningPropElement != null && owningPropElement.HasElements)
{
var root = new XElement(SharedConstants.Filters);
foreach (var filterObjSurElement in owningPropElement.Elements().ToList())
{
var filterGuid = filterObjSurElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant();
var className = guidToClassMapping[filterGuid];
var filterElement = Utilities.CreateFromBytes(classData[className][filterGuid]);
CmObjectNestingService.NestObject(false, filterElement, classData, guidToClassMapping);
root.Add(filterElement);
}
FileWriterService.WriteNestedFile(Path.Combine(generalBaseDir, SharedConstants.FLExFiltersFilename), root);
owningPropElement.RemoveNodes();
}
// LP Annotations (OC). Who still uses them? If all else fails, or they are used by several BCs, then store them in one file here.
// [FLExAnnotations.annotation: new ext]
// OJO! Sig is "CmAnnotation", which is abtract class, so handle like in Discourse-land.
owningPropElement = langProjElement.Element(SharedConstants.Annotations);
if (owningPropElement != null && owningPropElement.HasElements)
{
var root = new XElement(SharedConstants.Annotations);
foreach (var annotationObjSurElement in owningPropElement.Elements().ToList())
{
var annotationGuid = annotationObjSurElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant();
var className = guidToClassMapping[annotationGuid];
var annotationElement = Utilities.CreateFromBytes(classData[className][annotationGuid]);
CmObjectNestingService.NestObject(false, annotationElement, classData, guidToClassMapping);
BaseDomainServices.ReplaceElementNameWithAndAddClassAttribute(SharedConstants.CmAnnotation, annotationElement);
root.Add(annotationElement);
}
FileWriterService.WriteNestedFile(Path.Combine(generalBaseDir, SharedConstants.FLExAnnotationsFilename), root);
owningPropElement.RemoveNodes();
}
// Some CmPicture instances may not be owned.
var rootElement = new XElement(SharedConstants.Pictures);
var unownedPictures = classData[SharedConstants.CmPicture].Values.Where(listElement => XmlUtils.GetAttributes(listElement, new HashSet <string> {
SharedConstants.OwnerGuid
})[SharedConstants.OwnerGuid] == null).ToList();
foreach (var unownedPictureBytes in unownedPictures)
{
var element = Utilities.CreateFromBytes(unownedPictureBytes);
CmObjectNestingService.NestObject(
false,
element,
classData,
guidToClassMapping);
rootElement.Add(element);
}
FileWriterService.WriteNestedFile(Path.Combine(generalBaseDir, SharedConstants.FLExUnownedPicturesFilename), rootElement);
// No VirtualOrdering instances are owned.
if (MetadataCache.MdCache.ModelVersion > MetadataCache.StartingModelVersion)
{
rootElement = new XElement(SharedConstants.VirtualOrderings);
foreach (var element in classData[SharedConstants.VirtualOrdering].Values.ToArray().Select(virtualOrderingBytes => Utilities.CreateFromBytes(virtualOrderingBytes)))
{
CmObjectNestingService.NestObject(
false,
element,
classData,
guidToClassMapping);
rootElement.Add(element);
}
FileWriterService.WriteNestedFile(Path.Combine(generalBaseDir, SharedConstants.FLExVirtualOrderingFilename), rootElement);
}
// Yippee!! Write LP here. :-) [LanguageProject.langproj; new ext]
CmObjectNestingService.NestObject(false,
langProjElement,
classData,
guidToClassMapping);
FileWriterService.WriteNestedFile(Path.Combine(generalBaseDir, SharedConstants.LanguageProjectFilename), new XElement(SharedConstants.LanguageProject, langProjElement));
}
internal static void FlattenContext(
SortedDictionary <string, XElement> highLevelData,
SortedDictionary <string, XElement> sortedData,
string generalBaseDir)
{
var langProjPathname = Path.Combine(generalBaseDir, SharedConstants.LanguageProjectFilename);
var langProjDoc = XDocument.Load(langProjPathname);
var langProjElement = langProjDoc.Root.Element(SharedConstants.LangProject);
// Add LP to highLevelData.
highLevelData.Add(SharedConstants.LangProject, langProjElement);
// Flatten it.
CmObjectFlatteningService.FlattenOwnerlessObject(
langProjPathname,
sortedData,
langProjElement);
// Add stuff LP owns that is here, then flatten it.
// LP AnnotationDefs (OA-CmPossibilityList).
var currentPathname = Path.Combine(generalBaseDir, SharedConstants.AnnotationDefsListFilename);
if (File.Exists(currentPathname))
{
// Flatten it here to get the right pathname into the method.
BaseDomainServices.RestoreElement(
currentPathname,
sortedData,
langProjElement,
SharedConstants.AnnotationDefs,
XDocument.Load(currentPathname).Root.Element(SharedConstants.CmPossibilityList));
}
// LP Styles (OC-StStyle)
var langProjGuid = langProjElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant();
var sortedElements = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase);
currentPathname = Path.Combine(generalBaseDir, SharedConstants.FLExStylesFilename);
XDocument doc;
if (File.Exists(currentPathname))
{
doc = XDocument.Load(currentPathname);
foreach (var styleElement in doc.Root.Elements(SharedConstants.StStyle))
{
// Put style back into LP's Styles element.
CmObjectFlatteningService.FlattenOwnedObject(
currentPathname,
sortedData,
styleElement,
langProjGuid, sortedElements); // Restore 'ownerguid' to style.
}
// Restore LP Styles property in sorted order.
var langProjOwningProp = langProjElement.Element(SharedConstants.Styles);
foreach (var sortedTextObjSurElement in sortedElements.Values)
{
langProjOwningProp.Add(sortedTextObjSurElement);
}
}
// LP Filters (OC-CmFilter)
currentPathname = Path.Combine(generalBaseDir, SharedConstants.FLExFiltersFilename);
if (File.Exists(currentPathname))
{
sortedElements = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase);
doc = XDocument.Load(currentPathname);
foreach (var filterElement in doc.Root.Elements("CmFilter"))
{
// Put CmFilter back into LP's Filters element.
CmObjectFlatteningService.FlattenOwnedObject(
currentPathname,
sortedData,
filterElement,
langProjGuid, sortedElements); // Restore 'ownerguid' to style.
}
// Restore LP Filters property in sorted order.
var langProjOwningProp = langProjElement.Element(SharedConstants.Filters);
foreach (var sortedTextObjSurElement in sortedElements.Values)
{
langProjOwningProp.Add(sortedTextObjSurElement);
}
}
// LP Annotations (OC-CmAnnotation). [Odd elements like in Discourse.]
currentPathname = Path.Combine(generalBaseDir, SharedConstants.FLExAnnotationsFilename);
if (File.Exists(currentPathname))
{
sortedElements = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase);
doc = XDocument.Load(currentPathname);
foreach (var annotationElement in doc.Root.Elements(SharedConstants.CmAnnotation))
{
// Put CmAnnotation back into LP's Annotations element.
var classAttr = annotationElement.Attribute(SharedConstants.Class);
annotationElement.Name = classAttr.Value;
classAttr.Remove();
CmObjectFlatteningService.FlattenOwnedObject(
currentPathname,
sortedData,
annotationElement,
langProjGuid, sortedElements); // Restore 'ownerguid' to style.
}
// Restore LP Annotations property in sorted order.
var owningProp = langProjElement.Element(SharedConstants.Annotations);
foreach (var sortedTextObjSurElement in sortedElements.Values)
{
owningProp.Add(sortedTextObjSurElement);
}
}
// No VirtualOrdering instances are owned.
if (MetadataCache.MdCache.ModelVersion > MetadataCache.StartingModelVersion)
{
currentPathname = Path.Combine(generalBaseDir, SharedConstants.FLExVirtualOrderingFilename);
doc = XDocument.Load(currentPathname);
foreach (var orderingElement in doc.Root.Elements(SharedConstants.VirtualOrdering))
{
CmObjectFlatteningService.FlattenOwnerlessObject(
currentPathname,
sortedData,
orderingElement);
}
}
// Some CmPicture instances may not be owned.
currentPathname = Path.Combine(generalBaseDir, SharedConstants.FLExUnownedPicturesFilename);
doc = XDocument.Load(currentPathname);
foreach (var pictureElement in doc.Root.Elements(SharedConstants.CmPicture))
{
CmObjectFlatteningService.FlattenOwnerlessObject(
currentPathname,
sortedData,
pictureElement);
}
}
internal static void PutHumptyTogetherAgain(IProgress progress, bool writeVerbose, string mainFilePathname)
{
Guard.AgainstNull(progress, "progress");
FileWriterService.CheckPathname(mainFilePathname);
using (var tempFile = new TempFile())
{
using (var writer = XmlWriter.Create(tempFile.Path, new XmlWriterSettings // NB: These are the FW bundle of settings, not the canonical settings.
{
OmitXmlDeclaration = false,
CheckCharacters = true,
ConformanceLevel = ConformanceLevel.Document,
Encoding = new UTF8Encoding(false),
Indent = true,
IndentChars = (""),
NewLineOnAttributes = false
}))
{
var pathRoot = Path.GetDirectoryName(mainFilePathname);
// NB: The method calls are strictly ordered.
// Don't even think of changing them.
if (writeVerbose)
{
progress.WriteVerbose("Processing data model version number....");
}
else
{
progress.WriteMessage("Processing data model version number....");
}
UpgradeToVersion(writer, pathRoot);
if (writeVerbose)
{
progress.WriteVerbose("Processing custom properties....");
}
else
{
progress.WriteMessage("Processing custom properties....");
}
WriteOptionalCustomProperties(writer, pathRoot);
var sortedData = BaseDomainServices.PutHumptyTogetherAgain(progress, writeVerbose, pathRoot);
if (writeVerbose)
{
progress.WriteVerbose("Writing temporary fwdata file....");
}
else
{
progress.WriteMessage("Writing temporary fwdata file....");
}
foreach (var rtElement in sortedData.Values)
{
FileWriterService.WriteElement(writer, rtElement);
}
writer.WriteEndElement();
}
//Thread.Sleep(2000); In case it blows (access denied) up again on Sue's computer.
if (writeVerbose)
{
progress.WriteVerbose("Copying temporary fwdata file to main file....");
}
else
{
progress.WriteMessage("Copying temporary fwdata file to main file....");
}
File.Copy(tempFile.Path, mainFilePathname, true);
}
SplitFileAgainIfNeeded(progress, writeVerbose, mainFilePathname);
}
internal static void FlattenContext(
SortedDictionary <string, XElement> highLevelData,
SortedDictionary <string, XElement> sortedData,
string anthropologyBaseDir)
{
var langProjElement = highLevelData[SharedConstants.LangProject];
var currentPathname = Path.Combine(anthropologyBaseDir, SharedConstants.DataNotebookFilename);
var doc = XDocument.Load(currentPathname);
var root = doc.Root;
var dnMainElement = root.Element(SharedConstants.Header).Element("RnResearchNbk");
// Add the record elements (except the possible dummy one) into dnMainElement.
var sortedRecords = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase);
foreach (var recordElement in root.Elements("RnGenericRec")
.Where(element => element.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant() != SharedConstants.EmptyGuid))
{
// Add it to Records property of dnMainElement, BUT in sorted order, below, and then flatten dnMainElement.
sortedRecords.Add(recordElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(), recordElement);
}
if (sortedRecords.Count > 0)
{
var recordsElementOwningProp = dnMainElement.Element("Records")
?? CmObjectFlatteningService.AddNewPropertyElement(dnMainElement, "Records");
foreach (var sortedChartElement in sortedRecords.Values)
{
recordsElementOwningProp.Add(sortedChartElement);
}
}
// Put the RecTypes list back into place in dnMainElement, before dnMainElement is restored.
// But only as an <objsur> element.
var recTypesPathname = Path.Combine(anthropologyBaseDir, "RecTypes." + SharedConstants.List);
if (File.Exists(recTypesPathname))
{
var listDoc = XDocument.Load(recTypesPathname);
BaseDomainServices.RestoreElement(recTypesPathname, sortedData,
dnMainElement, "RecTypes",
listDoc.Root.Element(SharedConstants.CmPossibilityList));
}
BaseDomainServices.RestoreElement(currentPathname, sortedData,
langProjElement, "ResearchNotebook",
dnMainElement);
// Put the lists back where they belong in LangProj.
foreach (var listPathname in Directory.GetFiles(anthropologyBaseDir, "*." + SharedConstants.List))
{
var listDoc = XDocument.Load(listPathname);
var listRoot = listDoc.Root;
var listRootName = listRoot.Name.LocalName;
if (listRootName == "RecTypes")
{
continue;
}
BaseDomainServices.RestoreElement(listPathname,
sortedData,
langProjElement,
listRootName,
listRoot.Element(SharedConstants.CmPossibilityList));
}
}
internal static void NestContext(string linguisticsBaseDir,
IDictionary <string, XElement> wellUsedElements,
IDictionary <string, SortedDictionary <string, byte[]> > classData,
Dictionary <string, string> guidToClassMapping)
{
var discourseDir = Path.Combine(linguisticsBaseDir, SharedConstants.DiscourseRootFolder);
if (!Directory.Exists(discourseDir))
{
Directory.CreateDirectory(discourseDir);
}
var sortedInstanceData = classData["DsDiscourseData"];
if (sortedInstanceData.Count == 0)
{
return;
}
// 'discourseElement' is owned by LangProj in DsDiscourseData prop (OA).
var discourseElement = Utilities.CreateFromBytes(sortedInstanceData.Values.First());
// Nest the entire object, and then pull out the owned stuff, and relocate them, as needed.
CmObjectNestingService.NestObject(
false,
discourseElement,
classData,
guidToClassMapping);
var listElement = discourseElement.Element(SharedConstants.ConstChartTempl);
if (listElement != null)
{
// NB: Write list file, but only if discourseElement has the list.
FileWriterService.WriteNestedFile(Path.Combine(discourseDir, SharedConstants.ConstChartTemplFilename), listElement);
listElement.RemoveNodes();
}
listElement = discourseElement.Element(SharedConstants.ChartMarkers);
if (listElement != null)
{
// NB: Write list file, but only if discourseElement has the list.
FileWriterService.WriteNestedFile(Path.Combine(discourseDir, SharedConstants.ChartMarkersFilename), listElement);
listElement.RemoveNodes();
}
// <owning num="2" id="Charts" card="col" sig="DsChart"> [Abstract. Owns nothing special, but is subclass of CmMajorObject.]
// Disposition: Write in main discourse file as the repeating series of objects, BUT use the abstract class for the repeating element, since Gordon sees new subclasses of it coming along.
// NB: We will just let the normal nesting code work over discourseElement,
// which will put in the actual subclass name as the element tag.
// So, we'll just intercept them out of the owning prop elemtent (if any exist), and patch them up here.
// NB: If there are no such charts, then do the usual of making one with the empty guid for its Id.
var root = new XElement(SharedConstants.DiscourseRootFolder);
var header = new XElement(SharedConstants.Header);
root.Add(header);
header.Add(discourseElement);
// Remove child objsur node from owning LangProg
var langProjElement = wellUsedElements[SharedConstants.LangProject];
langProjElement.Element("DiscourseData").RemoveNodes();
var chartElements = discourseElement.Element("Charts");
if (chartElements != null && chartElements.HasElements)
{
foreach (var chartElement in chartElements.Elements())
{
BaseDomainServices.ReplaceElementNameWithAndAddClassAttribute(SharedConstants.DsChart, chartElement);
// It is already nested.
root.Add(chartElement);
}
chartElements.RemoveNodes();
}
FileWriterService.WriteNestedFile(Path.Combine(discourseDir, SharedConstants.DiscourseChartFilename), root);
}
internal static void FlattenContext(
SortedDictionary <string, XElement> highLevelData,
SortedDictionary <string, XElement> sortedData,
string scriptureBaseDir)
{
if (!Directory.Exists(scriptureBaseDir))
{
return;
}
// scriptureBaseDir is root/Scripture.
var pathname = Path.Combine(scriptureBaseDir, SharedConstants.ScriptureTransFilename);
if (!File.Exists(pathname))
{
return; // Nobody home.
}
var doc = XDocument.Load(pathname);
var scrElement = doc.Element(SharedConstants.TranslatedScripture).Elements().First();
// Put the NoteCategories list back in the right place.
pathname = Path.Combine(scriptureBaseDir, SharedConstants.NoteCategoriesListFilename);
if (File.Exists(pathname))
{
doc = XDocument.Load(pathname);
BaseDomainServices.RestoreElement(pathname, sortedData, scrElement, SharedConstants.NoteCategories, doc.Root.Element(SharedConstants.CmPossibilityList));
}
// Owned by LangProj in TranslatedScripture prop.
var langProjElement = highLevelData[SharedConstants.LangProject];
CmObjectFlatteningService.FlattenOwnedObject(
pathname,
sortedData,
scrElement,
langProjElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(),
langProjElement, SharedConstants.TranslatedScripture); // Restore 'ownerguid' to scrElement.
// Put the <objsur> elements back into BookAnnotations and ScriptureBooks property elements.
// There will always be 66 ScrBookAnnotations instances and they need go in canonical book order.
// There may (or may not) be ScrBook instances, but they all go in canonical book order in ScriptureBooks, if present.
var booksDir = Path.Combine(scriptureBaseDir, SharedConstants.Books);
var sortedFiles = new SortedList <int, string>(66);
foreach (var pathnameForAnn in Directory.GetFiles(booksDir, "*." + SharedConstants.bookannotations))
{
sortedFiles.Add(Int32.Parse(Path.GetFileNameWithoutExtension(pathnameForAnn)), pathnameForAnn);
}
var scrElementGuid = scrElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant();
var scriptureBooksProperty = scrElement.Element(SharedConstants.ScriptureBooks);
foreach (var sortedPathnameKvp in sortedFiles)
{
var sortedDoc = XDocument.Load(sortedPathnameKvp.Value);
var element = sortedDoc.Root.Element(SharedConstants.ScrBookAnnotations);
CmObjectFlatteningService.FlattenOwnedObject(
sortedPathnameKvp.Value,
sortedData,
element,
scrElementGuid, scrElement, SharedConstants.BookAnnotations); // Restore 'ownerguid' to annotation.
// Deal with optional ScrBook
var bookPathname = sortedPathnameKvp.Value.Replace(SharedConstants.bookannotations, SharedConstants.book);
if (!File.Exists(bookPathname))
{
continue;
}
if (scriptureBooksProperty == null)
{
scriptureBooksProperty = new XElement(SharedConstants.ScriptureBooks);
scrElement.Add(scriptureBooksProperty);
// Make sure new property is sorted in correct place.
DataSortingService.SortMainRtElement(scrElement);
}
// Add book <objsur> element to scrElement's ScriptureBooks element.
sortedDoc = XDocument.Load(bookPathname);
element = sortedDoc.Root.Element(SharedConstants.ScrBook);
CmObjectFlatteningService.FlattenOwnedObject(
bookPathname,
sortedData,
element,
scrElementGuid, scrElement, SharedConstants.ScriptureBooks); // Restore 'ownerguid' to book.
}
highLevelData.Add(scrElement.Attribute(SharedConstants.Class).Value, scrElement);
}
internal static void FlattenContext(
SortedDictionary <string, XElement> highLevelData,
SortedDictionary <string, XElement> sortedData,
string linguisticsBaseDir)
{
var reversalDir = Path.Combine(linguisticsBaseDir, ReversalRootFolder);
if (!Directory.Exists(reversalDir))
{
return;
}
var lexDb = highLevelData[SharedConstants.LexDb];
var sortedRevs = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase);
var unlovedFolders = new HashSet <string>();
foreach (var revIndexDirectoryName in Directory.GetDirectories(reversalDir))
{
var dirInfo = new DirectoryInfo(revIndexDirectoryName);
var ws = dirInfo.Name;
var reversalPathname = Path.Combine(revIndexDirectoryName, ws + "." + SharedConstants.Reversal);
if (!File.Exists(reversalPathname))
{
// If a reversal is deleted but there were ChorusNotes associated with it the directory might be
// here without any reversal files inside it.
unlovedFolders.Add(revIndexDirectoryName);
continue;
}
var reversalDoc = XDocument.Load(reversalPathname);
// Put entries back into index's Entries element.
var root = reversalDoc.Element("Reversal");
var header = root.Element(SharedConstants.Header);
var revIdxElement = header.Element("ReversalIndex");
// Restore POS list, if it exists.
var catPathname = Path.Combine(revIndexDirectoryName, ws + "-" + SharedConstants.PartsOfSpeechFilename);
if (File.Exists(catPathname))
{
var catListDoc = XDocument.Load(catPathname);
BaseDomainServices.RestoreElement(
catPathname,
sortedData,
revIdxElement, SharedConstants.PartsOfSpeech,
catListDoc.Root.Element(SharedConstants.CmPossibilityList)); // Owned elment.
}
// Put all records back in ReversalIndex, before sort and restore.
// EXCEPT, if there is only one of them and it is guid.Empty, then skip it
var sortedRecords = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase);
foreach (var recordElement in root.Elements("ReversalIndexEntry")
.Where(element => element.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant() != SharedConstants.EmptyGuid))
{
// Add it to Records property of revIdxElement, BUT in sorted order, below, and then flatten dnMainElement.
sortedRecords.Add(recordElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(), recordElement);
}
if (sortedRecords.Count > 0)
{
var recordsElementOwningProp = revIdxElement.Element("Entries")
?? CmObjectFlatteningService.AddNewPropertyElement(revIdxElement, "Entries");
foreach (var sortedChartElement in sortedRecords.Values)
{
recordsElementOwningProp.Add(sortedChartElement);
}
}
CmObjectFlatteningService.FlattenOwnedObject(reversalPathname, sortedData, revIdxElement,
lexDb.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(), sortedRevs); // Restore 'ownerguid' to indices.
}
foreach (var unlovedFolder in unlovedFolders)
{
Directory.Delete(unlovedFolder, true);
}
// Restore lexDb ReversalIndexes property in sorted order.
if (sortedRevs.Count == 0)
{
return;
}
var reversalsOwningProp = lexDb.Element("ReversalIndexes") ?? CmObjectFlatteningService.AddNewPropertyElement(lexDb, "ReversalIndexes");
foreach (var sortedRev in sortedRevs.Values)
{
reversalsOwningProp.Add(sortedRev);
}
}
internal static void FlattenContext(
SortedDictionary <string, XElement> highLevelData,
SortedDictionary <string, XElement> sortedData,
string linguisticsBaseDir)
{
var discourseDir = Path.Combine(linguisticsBaseDir, SharedConstants.DiscourseRootFolder);
if (!Directory.Exists(discourseDir))
{
return;
}
var chartPathname = Path.Combine(discourseDir, SharedConstants.DiscourseChartFilename);
if (!File.Exists(chartPathname))
{
return;
}
// The charts need to be sorted in guid order, before being added back into the owning prop element.
var doc = XDocument.Load(chartPathname);
var root = doc.Root;
var discourseElement = root.Element(SharedConstants.Header).Element("DsDiscourseData");
// Add lists back into discourseElement.
foreach (var listPathname in Directory.GetFiles(discourseDir, "*." + SharedConstants.List))
{
var listDoc = XDocument.Load(listPathname);
var listFilename = Path.GetFileName(listPathname);
var listElement = listDoc.Root.Element(SharedConstants.CmPossibilityList);
switch (listFilename)
{
case SharedConstants.ChartMarkersFilename:
discourseElement.Element(SharedConstants.ChartMarkers).Add(listElement);
break;
case SharedConstants.ConstChartTemplFilename:
discourseElement.Element(SharedConstants.ConstChartTempl).Add(listElement);
break;
}
}
// Add the chart elements (except the possible dummy one) into discourseElement.
var sortedCharts = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase);
foreach (var chartElement in root.Elements(SharedConstants.DsChart)
.Where(element => element.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant() != SharedConstants.EmptyGuid))
{
// No. Add it to discourseElement, BUT in sorted order, below, and then flatten discourseElement.
// Restore the right main element name from the class attribute.
var classAttr = chartElement.Attribute(SharedConstants.Class);
chartElement.Name = classAttr.Value;
classAttr.Remove();
sortedCharts.Add(chartElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(), chartElement);
}
if (sortedCharts.Count > 0)
{
var discourseElementOwningProp = discourseElement.Element("Charts")
?? CmObjectFlatteningService.AddNewPropertyElement(discourseElement, "Charts");
foreach (var sortedChartElement in sortedCharts.Values)
{
discourseElementOwningProp.Add(sortedChartElement);
}
}
var langProjElement = highLevelData[SharedConstants.LangProject];
BaseDomainServices.RestoreElement(
chartPathname,
sortedData,
langProjElement,
"DiscourseData",
discourseElement);
}
internal static void NestContext(string linguisticsBaseDir,
IDictionary <string, XElement> wellUsedElements,
IDictionary <string, SortedDictionary <string, byte[]> > classData,
Dictionary <string, string> guidToClassMapping)
{
var morphAndSynDir = Path.Combine(linguisticsBaseDir, SharedConstants.MorphologyAndSyntax);
if (!Directory.Exists(morphAndSynDir))
{
Directory.CreateDirectory(morphAndSynDir);
}
var lexDb = wellUsedElements[SharedConstants.LexDb];
if (lexDb != null)
{
// Write out LexDb's "MorphTypes" list, as per AndyB (7 Feb 2012).
FileWriterService.WriteNestedListFileIfItExists(classData, guidToClassMapping,
lexDb, SharedConstants.MorphTypes,
Path.Combine(morphAndSynDir, SharedConstants.MorphTypesListFilename));
}
var langProjElement = wellUsedElements[SharedConstants.LangProject];
// 1. Nest: LP's MorphologicalData(MoMorphData OA) (Also does MoMorphData's ProdRestrict(CmPossibilityList)
// Remove objsur node from LP.
var morphologicalDataPropElement = langProjElement.Element("MorphologicalData");
morphologicalDataPropElement.RemoveNodes();
var morphDataElement = Utilities.CreateFromBytes(classData["MoMorphData"].Values.First());
CmObjectNestingService.NestObject(
false,
morphDataElement,
classData,
guidToClassMapping);
// Hold off writing it until its list is written.
// 2. Nest: LP's MsFeatureSystem(FsFeatureSystem OA)
// Remove objsur node from LP.
var morphFeatureSystemPropElement = langProjElement.Element("MsFeatureSystem");
var morphFeatureSystemElement = Utilities.CreateFromBytes(classData["FsFeatureSystem"][morphFeatureSystemPropElement.Element(SharedConstants.Objsur).Attribute(SharedConstants.GuidStr).Value]);
morphFeatureSystemPropElement.RemoveNodes();
CmObjectNestingService.NestObject(
false,
morphFeatureSystemElement,
classData,
guidToClassMapping);
FileWriterService.WriteNestedFile(Path.Combine(morphAndSynDir, SharedConstants.MorphAndSynFeaturesFilename), new XElement(SharedConstants.FeatureSystem, morphFeatureSystemElement));
// 3. Nest: LP's PartsOfSpeech(CmPossibilityList OA)
// Remove objsur node from LP.
FileWriterService.WriteNestedListFileIfItExists(classData, guidToClassMapping,
langProjElement, SharedConstants.PartsOfSpeech,
Path.Combine(morphAndSynDir, SharedConstants.PartsOfSpeechFilename));
// 4. Nest: LP's AnalyzingAgents(CmAgent OC) (use some new extension and a fixed name)
// Remove objsur node(s) from LP.
var agents = classData["CmAgent"];
var rootElement = new XElement(SharedConstants.AnalyzingAgents);
foreach (var agentGuid in BaseDomainServices.GetGuids(langProjElement, SharedConstants.AnalyzingAgents))
{
var agentElement = Utilities.CreateFromBytes(agents[agentGuid]);
rootElement.Add(agentElement);
CmObjectNestingService.NestObject(
false,
agentElement,
classData,
guidToClassMapping);
}
FileWriterService.WriteNestedFile(Path.Combine(morphAndSynDir, SharedConstants.AnalyzingAgentsFilename), rootElement);
langProjElement.Element(SharedConstants.AnalyzingAgents).RemoveNodes();
// A. Write: MoMorphData's ProdRestrict(CmPossibilityList OA) and write in its own .list file.
// Remove ProdRestrict node child in MoMorphData
var prodRestrictPropElement = morphDataElement.Element("ProdRestrict");
if (prodRestrictPropElement != null && prodRestrictPropElement.HasElements)
{
// NB: Write file, but only if morphDataElement has the list.
FileWriterService.WriteNestedFile(Path.Combine(morphAndSynDir, "ProdRestrict." + SharedConstants.List), prodRestrictPropElement);
prodRestrictPropElement.RemoveNodes();
}
// B. Write: LP's MorphologicalData(MoMorphData OA) in a new extension (morphdata)
FileWriterService.WriteNestedFile(Path.Combine(morphAndSynDir, SharedConstants.MorphAndSynDataFilename), new XElement(SharedConstants.MorphAndSynData, morphDataElement));
}
internal static void FlattenContext(
SortedDictionary <string, XElement> highLevelData,
SortedDictionary <string, XElement> sortedData,
string linguisticsBaseDir)
{
var morphAndSynDir = Path.Combine(linguisticsBaseDir, SharedConstants.MorphologyAndSyntax);
if (!Directory.Exists(morphAndSynDir))
{
return;
}
var langProjElement = highLevelData[SharedConstants.LangProject];
var lexDb = highLevelData[SharedConstants.LexDb];
var currentPathname = Path.Combine(morphAndSynDir, SharedConstants.MorphTypesListFilename);
if (lexDb != null && File.Exists(currentPathname))
{
// Restore MorphTypes list to LexDb.
var morphTypesDoc = XDocument.Load(currentPathname);
BaseDomainServices.RestoreElement(
currentPathname,
sortedData,
lexDb, SharedConstants.MorphTypes,
morphTypesDoc.Root.Element(SharedConstants.CmPossibilityList)); // Owned elment.
}
var langProjGuid = langProjElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant();
currentPathname = Path.Combine(morphAndSynDir, SharedConstants.MorphAndSynFeaturesFilename);
if (File.Exists(currentPathname))
{
var mAndSFeatSysDoc = XDocument.Load(currentPathname);
BaseDomainServices.RestoreElement(
currentPathname,
sortedData,
langProjElement, "MsFeatureSystem",
mAndSFeatSysDoc.Root.Element("FsFeatureSystem")); // Owned elment.
}
currentPathname = Path.Combine(morphAndSynDir, SharedConstants.PartsOfSpeechFilename);
if (File.Exists(currentPathname))
{
var posDoc = XDocument.Load(currentPathname);
BaseDomainServices.RestoreElement(
currentPathname,
sortedData,
langProjElement, SharedConstants.PartsOfSpeech,
posDoc.Root.Element(SharedConstants.CmPossibilityList)); // Owned elment.
}
currentPathname = Path.Combine(morphAndSynDir, SharedConstants.AnalyzingAgentsFilename);
// Put Agents back into LP.
var sortedAgents = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase);
var agentDoc = XDocument.Load(currentPathname);
foreach (var agentElement in agentDoc.Root.Elements())
{
CmObjectFlatteningService.FlattenOwnedObject(
currentPathname,
sortedData,
agentElement,
langProjGuid, sortedAgents); // Restore 'ownerguid' to agent.
}
// Restore LP AnalyzingAgents property in sorted order.
if (sortedAgents.Count > 0)
{
var langProjOwningProp = langProjElement.Element(SharedConstants.AnalyzingAgents);
foreach (var sortedTextObjSurElement in sortedAgents.Values)
{
langProjOwningProp.Add(sortedTextObjSurElement);
}
}
currentPathname = Path.Combine(morphAndSynDir, SharedConstants.MorphAndSynDataFilename);
if (File.Exists(currentPathname))
{
var mAndSDataDoc = XDocument.Load(currentPathname);
var morphDataElement = mAndSDataDoc.Root.Element("MoMorphData");
BaseDomainServices.RestoreElement(
currentPathname,
sortedData,
langProjElement,
"MorphologicalData",
morphDataElement);
currentPathname = Path.Combine(morphAndSynDir, "ProdRestrict." + SharedConstants.List);
if (File.Exists(currentPathname))
{
var prodRestrictDoc = XDocument.Load(currentPathname);
var prodRestrictListElement = prodRestrictDoc.Root.Element(SharedConstants.CmPossibilityList);
BaseDomainServices.RestoreElement(
currentPathname,
sortedData,
morphDataElement, "ProdRestrict", prodRestrictListElement);
}
}
}
private static void FlattenObjectCore(
string pathname,
SortedDictionary <string, XElement> sortedData,
XElement element, string ownerguid)
{
if (string.IsNullOrEmpty(pathname))
{
throw new ArgumentNullException("pathname");
}
if (sortedData == null)
{
throw new ArgumentNullException("sortedData");
}
if (element == null)
{
throw new ArgumentNullException("element");
}
// No, since unowned stuff will feed a null.
//if (string.IsNullOrEmpty(ownerguid)) throw new ArgumentNullException(SharedConstants.OwnerGuid);
if (ownerguid != null && ownerguid == string.Empty)
{
throw new ArgumentException(Resources.kOwnerGuidEmpty, SharedConstants.OwnerGuid);
}
string className;
bool isOwnSeqNode;
var elementGuid = CheckForDuplicateElementMethod.CheckForDuplicateGuid(pathname, sortedData, element, out isOwnSeqNode, out className);
sortedData.Add(elementGuid, element);
// The name of 'element' is the class of CmObject, or 'ownseq', or....
element.Name = SharedConstants.RtTag;
if (!isOwnSeqNode)
{
element.Add(new XAttribute(SharedConstants.Class, className));
}
//if (element.Attribute(SharedConstants.OwnerGuid) == null)
if (ownerguid != null) // && element.Attribute(SharedConstants.OwnerGuid) == null)
{
element.Add(new XAttribute(SharedConstants.OwnerGuid, ownerguid));
}
// Re-sort those attributes.
var sortedAttrs = new SortedDictionary <string, XAttribute>();
foreach (var attribute in element.Attributes())
{
sortedAttrs.Add(attribute.Name.LocalName, attribute);
}
element.Attributes().Remove();
element.Add(sortedAttrs.Values);
// Restore any ref seq props to have 'objsur' elements.
var mdc = MetadataCache.MdCache;
var propCache = mdc.PropertyCache[className];
var refSeqPropNames = propCache["AllReferenceSequence"];
// Restore any ref col props to have 'objsur' elements.
var refColPropNames = propCache["AllReferenceCollection"];
var owningPropsForClass = propCache["AllOwning"];
if (owningPropsForClass.Count == 0 && refSeqPropNames.Count == 0 && refColPropNames.Count == 0)
{
return; // Nothing special to be done for normal properties.
}
foreach (var propertyElement in element.Elements().ToArray())
{
var isCustomProperty = propertyElement.Name.LocalName == SharedConstants.Custom;
var propName = isCustomProperty ? propertyElement.Attribute(SharedConstants.Name).Value : propertyElement.Name.LocalName;
if (!owningPropsForClass.Contains(propName))
{
if (refSeqPropNames.Contains(propName))
{
foreach (var refSeqNode in propertyElement.Elements(SharedConstants.Refseq))
{
refSeqNode.Name = SharedConstants.Objsur;
}
}
else if (refColPropNames.Contains(propName))
{
foreach (var refColNode in propertyElement.Elements(SharedConstants.Refcol))
{
refColNode.Name = SharedConstants.Objsur;
}
}
continue;
}
if (!propertyElement.HasElements)
{
continue;
}
foreach (var ownedElement in propertyElement.Elements().ToArray())
{
if (ownedElement.Name.LocalName == SharedConstants.Objsur)
{
break;
}
// Do before the removal call, so we know the parent, and thus, the property name.
if (isCustomProperty)
{
var owningPropertyElement = (element.Elements().Where(customNode => customNode.Name.LocalName == SharedConstants.Custom && customNode.Attribute(SharedConstants.Name) != null && customNode.Attribute(SharedConstants.Name).Value == propertyElement.Attribute(SharedConstants.Name).Value)).First();
ownedElement.Remove();
FlattenObjectCore(pathname, sortedData, ownedElement, elementGuid); // BEFORE we make the objsur!
BaseDomainServices.RestoreObjsurElement(owningPropertyElement, ownedElement);
}
else
{
var propertyName = ownedElement.Parent.Name.LocalName;
ownedElement.Remove();
// Move down the nested set of owned objects, and do the same.
FlattenOwnedObject(pathname, sortedData, ownedElement, elementGuid, element, propertyName);
}
}
}
}
internal static void FlattenContext(
SortedDictionary <string, XElement> highLevelData,
SortedDictionary <string, XElement> sortedData,
string linguisticsBaseDir)
{
var textCorpusBaseDir = Path.Combine(linguisticsBaseDir, SharedConstants.TextCorpus);
if (!Directory.Exists(textCorpusBaseDir))
{
return;
}
var langProjElement = highLevelData[SharedConstants.LangProject];
var langProjGuid = langProjElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant();
// Put the Genre list back in the right place.
var pathname = Path.Combine(textCorpusBaseDir, SharedConstants.GenreListFilename);
var doc = XDocument.Load(pathname);
BaseDomainServices.RestoreElement(pathname, sortedData, langProjElement, SharedConstants.GenreList, doc.Root.Element(SharedConstants.CmPossibilityList));
// Put the markup tags list back in the right place.
pathname = Path.Combine(textCorpusBaseDir, SharedConstants.TextMarkupTagsListFilename);
doc = XDocument.Load(pathname);
BaseDomainServices.RestoreElement(pathname, sortedData, langProjElement, SharedConstants.TextMarkupTags, doc.Root.Element(SharedConstants.CmPossibilityList));
// Put the translation tags list back in the right place.
pathname = Path.Combine(textCorpusBaseDir, SharedConstants.TranslationTagsListFilename);
doc = XDocument.Load(pathname);
BaseDomainServices.RestoreElement(pathname, sortedData, langProjElement, SharedConstants.TranslationTags, doc.Root.Element(SharedConstants.CmPossibilityList));
if (MetadataCache.MdCache.ModelVersion < 7000059)
{
// Backwards compatible code.
// Put Texts back into LP.
var sortedTexts = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase);
foreach (var textPathname in Directory.GetFiles(textCorpusBaseDir, "*." + SharedConstants.TextInCorpus, SearchOption.TopDirectoryOnly))
{
var textDoc = XDocument.Load(textPathname);
// Put texts back into index's Entries element.
var root = textDoc.Root;
var textElement = root.Elements().First();
CmObjectFlatteningService.FlattenOwnedObject(
textPathname,
sortedData,
textElement,
langProjGuid, sortedTexts); // Restore 'ownerguid' to text.
}
// Restore LP Texts property in sorted order.
if (sortedTexts.Count == 0)
{
return;
}
var langProjOwningProp = langProjElement.Element("Texts");
foreach (var sortedTextObjSurElement in sortedTexts.Values)
{
langProjOwningProp.Add(sortedTextObjSurElement);
}
}
else
{
// Put Texts (all unowned now) all in 'sortedData'.
foreach (var textPathname in Directory.GetFiles(textCorpusBaseDir, "*." + SharedConstants.TextInCorpus, SearchOption.TopDirectoryOnly))
{
var textDoc = XDocument.Load(textPathname);
var root = textDoc.Root;
var textElement = root.Elements().First();
CmObjectFlatteningService.FlattenOwnerlessObject(
textPathname,
sortedData,
textElement);
}
}
}
internal static void RemoveBoundedContextData(string pathRoot)
{
BaseDomainServices.RemoveBoundedContextDataCore(Path.Combine(pathRoot, SharedConstants.Other));
}
