/// <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"?
}
}