public void AddNewFieldDescriptionWithOldName()
{
// Setup test
var origName = "zCustom Field";
var newName = "zNew Custom Field User label";
CreateCustomFieldAndRelabel(origName, newName);
var firstFlid = m_mdc.GetFieldId2(1, origName, true);
var secondUserLabel = "unrelatedUserLabel";
var customField2 = new FieldDescription(Cache)
{
Class = 1,
Name = origName,
Userlabel = secondUserLabel,
Type = CellarPropertyType.String
};
// SUT
customField2.UpdateCustomField(); // should change Name slightly
// Verify
var newExpectedName = origName + "1";
var secondFlid = m_mdc.GetFieldId2(customField2.Class, newExpectedName, true);
Assert.AreNotEqual(0, secondFlid, "Field not, or incorrectly, installed.");
var actualNewName = m_mdc.GetFieldName(secondFlid);
Assert.AreEqual(newExpectedName, actualNewName,
string.Format("Field Name should be changed to {0}.", newExpectedName));
Assert.AreEqual(secondUserLabel, m_mdc.GetFieldLabel(secondFlid), "User label shouldn't change.");
// Cleanup
m_mdc.DeleteCustomField(firstFlid);
m_mdc.DeleteCustomField(secondFlid);
}
private static Dictionary <string, List <PropertyInfo> > CacheBasicProperties(IFwMetaDataCacheManaged mdc)
{
var cachedBasicProperties = new Dictionary <string, List <PropertyInfo> >();
foreach (var classId in mdc.GetClassIds())
{
var className = mdc.GetClassName(classId);
List <PropertyInfo> basicProps;
if (!cachedBasicProperties.TryGetValue(className, out basicProps))
{
basicProps = new List <PropertyInfo>();
cachedBasicProperties.Add(className, basicProps);
}
basicProps.AddRange(mdc.GetFields(classId, className != "CmObject", (int)CellarPropertyTypeFilter.AllBasic).Select(propId => new PropertyInfo
{
m_propertyName = mdc.GetFieldName(propId),
m_propertyType = (CellarPropertyType)mdc.GetFieldType(propId),
m_isCustom = mdc.IsCustom(propId),
m_isVirtual = mdc.get_IsVirtual(propId)
}));
if (basicProps.Count == 0)
{
cachedBasicProperties.Remove(className);
}
}
return(cachedBasicProperties);
}
private void m_btnAddCustom_Click(object sender, EventArgs e)
{
// What we'd like to do is the following bit of code, but we can't due to
// circular dependencies that would be introduced. We could possibly move
// the dialog to another assembly/dll, but that would require reworking a
// fair number of strings that have been converted to resources.
//using (var dlg = new AddCustomFieldDlg(m_mediator, AddCustomFieldDlg.LocationType.Notebook))
// dlg.ShowDialog();
System.Type typeFound;
MethodInfo mi = XmlUtils.GetStaticMethod("xWorks.dll",
"SIL.FieldWorks.XWorks.AddCustomFieldDlg",
"ShowNotebookCustomFieldDlg",
"AnthroFieldMappingDlg.m_btnAddCustom_Click()", out typeFound);
if (mi != null)
{
var parameters = new object[2];
parameters[0] = m_mediator;
parameters[1] = m_propertyTable;
mi.Invoke(typeFound,
System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public |
System.Reflection.BindingFlags.NonPublic, null, parameters, null);
// Now, clean up our map of possible field targets and reload the field combo list.
List <int> delFields = new List <int>();
foreach (int key in m_mapFlidName.Keys)
{
if (!m_mdc.FieldExists(key))
{
delFields.Add(key);
}
}
foreach (int flid in delFields)
{
m_mapFlidName.Remove(flid);
}
foreach (int flid in m_mdc.GetFields(RnGenericRecTags.kClassId, false, (int)CellarPropertyTypeFilter.All))
{
if (m_mapFlidName.ContainsKey(flid))
{
continue;
}
if (m_mdc.IsCustom(flid))
{
string name = m_mdc.GetFieldName(flid);
m_mapFlidName.Add(flid, name);
}
}
FillInFieldList();
}
else
{
}
}
/// <summary> Gets the name of a field. </summary>
/// <param name='luFlid'>Field identification number. In the database, this corresponds to the "Id"
/// column in the Field$ table. </param>
/// <returns>Points to the output name of the field. In the database, this
/// corresponds to the "Name" column in the Field$ table.</returns>
public virtual string GetFieldName(int luFlid)
{
return(m_metaDataCache.GetFieldName(luFlid));
}
private void ExportCustomFields(TextWriter writer, IRnGenericRec record)
{
ISilDataAccessManaged sda = m_cache.DomainDataByFlid as ISilDataAccessManaged;
Debug.Assert(sda != null);
foreach (int flid in m_customFlids)
{
string fieldName = m_mdc.GetFieldName(flid);
bool fHandled = false;
ITsString tss;
string s;
CellarPropertyType cpt = (CellarPropertyType)m_mdc.GetFieldType(flid);
switch (cpt)
{
case CellarPropertyType.Boolean:
break;
case CellarPropertyType.Integer:
break;
case CellarPropertyType.Numeric:
break;
case CellarPropertyType.Float:
break;
case CellarPropertyType.Time:
break;
case CellarPropertyType.Guid:
break;
case CellarPropertyType.Image:
case CellarPropertyType.Binary:
break;
case CellarPropertyType.GenDate:
break;
case CellarPropertyType.String:
tss = sda.get_StringProp(record.Hvo, flid);
if (tss != null && tss.Text != null)
{
ExportString(writer, tss, fieldName);
}
fHandled = true;
break;
case CellarPropertyType.MultiString:
case CellarPropertyType.MultiUnicode:
ITsMultiString tms = sda.get_MultiStringProp(record.Hvo, flid);
int cch = 0;
for (int i = 0; i < tms.StringCount; ++i)
{
int ws;
tss = tms.GetStringFromIndex(i, out ws);
cch += tss.Length;
if (cch > 0)
{
break;
}
}
if (cch > 0)
{
writer.WriteLine("<Field name=\"{0}\" type=\"MultiString\">", fieldName);
for (int i = 0; i < tms.StringCount; ++i)
{
int ws;
tss = tms.GetStringFromIndex(i, out ws);
if (tss != null && tss.Length > 0)
{
if (cpt == CellarPropertyType.MultiString)
{
writer.WriteLine(TsStringUtils.GetXmlRep(tss,
m_cache.WritingSystemFactory, ws, true));
}
else
{
writer.WriteLine("<AUni ws=\"{0}\">{1}</AUni>",
m_cache.WritingSystemFactory.GetStrFromWs(ws),
XmlUtils.MakeSafeXml(tss.Text));
}
}
}
writer.WriteLine("</Field>");
}
fHandled = true;
break;
case CellarPropertyType.Unicode:
break;
case CellarPropertyType.ReferenceAtomic:
case CellarPropertyType.ReferenceCollection:
case CellarPropertyType.ReferenceSequence:
{
int destClid = m_mdc.GetDstClsId(flid);
List <int> rghvoDest = new List <int>();
if (cpt == CellarPropertyType.ReferenceAtomic)
{
int hvo = sda.get_ObjectProp(record.Hvo, flid);
if (hvo != 0)
{
if (destClid == CmPossibilityTags.kClassId)
{
ICmPossibility poss = PossibilityRepository.GetObject(hvo);
ExportAtomicReference(writer, poss, fieldName, "CmPossibility");
fHandled = true;
}
else
{
rghvoDest.Add(hvo);
}
}
else
{
fHandled = true;
}
}
else
{
int[] hvos = sda.VecProp(record.Hvo, flid);
if (hvos.Length > 0)
{
if (destClid == CmPossibilityTags.kClassId)
{
List <ICmPossibility> collection = new List <ICmPossibility>();
foreach (int hvo in hvos)
{
collection.Add(PossibilityRepository.GetObject(hvo));
}
ExportReferenceList(writer, collection, fieldName, "CmPossibility", cpt);
fHandled = true;
}
else
{
rghvoDest.AddRange(hvos);
}
}
else
{
fHandled = true;
}
}
if (rghvoDest.Count > 0)
{
}
}
break;
case CellarPropertyType.OwningAtomic:
case CellarPropertyType.OwningCollection:
case CellarPropertyType.OwningSequence:
{
int destClid = m_mdc.GetDstClsId(flid);
List <int> rghvoDest = new List <int>();
if (cpt == CellarPropertyType.OwningAtomic)
{
int hvo = sda.get_ObjectProp(record.Hvo, flid);
if (hvo != 0)
{
if (destClid == StTextTags.kClassId)
{
IStText text = StTextRepository.GetObject(hvo);
ExportStText(writer, text, fieldName);
fHandled = true;
}
else
{
rghvoDest.Add(hvo);
}
}
else
{
fHandled = true;
}
}
else
{
}
}
break;
}
if (!fHandled)
{
}
}
}
/// <summary>
///
/// </summary>
/// <param name="output"></param>
/// <param name="labelName"></param>
/// <param name="fieldName"></param>
/// <param name="customFieldId"></param>
/// <param name="className"></param>
protected void ReplaceParamsInAttributes(XmlNode output, string labelName, string fieldName, int customFieldId, string className)
{
SetupWsParams(output, customFieldId);
ReplaceSubstringInAttr visitorFn = new ReplaceSubstringInAttr("$fieldName", fieldName);
XmlUtils.VisitAttributes(output, visitorFn);
AppendClassAttribute(output, fieldName, className);
ReplaceSubstringInAttr visitorLab = new ReplaceSubstringInAttr("$label", labelName);
XmlUtils.VisitAttributes(output, visitorLab);
if (customFieldId != 0 && m_mdc is IFwMetaDataCacheManaged)
{
IFwMetaDataCacheManaged mdc = m_mdc as IFwMetaDataCacheManaged;
if (mdc.IsCustom(customFieldId) && mdc.GetDstClsId(customFieldId) != 0)
{
Guid guidList = (m_mdc as IFwMetaDataCacheManaged).GetFieldListRoot(customFieldId);
if (guidList != Guid.Empty)
{
string targetList;
ICmPossibilityList list = m_cache.ServiceLocator.GetInstance <ICmPossibilityListRepository>().GetObject(guidList);
if (list.Owner != null)
{
targetList = String.Format("{0}.{1}", list.Owner.ClassName, mdc.GetFieldName(list.OwningFlid));
}
else
{
targetList = String.Format("unowned.{0}", guidList.ToString());
}
ReplaceSubstringInAttr visitorTarg = new ReplaceSubstringInAttr("$targetList", targetList);
XmlUtils.VisitAttributes(output, visitorTarg);
}
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Refresh the lv (list view) control based on the tv (tree view) control.
/// </summary>
/// ------------------------------------------------------------------------------------
public void AfterSelectMethod()
{
string holdType = "", holdSig = "";
int clid = (int)m_tvModel.SelectedNode.Tag;
// Get flids.
int[] uFlids = m_mdc.GetFields(clid, true, (int)CellarPropertyTypeFilter.All);
List <ListViewItem> list = new List <ListViewItem>();
for (int i = uFlids.Length - 1; i >= 0; --i)
{
int flid = uFlids[i];
if (flid == 0)
{
continue; // Keep looking for suitable flids lower in the array.
}
else
{
if (FDOBrowserForm.m_virtualFlag == false && (flid >= 20000000 && flid < 30000000))
{
continue;
}
else
{
string className = m_mdc.GetOwnClsName(flid);
ListViewItem lvi = new ListViewItem(className);
list.Add(lvi);
// flid
lvi.SubItems.Add(flid.ToString());
// field name
string fieldname = m_mdc.GetFieldName(flid);
lvi.SubItems.Add(fieldname);
int flidType = m_mdc.GetFieldType(flid);
string type = "Not recognized";
string signature = "Not recognized";
int dstClid;
switch (flidType)
{
// Basic data types.
case (int)CellarPropertyType.Boolean:
type = "Basic";
signature = "Boolean";
break;
case (int)CellarPropertyType.Integer:
type = "Basic";
signature = "Integer";
break;
case (int)CellarPropertyType.Numeric:
type = "Basic";
signature = "Numeric";
break;
case (int)CellarPropertyType.Float:
type = "Basic";
signature = "Float";
break;
case (int)CellarPropertyType.Time:
type = "Basic";
signature = "Time";
break;
case (int)CellarPropertyType.Guid:
type = "Basic";
signature = "Guid";
break;
case (int)CellarPropertyType.Image:
type = "Basic";
signature = "Image";
break;
case (int)CellarPropertyType.GenDate:
type = "Basic";
signature = "GenDate";
break;
case (int)CellarPropertyType.Binary:
type = "Basic";
signature = "Binary";
break;
case (int)CellarPropertyType.String:
type = "Basic";
signature = "String";
break;
case (int)CellarPropertyType.MultiString:
type = "Basic";
signature = "MultiString";
break;
case (int)CellarPropertyType.Unicode:
type = "Basic";
signature = "Unicode";
break;
case (int)CellarPropertyType.MultiUnicode:
type = "Basic";
signature = "MultiUnicode";
break;
// CmObjects.
case (int)CellarPropertyType.OwningAtomic:
type = "OA";
dstClid = m_mdc.GetDstClsId(flid);
signature = m_mdc.GetClassName(dstClid);
break;
case (int)CellarPropertyType.ReferenceAtomic:
type = "RA";
dstClid = m_mdc.GetDstClsId(flid);
signature = m_mdc.GetClassName(dstClid);
break;
case (int)CellarPropertyType.OwningCollection:
type = "OC";
dstClid = m_mdc.GetDstClsId(flid);
signature = m_mdc.GetClassName(dstClid);
break;
case (int)CellarPropertyType.ReferenceCollection:
type = "RC";
dstClid = m_mdc.GetDstClsId(flid);
signature = m_mdc.GetClassName(dstClid);
break;
case (int)CellarPropertyType.OwningSequence:
type = "OS";
dstClid = m_mdc.GetDstClsId(flid);
signature = m_mdc.GetClassName(dstClid);
break;
case (int)CellarPropertyType.ReferenceSequence:
type = "RS";
dstClid = m_mdc.GetDstClsId(flid);
signature = m_mdc.GetClassName(dstClid);
break;
}
if (flid >= 20000000 && flid < 30000000)
{
type += " (Virt)";
}
else if (flid > 10000000)
{
type += " (BackRef)";
}
lvi.SubItems.Add(type);
lvi.SubItems.Add(signature);
}
}
}
// Add custom fields
if (FDOBrowserForm.CFields != null && FDOBrowserForm.CFields.Count > 0)
{
foreach (CustomFields cf in FDOBrowserForm.CFields)
{
if (clid == cf.ClassID)
{
string clasName = m_mdc.GetClassName(cf.ClassID);
ListViewItem lv = new ListViewItem(clasName);
list.Add(lv);
// classname
//lv.SubItems.Add(clasName);
// flid
lv.SubItems.Add(cf.FieldID.ToString());
// field name
lv.SubItems.Add(cf.Name);
// Type
switch (cf.Type)
{
case "ICmPossibility":
holdType = "Custom - RA";
break;
case "FdoReferenceCollection<ICmPossibility>":
holdType = "Custom - RC";
break;
case "IStText":
holdType = "Custom - OA";
break;
default:
holdType = "Custom";
break;
}
lv.SubItems.Add(holdType);
// Signature
switch (cf.Type)
{
case "ITsString":
holdSig = "String";
break;
case "System.Int32":
holdSig = "Integer";
break;
case "SIL.FieldWorks.Common.FwUtils.GenDate":
holdSig = "GenDate";
break;
case "ICmPossibility":
holdSig = "CmPossibility";
break;
case "FdoReferenceCollection<ICmPossibility>":
holdSig = "CmPossibility";
break;
case "IStText":
holdSig = "StText";
break;
default:
MessageBox.Show(String.Format("Type not recognized for signature for custom model fields. Type: {0}", cf.Type));
break;
}
lv.SubItems.Add(holdSig);
}
}
}
LoadListView(list);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Handles the flids for basic data (bool, string, int, etc.)
/// </summary>
/// <param name="thisFlid">The object type flid.</param>
/// <param name="flidType">The owning flid type.</param>
/// <param name="hvoSrc">The hvo of the source object.</param>
/// <param name="hvoNew">The hvo of the new object.</param>
/// ------------------------------------------------------------------------------------
private void HandleBasicOrStringFlid(int thisFlid, int flidType, int hvoSrc, int hvoNew)
{
// Basic and String properties are copied
switch (flidType)
{
// Basic Properties follow
case (int)CellarPropertyType.Binary:
string flidName = m_mdc.GetFieldName(thisFlid);
if (flidName == "Rules" || flidName == "StyleRules")
{
CopyBinaryAsTextProps(thisFlid, hvoSrc, hvoNew);
}
else
{
CopyBinaryAsBinary(thisFlid, hvoSrc, hvoNew);
}
break;
case (int)CellarPropertyType.Boolean:
// Copy boolean value
m_sda.SetBoolean(hvoNew, thisFlid, m_sda.get_BooleanProp(hvoSrc, thisFlid));
break;
case (int)CellarPropertyType.Guid:
// Copy guid value
// These are currently used as the ID for an application, or a version number, or a Scripture Check ID)
m_sda.SetGuid(hvoNew, thisFlid, m_sda.get_GuidProp(hvoSrc, thisFlid));
break;
case (int)CellarPropertyType.GenDate: // Fall through, since a GenDate is an int.
case (int)CellarPropertyType.Integer:
// Copy integer value
m_sda.SetInt(hvoNew, thisFlid, m_sda.get_IntProp(hvoSrc, thisFlid));
break;
case (int)CellarPropertyType.Time:
// Copy time value
m_sda.SetTime(hvoNew, thisFlid, m_sda.get_TimeProp(hvoSrc, thisFlid));
break;
// String Properties follow
case (int)CellarPropertyType.String:
// Copy string value
// Review: Please check these next three!
m_sda.SetString(hvoNew, thisFlid, m_sda.get_StringProp(hvoSrc, thisFlid));
break;
case (int)CellarPropertyType.Unicode:
// Copy Unicode string
m_sda.set_UnicodeProp(hvoNew, thisFlid, m_sda.get_UnicodeProp(hvoSrc, thisFlid));
break;
case (int)CellarPropertyType.MultiString: // Fall through
case (int)CellarPropertyType.MultiUnicode:
ITsMultiString sMulti = m_sda.get_MultiStringProp(hvoSrc, thisFlid);
for (int i = 0; i < sMulti.StringCount; i++)
{
int ws;
ITsString tss = sMulti.GetStringFromIndex(i, out ws);
m_sda.SetMultiStringAlt(hvoNew, thisFlid, ws, tss);
}
break;
default:
throw new FDOInvalidFieldTypeException(String.Format("CopyObject: Unsupported field type {0}.", flidType));
}
}
/// <summary>
/// Return the LIFT range name for a given cmPossibilityList. Get the fieldName
/// of the owning field and use that to get the range name.
/// </summary>
/// <returns></returns>
public static string GetRangeNameForLiftExport(IFwMetaDataCacheManaged mdc, ICmPossibilityList list)
{
string rangeName = null;
if (list.OwningFlid == 0)
{
rangeName = list.Name.BestAnalysisVernacularAlternative.Text;
}
else
{
var fieldName = mdc.GetFieldName(list.OwningFlid);
rangeName = GetRangeName(fieldName);
}
return rangeName;
}
protected IDictionary <string, object> GetFieldValuesByName(LcmCache cache, ICmObject obj)
{
IFwMetaDataCacheManaged mdc = cache.ServiceLocator.MetaDataCache;
return(GetFieldValues(cache, obj).ToDictionary(kv => mdc.GetFieldName(kv.Key), kv => kv.Value));
}
private static Dictionary<string, List<PropertyInfo>> CacheBasicProperties(IFwMetaDataCacheManaged mdc)
{
var cachedBasicProperties = new Dictionary<string, List<PropertyInfo>>();
foreach (var classId in mdc.GetClassIds())
{
var className = mdc.GetClassName(classId);
List<PropertyInfo> basicProps;
if (!cachedBasicProperties.TryGetValue(className, out basicProps))
{
basicProps = new List<PropertyInfo>();
cachedBasicProperties.Add(className, basicProps);
}
basicProps.AddRange(mdc.GetFields(classId, className != "CmObject", (int)CellarPropertyTypeFilter.AllBasic).Select(propId => new PropertyInfo
{
m_propertyName = mdc.GetFieldName(propId),
m_propertyType = (CellarPropertyType)mdc.GetFieldType(propId),
m_isCustom = mdc.IsCustom(propId),
m_isVirtual = mdc.get_IsVirtual(propId)
}));
if (basicProps.Count == 0)
cachedBasicProperties.Remove(className);
}
return cachedBasicProperties;
}
private void VerifyCmPossibilityCustomFields(ILexEntry entry)
{
m_mdc = Cache.MetaDataCacheAccessor as IFwMetaDataCacheManaged;
var repo = Cache.ServiceLocator.GetInstance<ICmPossibilityListRepository>();
//Store mapping between Possibility List names and their guids. This is used to verify that
//the custom list has stored the correct guid for the list when imported.
m_customListNamesAndGuids.Add(RangeNames.sSemanticDomainListOA, Cache.LanguageProject.SemanticDomainListOA.Guid);
foreach (ICmPossibilityList list in repo.AllInstances())
{
if (list.OwningFlid == 0) //then it is a custom list
{
if (!m_customListNamesAndGuids.ContainsKey(list.Name.BestAnalysisVernacularAlternative.Text))
{
m_customListNamesAndGuids.Add(list.Name.BestAnalysisVernacularAlternative.Text, list.Guid);
}
}
}
//Verify each custom field
foreach (var flid in m_mdc.GetFields(entry.ClassID, true, (int)CellarPropertyTypeFilter.All))
{
if (!m_mdc.IsCustom(flid))
continue;
var fieldName = m_mdc.GetFieldName(flid);
if (fieldName == "CustomFld ListSingle")
{
VerifyCustomListToPossList(flid, CellarPropertyType.ReferenceAtomic, RangeNames.sSemanticDomainListOA);
}
else if (fieldName == "CustomFld ListMulti")
{
VerifyCustomListToPossList(flid, CellarPropertyType.ReferenceCollection, RangeNames.sSemanticDomainListOA);
}
else if (fieldName == "CustomFld CmPossibilityCustomList")
{
VerifyCustomListToPossList(flid, CellarPropertyType.ReferenceAtomic, "CustomCmPossibiltyList");
}
else if (fieldName == "CustomFld CustomList2")
{
VerifyCustomListToPossList(flid, CellarPropertyType.ReferenceAtomic, "CustomList Number2 ");
}
}
}