/// <summary> /// Set custom field data for one field (specified by owner HVO and field ID). /// </summary> /// <returns><c>true</c>, if custom field data was set, <c>false</c> otherwise (e.g., if value hadn't changed, /// or value was null, or field type was one not implemented in LCM, such as CellarPropertyType.Float).</returns> /// <param name="hvo">HVO of object whose field we're setting.</param> /// <param name="flid">Field ID of custom field to set.</param> /// <param name="value">Field's new value (as returned by GetCustomFieldData).</param> /// <param name="guidOrGuids">GUID or guids associated with new value (as returned by GetCustomFieldData). /// May be null or BsonNull.Value if no GUIDs associated with this value.</param> public bool SetCustomFieldData(int hvo, int flid, BsonValue value, BsonValue guidOrGuids) { if ((value == null) || (value == BsonNull.Value) || ((value.BsonType == BsonType.Array) && (value.AsBsonArray.Count == 0))) { return(false); } List <Guid> fieldGuids = new List <Guid>(); if (guidOrGuids == null || guidOrGuids == BsonNull.Value) { // Leave fieldGuids as an empty list } else { if (guidOrGuids is BsonArray) { fieldGuids.AddRange(guidOrGuids.AsBsonArray.Select(bsonValue => ParseGuidOrDefault(bsonValue.AsString))); } else { fieldGuids.Add(ParseGuidOrDefault(guidOrGuids.AsString)); } } ISilDataAccessManaged data = (ISilDataAccessManaged)cache.DomainDataByFlid; CellarPropertyType fieldType = (CellarPropertyType)lcmMetaData.GetFieldType(flid); string fieldName = lcmMetaData.GetFieldNameOrNull(flid); // logger.Debug("Custom field named {0} has type {1}", fieldName, fieldType.ToString()); if (fieldName == null) { return(false); } // Valid field types in LCM are GenDate, Integer, String, OwningAtomic, ReferenceAtomic, and ReferenceCollection, so that's all we implement. switch (fieldType) { case CellarPropertyType.GenDate: { var valueAsMultiText = BsonSerializer.Deserialize <LfMultiText>(value.AsBsonDocument); string valueAsString = valueAsMultiText.BestString(new string[] { MagicStrings.LanguageCodeForGenDateFields }); if (string.IsNullOrEmpty(valueAsString)) { return(false); } GenDate valueAsGenDate; if (GenDate.TryParse(valueAsString, out valueAsGenDate)) { GenDate oldValue = data.get_GenDateProp(hvo, flid); if (oldValue == valueAsGenDate) { return(false); } else { data.SetGenDate(hvo, flid, valueAsGenDate); return(true); } } return(false); } case CellarPropertyType.Integer: { var valueAsMultiText = BsonSerializer.Deserialize <LfMultiText>(value.AsBsonDocument); string valueAsString = valueAsMultiText.BestString(new string[] { MagicStrings.LanguageCodeForIntFields }); if (string.IsNullOrEmpty(valueAsString)) { return(false); } int valueAsInt; if (int.TryParse(valueAsString, out valueAsInt)) { int oldValue = data.get_IntProp(hvo, flid); if (oldValue == valueAsInt) { return(false); } else { data.SetInt(hvo, flid, valueAsInt); return(true); } } return(false); } case CellarPropertyType.OwningAtomic: { // Custom field is a MultiparagraphText, which is an IStText object in LCM IStTextRepository textRepo = servLoc.GetInstance <IStTextRepository>(); Guid fieldGuid = fieldGuids.FirstOrDefault(); IStText text; if (!textRepo.TryGetObject(fieldGuid, out text)) { int currentFieldContentsHvo = data.get_ObjectProp(hvo, flid); if (currentFieldContentsHvo != LcmCache.kNullHvo) { text = (IStText)cache.GetAtomicPropObject(currentFieldContentsHvo); } else { // NOTE: I don't like the "magic" -2 number below, but LCM doesn't seem to have an enum for this. 2015-11 RM int newStTextHvo = data.MakeNewObject(cache.GetDestinationClass(flid), hvo, flid, -2); text = (IStText)cache.GetAtomicPropObject(newStTextHvo); } } // Shortcut: if text contents haven't changed, we don't want to change anything at all BsonValue currentLcmTextContents = ConvertUtilities.GetCustomStTextValues(text, flid, servLoc.WritingSystemManager, lcmMetaData, cache.DefaultUserWs); if ((currentLcmTextContents == BsonNull.Value || currentLcmTextContents == null) && (value == BsonNull.Value || value == null)) { return(false); } if (currentLcmTextContents != null && currentLcmTextContents.Equals(value)) { // No changes needed. return(false); } // BsonDocument passed in contains "paragraphs". ParseCustomStTextValuesFromBson wants only a "value" element // inside the doc, so we'll need to construct a new doc for the StTextValues. BsonDocument doc = value.AsBsonDocument; LfMultiParagraph multiPara = BsonSerializer.Deserialize <LfMultiParagraph>(doc); // Now we have another way to check for "old value and new value were the same": if the LCM multiparagraph was empty, // GetCustomStTextValues will have returned null -- so if this multiPara has no paragraphs, that's also an unchanged situation if ((multiPara.Paragraphs == null || multiPara.Paragraphs.Count <= 0) && (currentLcmTextContents == BsonNull.Value || currentLcmTextContents == null)) { return(false); } int wsId; if (multiPara.InputSystem == null) { wsId = lcmMetaData.GetFieldWs(flid); } else { wsId = servLoc.WritingSystemFactory.GetWsFromStr(multiPara.InputSystem); } ConvertUtilities.SetCustomStTextValues(text, multiPara.Paragraphs, wsId); return(true); } case CellarPropertyType.ReferenceAtomic: if (fieldGuids.FirstOrDefault() != Guid.Empty) { int referencedHvo = data.get_ObjFromGuid(fieldGuids.FirstOrDefault()); int oldHvo = data.get_ObjectProp(hvo, flid); if (referencedHvo == oldHvo) { return(false); } else { data.SetObjProp(hvo, flid, referencedHvo); // TODO: What if the value of the referenced object has changed in LanguageForge? (E.g., change that possibility's text from "foo" to "bar") // Need to implement that scenario. return(true); } } else { // It's a reference to an ICmPossibility instance: create a new entry in appropriate PossibilityList LfStringField valueAsLfStringField = BsonSerializer.Deserialize <LfStringField>(value.AsBsonDocument); string nameHierarchy = valueAsLfStringField.Value; if (nameHierarchy == null) { return(false); } int fieldWs = lcmMetaData.GetFieldWs(flid); // Oddly, this can return 0 for some custom fields. TODO: Find out why: that seems like it would be an error. if (fieldWs == 0) { fieldWs = cache.DefaultUserWs; // TODO: Investigate, because this should probably be wsEn instead so that we can create correct keys. } if (fieldWs < 0) { // FindOrCreatePossibility has a bug where it doesn't handle "magic" writing systems (e.g., -1 for default analysis, etc) and // throws an exception instead. So we need to get a real ws here. fieldWs = WritingSystemServices.ActualWs(cache, fieldWs, hvo, flid); } ICmPossibilityList parentList = GetParentListForField(flid); ICmPossibility newPoss = parentList.FindOrCreatePossibility(nameHierarchy, fieldWs); int oldHvo = data.get_ObjectProp(hvo, flid); if (newPoss.Hvo == oldHvo) { return(false); } else { data.SetObjProp(hvo, flid, newPoss.Hvo); return(true); } } case CellarPropertyType.ReferenceCollection: case CellarPropertyType.ReferenceSequence: { if (value == null || value == BsonNull.Value) { // Can't write null to a collection or sequence in LCM; it's forbidden. So data.SetObjProp(hvo, flid, LcmCache.kNullHvo) will not work. // Instead, we delete all items from the existing collection or sequence, and thus store an empty coll/seq in LCM. int oldSize = data.get_VecSize(hvo, flid); if (oldSize == 0) { // It was already empty, so leave it unchanged so we don't cause unnecessary changes in the .fwdata XML (and unnecessary Mercurial commits). return(false); } else { data.Replace(hvo, flid, 0, oldSize, null, 0); // This is how you set an empty array return(true); } } int fieldWs = lcmMetaData.GetFieldWs(flid); // TODO: Investigate why this is sometimes coming back as 0 instead of as a real writing system ID if (fieldWs == 0) { fieldWs = cache.DefaultUserWs; } ICmPossibilityList parentList = GetParentListForField(flid); LfStringArrayField valueAsStringArray = BsonSerializer.Deserialize <LfStringArrayField>(value.AsBsonDocument); // Step 1: Get ICmPossibility instances from the string keys that LF gave us // First go through all the GUIDs we have and match them up to the keys. If they match up, // then remove the keys from the list. Any remaining keys get looked up with FindOrCreatePossibility(), so now we // have a complete set of GUIDs (or ICmPossibility objects, which works out to the same thing). // TODO: This is all kind of ugly, and WAY too long for one screen. I could put it in its own function, // but there's really no real gain from that, as it simply moves the logic even further away from where // it needs to be. There's not really a *good* way to achieve simplicity with this code design, unfortunately. // The only thing that would be close to simple would be to call some functions from the LcmToMongo option list // converters, and that's pulling in code from the "wrong" direction, which has its own ugliness. Ugh. HashSet <string> keysFromLF = new HashSet <string>(valueAsStringArray.Values); var fieldObjs = new List <ICmPossibility>(); foreach (Guid guid in fieldGuids) { ICmPossibility poss; string key = ""; if (guid != default(Guid)) { poss = servLoc.GetInstance <ICmPossibilityRepository>().GetObject(guid); if (poss == null) { // TODO: Decide what to do with possibilities deleted from LCM key = ""; } else { if (poss.Abbreviation == null) { key = ""; } else { ITsString keyTss = poss.Abbreviation.get_String(wsEn); key = keyTss == null ? "" : keyTss.Text ?? ""; } fieldObjs.Add(poss); } } keysFromLF.Remove(key); // Ignoring return value (HashSet.Remove returns false if the key wasn't present), because false could mean one of two things: // 1. The CmPossibility had its English abbreviation changed in LCM, but LF doesn't know this yet. // If this is the case, the LF key won't match, but the GUID will still match. So we might end up creating // duplicate entries below with the FindOrCreatePossibility. TODO: Need to verify that LCM->LF possibility lists // get updated correctly if renames happen! (... Or use the OptionList converters, that's what they were for.) // 2. The CmPossibility was just created in LF and isn't in LCM yet. In which case we should have been using the // OptionList converters, which would hopefully have handled creating the ICmPossibility instane in LCM. // Either way, we can't really use that fact later, since we can't be certain if the possibility was renamed or created. } // Any remaining keysFromLF strings did not have corresponding GUIDs in Mongo. // This is most likely because they were added by LF, which doesn't write to the customFieldGuids field. // So we assume they exist in FW, and just look them up. foreach (string key in keysFromLF) { ICmPossibility poss = parentList.FindOrCreatePossibility(key, wsEn); // TODO: If this is a new possibility, then we need to populate it with ALL the corresponding data from LF, // which we don't necessarily have at this point. Need to make that a separate step in the Send/Receive: converting option lists first. fieldObjs.Add(poss); } // logger.Debug("Custom field {0} for CmObject {1}: BSON list was [{2}] and customFieldGuids was [{3}]. This was translated to keysFromLF = [{4}] and fieldObjs = [{5}]", // fieldName, // hvo, // String.Join(", ", valueAsStringArray.Values), // String.Join(", ", fieldGuids.Select(g => g.ToString())), // String.Join(", ", keysFromLF.AsEnumerable()), // String.Join(", ", fieldObjs.Select(poss => poss.AbbrAndName)) // ); // Step 2: Remove any objects from the "old" list that weren't in the "new" list // We have to look them up by HVO because that's the only public API available in LCM // Following logic inspired by XmlImportData.CopyCustomFieldData in FieldWorks source int[] oldHvosArray = data.VecProp(hvo, flid); int[] newHvosArray = fieldObjs.Select(poss => poss.Hvo).ToArray(); // Shortcut check if (oldHvosArray.SequenceEqual(newHvosArray)) { // Nothing to do, so return now so that we don't cause unnecessary changes and commits in Mercurial return(false); } HashSet <int> newHvos = new HashSet <int>(newHvosArray); HashSet <int> combinedHvos = new HashSet <int>(); // Loop backwards so deleting items won't mess up indices of subsequent deletions for (int idx = oldHvosArray.Length - 1; idx >= 0; idx--) { int oldHvo = oldHvosArray[idx]; if (newHvos.Contains(oldHvo)) { combinedHvos.Add(oldHvo); } else { data.Replace(hvo, flid, idx, idx + 1, null, 0); // Important to pass *both* null *and* 0 here to remove items } } // Step 3: Add any objects from the "new" list that weren't in the "old" list foreach (int newHvo in newHvosArray) { if (combinedHvos.Contains(newHvo)) { continue; } // This item was added in the new list data.Replace(hvo, flid, combinedHvos.Count, combinedHvos.Count, new int[] { newHvo }, 1); combinedHvos.Add(newHvo); } return(true); } case CellarPropertyType.String: { var valueAsMultiText = BsonSerializer.Deserialize <LfMultiText>(value.AsBsonDocument); int wsIdForField = lcmMetaData.GetFieldWs(flid); string wsStrForField = servLoc.WritingSystemFactory.GetStrFromWs(wsIdForField); KeyValuePair <string, string> kv = valueAsMultiText.BestStringAndWs(new string[] { wsStrForField }); string foundWs = kv.Key ?? string.Empty; string foundData = kv.Value ?? string.Empty; int foundWsId = servLoc.WritingSystemFactory.GetWsFromStr(foundWs); if (foundWsId == 0) { return(false); // Skip any unidentified writing systems } ITsString oldValue = data.get_StringProp(hvo, flid); ITsString newValue = ConvertMongoToLcmTsStrings.SpanStrToTsString(foundData, foundWsId, servLoc.WritingSystemFactory); if (oldValue != null && TsStringUtils.GetDiffsInTsStrings(oldValue, newValue) == null) // GetDiffsInTsStrings() returns null when there are no changes { return(false); } else { data.SetString(hvo, flid, newValue); return(true); } } default: return(false); // TODO: Maybe issue a proper warning (or error) log message for "field type not recognized"? } }
public static void SetCustomStTextValues(IStText lcmStText, IEnumerable <LfParagraph> lfParas, int wsId) { // Step 1: Delete all LCM paragraphs that are no longer found in LF var guidsInLf = new HashSet <Guid>(lfParas.Where(p => p.Guid != null).Select(p => p.Guid.Value)); var parasToDelete = new HashSet <IStTxtPara>(); for (int i = 0, count = lcmStText.ParagraphsOS.Count; i < count; i++) { IStTxtPara para = lcmStText[i]; if (!guidsInLf.Contains(para.Guid)) { parasToDelete.Add(para); } } foreach (IStTxtPara para in parasToDelete) { if (para.CanDelete) { para.Delete(); } } // Step 2: Step through LF and LCM paragraphs, adding new paragraphs as needed. // (We step through LCM paras *by integer index* so that inserting new paragraphs into LCM will place them in the right location) int lcmIdx = 0; foreach (LfParagraph lfPara in lfParas) { IStTxtPara lcmPara; if (lcmIdx >= lcmStText.ParagraphsOS.Count) { // Past the end of existing LCM paras: create new para at end lcmPara = lcmStText.AddNewTextPara(lfPara.StyleName); } else { lcmPara = lcmStText[lcmIdx]; if (lcmPara.Guid != lfPara.Guid) { // A new para was inserted into LF at this point; duplicate that in LCM lcmPara = lcmStText.InsertNewTextPara(lcmIdx, lfPara.StyleName); } } lcmPara.Contents = ConvertMongoToLcmTsStrings.SpanStrToTsString(lfPara.Content, wsId, lcmStText.Cache.WritingSystemFactory); // It turns out that LCM often has an empty StyleName for the normal, default paragraph style. So in those // cases, where we've gotten an empty StyleName in the LfParagraph object, we should NOT change it to be // the default paragraph style, as that can cause round-tripping problems. #if false if (String.IsNullOrEmpty(lfPara.StyleName)) { lfPara.StyleName = defaultParagraphStyle; // NOTE: The "defaultParagraphStyle" parameter has been removed } #endif if (!String.IsNullOrEmpty(lfPara.StyleName)) // Not allowed to set an empty style name on an LCM paragraph { lcmPara.StyleName = lfPara.StyleName; } lcmIdx++; } }