protected MFilesObject(int id, string name, string alias, MFDataType dataType = MFDataType.MFDatatypeUninitialized)
{
Id = id;
Name = name;
Alias = alias;
DataType = dataType;
}
public static SearchConditions AddPropertyCondition <T>(this SearchConditions search, object value, MFConditionType cType = MFConditionType.MFConditionTypeEqual)
where T : IMFPropertyDefinition
{
int pd_id = (int)typeof(T).GetField("id").GetRawConstantValue();
MFDataType data_type = (MFDataType)typeof(T).GetField("data_type").GetRawConstantValue();
if (value is IObjVerEx)
{
search.AddPropertyCondition(pd_id, cType, data_type, (value as IObjVerEx).objVerEx.ToLookup());
}
else if (value is IList)
{
Lookups lookups = new Lookups();
foreach (IObjVerEx objVerEx in (value as IList))
{
if (objVerEx == null)
{
break;
}
lookups.Add(-1, objVerEx.objVerEx.ToLookup());
}
search.AddPropertyCondition(pd_id, cType, data_type, lookups);
}
else
{
search.AddPropertyCondition(pd_id, cType, data_type, value);
}
return(search);
}
public void KnownPropertyDefReturnsCorrectData()
{
// Details about the property.
int propertyDefId = 1234;
MFDataType dataType = MFDataType.MFDatatypeText;
// Mock the property definition.
var mock = this.GetVaultPropertyDefOperationsMock();
mock
.Setup(m => m.GetPropertyDef(propertyDefId))
.Returns((int id) =>
{
var propertyDef = new PropertyDef()
{
ID = propertyDefId,
Name = "hello world",
DataType = MFDataType.MFDatatypeText
};
return(propertyDef);
});
// Run the method and check the output.
Assert.IsTrue(mock.Object.TryGetPropertyDefDataType(propertyDefId, out MFDataType output));
Assert.AreEqual(dataType, output);
}
public static PropertyValue ConvertObjectToLookup <T>(object id, MFDataType data_type, T objClass)
where T : IObjVerEx
{
if (null == objClass)
{
PropertyValue pv = new PropertyValue()
{
PropertyDef = (int)id
};
pv.TypedValue.SetValueToNULL(data_type);
return(pv);
}
Lookup lookup = new Lookup()
{
Item = objClass.objVerEx.ID,
ObjectType = objClass.objVerEx.Type
};
PropertyValue propVal = new PropertyValue();
propVal.TypedValue.SetValueToLookup(lookup);
propVal.PropertyDef = (int)id;
return(propVal);
}
/// <summary>
/// Attempts to get the <see cref="PropertyDef.DataType"/> of a <see cref="PropertyDef"/>
/// with the given <paramref name="propertyDefId"/>.
/// </summary>
/// <param name="propertyDefOperations">The <see cref="VaultPropertyDefOperations"/> instance to use to communicate with the vault.</param>
/// <param name="propertyDefId">The Id of the property definition to attempt to read.</param>
/// <param name="dataType">The data type of the property definition, or <see cref="MFDataType.MFDatatypeUninitialized"/> if not found.</param>
/// <returns>true if the property definition could be found, false otherwise.</returns>
public static bool TryGetPropertyDefDataType
(
this VaultPropertyDefOperations propertyDefOperations,
int propertyDefId,
out MFDataType dataType
)
{
// Sanity.
if (null == propertyDefOperations)
{
throw new ArgumentNullException(nameof(propertyDefOperations));
}
// Default.
dataType = MFDataType.MFDatatypeUninitialized;
// Attempt to get from the underlying data.
try
{
dataType = propertyDefOperations
.GetPropertyDef(propertyDefId)
.DataType;
return(true);
}
catch
{
return(false);
}
}
public SearchParameters AddPDNullCheck <T>(bool is_null = true)
where T : IMFPropertyDefinition
{
int pd_id = (int)typeof(T).GetField("id").GetRawConstantValue();
MFDataType data_type = (MFDataType)typeof(T).GetField("data_type").GetRawConstantValue();
return(this.AddPDNullCheck(pd_id, data_type, is_null));
}
/// <summary>
/// 一般属性
/// </summary>
/// <param name="propDef"></param>
/// <param name="dataType"></param>
/// <param name="value"></param>
/// <returns></returns>
public static PropertyValue Create(int propDef, MFDataType dataType, object value)
{
var p = new PropertyValue {
PropertyDef = propDef
};
SetValue(p.Value, dataType, value);
return(p);
}
public static SearchCondition propertyIsEmpty(int propertyID, MFDataType datatype)
{
SearchCondition hasProperty = new SearchCondition();
hasProperty.Expression.DataPropertyValuePropertyDef = propertyID;
hasProperty.ConditionType = MFConditionType.MFConditionTypeEqual;
hasProperty.TypedValue.SetValue(datatype, "");
return(hasProperty);
}
public static void Clear(this IObjVerEx obj, object prop, MFDataType data_type)
{
PropertyValue pv = new PropertyValue()
{
PropertyDef = (int)prop
};
pv.TypedValue.SetValueToNULL(data_type);
obj.objVerEx.SetProperty(pv);
}
/// <summary>
/// 对象属性搜索
/// </summary>
/// <param name="cType"></param>
/// <param name="propDef"></param>
/// <param name="dType"></param>
/// <param name="value"></param>
/// <returns></returns>
public static SearchCondition Property(MFConditionType cType,
int propDef, MFDataType dType, object value)
{
var sc = new SearchCondition();
sc.ConditionType = cType;
sc.Expression.DataPropertyValuePropertyDef = propDef;
MFPropertyUtils.SetValue(sc.TypedValue, dType, value);
return(sc);
}
/// <summary>
/// 对象状态搜索
/// </summary>
/// <param name="cType"></param>
/// <param name="sType"></param>
/// <param name="dType"></param>
/// <param name="value"></param>
/// <returns></returns>
public static SearchCondition Status(MFConditionType cType,
MFStatusType sType, MFDataType dType, object value)
{
var sc = new SearchCondition();
sc.ConditionType = cType;
sc.Expression.DataStatusValueType = sType;
MFPropertyUtils.SetValue(sc.TypedValue, dType, value);
return(sc);
}
public static void SetToNull(this IObjVerEx obj, int id, MFDataType data_type)
{
obj.RemoveCachedProperty(id);
PropertyValue pv = new PropertyValue()
{
PropertyDef = id
};
pv.TypedValue.SetValueToNULL(data_type);
obj.objVerEx.SetProperty(pv);
}
internal static void SetValue(TypedValue tv, MFDataType dataType, object value)
{
if (value == null)
{
tv.SetValueToNULL(dataType);
}
else
{
Validate(dataType, value);
tv.SetValue(dataType, value);
}
}
public static PropertyValue ConvertValueListToLookups <T>(object id, MFDataType data_type, List <T?> vList)
where T : struct
{
if (!typeof(T).IsEnum || vList == null)
{
PropertyValue pv = new PropertyValue()
{
PropertyDef = (int)id
};
pv.TypedValue.SetValueToNULL(data_type);
return(pv);
}
Lookups lookups = new Lookups();
foreach (T t in vList)
{
if (Equals(t, default(T)))
{
continue;
}
string value_list_name = typeof(T).Name.Replace("VL", "");
if (!string.IsNullOrEmpty(value_list_name) && !char.IsDigit(value_list_name[1]))
{
value_list_name = value_list_name.Substring(1, value_list_name.Length - 1);
}
int ObjectType = (int)Enum.Parse(typeof(VL_ValueLists), value_list_name, true);
Lookup lookup = new Lookup()
{
Item = Convert.ToInt32(t),
ObjectType = ObjectType
};
if (lookups.GetLookupIndexByItem(lookup.Item) == -1)
{
lookups.Add(-1, lookup);
}
}
PropertyValue propVal = new PropertyValue()
{
PropertyDef = (int)id
};
propVal.TypedValue.SetValueToMultiSelectLookup(lookups);
return(propVal);
}
public void SetValue(MFDataType DataType, object Value)
{
if (DataType == MFDataType.MFDatatypeText)
{
this.Value = Value;
return;
}
else if (DataType == MFDataType.MFDatatypeBoolean)
{
this.Value = Value;
return;
}
throw new NotImplementedException();
}
public SearchParameters AddPDNullCheck(int property_def, MFDataType dataType, bool is_null = true)
{
TypedValue value = new TypedValue();
value.SetValueToNULL(dataType);
SearchCondition search = new SearchCondition();
search.Expression.DataPropertyValuePropertyDef = property_def;
Expression exp = new Expression();
exp.SetPropertyValueExpression(property_def, MFParentChildBehavior.MFParentChildBehaviorNone);
search.ConditionType = is_null ? MFConditionType.MFConditionTypeEqual : MFConditionType.MFConditionTypeNotEqual;
search.Set(exp, search.ConditionType, value);
this.Conditions.Add(1, search);
return(this);
}
public PropertyValueInstruction
(
PropertyValueInstructionType instructionType,
int propertyDefId,
MFDataType dataType,
object value
)
{
this.InstructionType = instructionType;
var pv = new PropertyValue()
{
PropertyDef = propertyDefId
};
pv.TypedValue.SetValue(dataType, value);
this.PropertyValue = pv;
}
public static PropertyValue ConvertPropertyBoolValue(object id, MFDataType data_type, bool?value)
{
PropertyValue pv = new PropertyValue()
{
PropertyDef = (int)id
};
if (null == value)
{
pv.TypedValue.SetValueToNULL(data_type);
}
else
{
pv.TypedValue.SetValue(data_type, value);
}
return(pv);
}
public void AddValueToProperty_ThrowsForUnsupportedDataType
(
MFDataType dataType,
object initialValue,
object newValue
)
{
const int propertyDefId = 12345;
// Set up the instruction to add/update.
var instruction = new ObjectCopyOptions.PropertyValueInstruction()
{
InstructionType = ObjectCopyOptions.PropertyValueInstructionType.AddValueToProperty,
PropertyValue = new PropertyValue()
{
PropertyDef = propertyDefId
}
};
instruction.PropertyValue.TypedValue.SetValue
(
dataType,
newValue // Add the new value.
);
// Apply it.
var propertyValues = new PropertyValues();
{
var pv = new PropertyValue()
{
PropertyDef = propertyDefId
};
// Set the starting value the initial value.
pv.TypedValue.SetValue
(
dataType,
initialValue
);
propertyValues.Add(-1, pv);
}
instruction.ApplyTo(propertyValues);
}
private static string TypeDesc(MFDataType type)
{
switch (type)
{
case MFDataType.MFDatatypeBoolean:
return("布尔");
case MFDataType.MFDatatypeDate:
case MFDataType.MFDatatypeTime:
case MFDataType.MFDatatypeTimestamp:
return("日期");
case MFDataType.MFDatatypeFloating:
case MFDataType.MFDatatypeInteger:
case MFDataType.MFDatatypeInteger64:
return("数字");
}
return("字符串");
}
public void SearchConditionIsCorrect
(
int propertyDef,
long?input,
MFDataType dataType,
MFConditionType conditionType,
MFParentChildBehavior parentChildBehavior,
PropertyDefOrObjectTypes indirectionLevels
)
{
base.AssertSearchConditionIsCorrect
(
propertyDef,
dataType,
input,
conditionType,
parentChildBehavior,
indirectionLevels
);
}
public static PropertyValue ConvertObjectToLookups <T>(object id, MFDataType data_type, List <T> objClass)
where T : IObjVerEx
{
if (null == objClass)
{
PropertyValue pv = new PropertyValue()
{
PropertyDef = (int)id
};
pv.TypedValue.SetValueToNULL(data_type);
return(pv);
}
Lookups lookups = new Lookups();
foreach (T t in objClass)
{
if (null == t)
{
continue;
}
Lookup lookup = new Lookup()
{
Item = t.objVerEx.ID,
ObjectType = t.objVerEx.Type
};
if (lookups.GetLookupIndexByItem(lookup.Item) == -1)
{
lookups.Add(-1, lookup);
}
}
PropertyValue propVal = new PropertyValue();
propVal.TypedValue.SetValueToMultiSelectLookup(lookups);
propVal.PropertyDef = (int)id;
return(propVal);
}
private static SqlDbType MapType(MFDataType mfDataType)
{
switch (mfDataType)
{
case MFDataType.MFDatatypeMultiLineText:
case MFDataType.MFDatatypeText:
return(SqlDbType.NVarChar);
case MFDataType.MFDatatypeInteger:
return(SqlDbType.Int);
case MFDataType.MFDatatypeInteger64:
return(SqlDbType.BigInt);
case MFDataType.MFDatatypeFloating:
return(SqlDbType.Float);
case MFDataType.MFDatatypeDate:
case MFDataType.MFDatatypeTime:
case MFDataType.MFDatatypeTimestamp:
case MFDataType.MFDatatypeFILETIME:
return(SqlDbType.DateTime);
case MFDataType.MFDatatypeBoolean:
return(SqlDbType.Bit);
case MFDataType.MFDatatypeLookup:
return(SqlDbType.Int);
case MFDataType.MFDatatypeMultiSelectLookup:
case MFDataType.MFDatatypeUninitialized:
case MFDataType.MFDatatypeACL:
default:
return(SqlDbType.NVarChar);
}
}
public static PropertyValue ConvertValueListToLookup <T>(object id, MFDataType data_type, T?vList)
where T : struct
{
if (!typeof(T).IsEnum || null == vList)
{
PropertyValue pv = new PropertyValue()
{
PropertyDef = (int)id
};
pv.TypedValue.SetValueToNULL(data_type);
return(pv);
}
string value_list_name = typeof(T).Name?.Replace("VL", "");
if (!string.IsNullOrEmpty(value_list_name) && !char.IsDigit(value_list_name[1]))
{
value_list_name = value_list_name.Substring(1, value_list_name.Length - 1);
}
int ObjectType = (int)Enum.Parse(typeof(VL_ValueLists), value_list_name, true);
Lookup lookup = new Lookup()
{
Item = Convert.ToInt32(vList),
ObjectType = ObjectType
};
PropertyValue propVal = new PropertyValue()
{
PropertyDef = (int)id
};
propVal.TypedValue.SetValueToLookup(lookup);
return(propVal);
}
private PropertyValue GetPropertyValue(int propertyDef, MFDataType dataType, object value)
{
var propertyValue = new PropertyValue();
propertyValue.PropertyDef = propertyDef;
try { propertyValue.TypedValue.SetValue(dataType, value); }
catch (Exception ex)
{
throw new ArgumentException(
string.Format("propertyValue.TypedValue.SetValue() failed with parameters: propertyDefId: {0}, dataType: {1}, value: {2}",
propertyDef, dataType, value), ex);
}
return propertyValue;
}
internal static void Validate(MFDataType dType, object value)
{
System.Diagnostics.Debug.Assert(value != null);
switch (dType)
{
case MFDataType.MFDatatypeACL:
case MFDataType.MFDatatypeInteger:
case MFDataType.MFDatatypeLookup:
if (value is Int32)
{
return;
}
break;
case MFDataType.MFDatatypeBoolean:
if (value is Boolean)
{
return;
}
break;
case MFDataType.MFDatatypeDate:
case MFDataType.MFDatatypeFILETIME:
case MFDataType.MFDatatypeTime:
case MFDataType.MFDatatypeTimestamp:
if (value is DateTime)
{
return;
}
break;
case MFDataType.MFDatatypeFloating:
if (value is Single || value is Double || value is Int32)
{
return;
}
break;
case MFDataType.MFDatatypeInteger64:
if ((value is Int64) || (value is Int32))
{
return;
}
break;
case MFDataType.MFDatatypeText:
case MFDataType.MFDatatypeMultiLineText:
if (value is String)
{
return;
}
break;
case MFDataType.MFDatatypeMultiSelectLookup:
if (value is Int32 || value is Int32[])
{
return;
}
break;
case MFDataType.MFDatatypeUninitialized:
break;
}
throw new ArgumentException(string.Format(
"数据类型({0})与值给出的类型({1})不匹配", dType.ToString(), value.GetType()));
}
public void SetValueToNULL(MFDataType DataType)
{
throw new NotImplementedException();
}
public static void SetPropertyFrom(this IObjVerEx obj, IObjVerEx source_obj, int property_id, MFDataType property_datatype)
{
if (source_obj.objVerEx.HasProperty(property_id))
{
obj.RemoveCachedProperty(property_id);
if (source_obj.IsNull(property_id))
{
obj.SetToNull(property_id, property_datatype);
}
else
{
obj.objVerEx.SetProperty(source_obj.objVerEx.GetProperty(property_id));
}
}
}
public List <ObjVerEx> FindObjects(Vault vault, MFIdentifier ClassAlias, MFIdentifier PDAlias, MFDataType PDType, String findValue)
{
// Create our search builder.
var searchBuilder = new MFSearchBuilder(vault);
// Add an object type filter.
searchBuilder.Class(ClassAlias);
// Add a "not deleted" filter.
searchBuilder.Deleted(false);
List <ObjVerEx> searchResults;
searchBuilder.Property(PDAlias, PDType, findValue);
searchResults = searchBuilder.FindEx();
return((searchResults.Count != 0) ? searchResults : null);
}
private int LookupRef(Vault vault, int ObjectID, MFDataType DataType, bool SearchLookupID, object value, LookupOrValuelistStrategy searchType = LookupOrValuelistStrategy.SearchLookup)
{
// Create list of search conditions.
var oSCs = new MFilesAPI.SearchConditions();
// Create single search condition.
var oSC = new MFilesAPI.SearchCondition();
// =================================================================================
// Filter not deleted
if (searchType == LookupOrValuelistStrategy.SearchLookup)
{
oSC.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeDeleted);
}
else
{
oSC.Expression.SetValueListItemExpression(MFValueListItemPropertyDef.MFValueListItemPropertyDefDeleted,
MFParentChildBehavior.MFParentChildBehaviorNone);
}
oSC.ConditionType = MFConditionType.MFConditionTypeEqual;
oSC.TypedValue.SetValue(MFDataType.MFDatatypeBoolean, false);
oSCs.Add(-1, oSC);
// =================================================================================
// Filter if it's object only objects
if (searchType == LookupOrValuelistStrategy.SearchLookup)
{
oSC.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeObjectTypeID);
oSC.ConditionType = MFConditionType.MFConditionTypeEqual;
oSC.TypedValue.SetValue(DataType, ObjectID);
oSCs.Add(-1, oSC);
}
// =================================================================================
// Filter Search by ID or name Value
if (SearchLookupID)
{
oSC.Expression.DataStatusValueType = MFStatusType.MFStatusTypeExtID;
oSC.ConditionType = MFConditionType.MFConditionTypeEqual;
oSC.TypedValue.SetValue(MFDataType.MFDatatypeText, value);
oSCs.Add(-1, oSC);
}
else
{
if (searchType == LookupOrValuelistStrategy.SearchLookup)
{
// object value search syntax
oSC.Expression.SetPropertyValueExpression((int)MFBuiltInPropertyDef.MFBuiltInPropertyDefNameOrTitle, MFParentChildBehavior.MFParentChildBehaviorNone);
oSC.ConditionType = MFConditionType.MFConditionTypeEqual;
oSC.TypedValue.SetValue(MFDataType.MFDatatypeText, value);
oSCs.Add(-1, oSC);
}
else
{
// valuelist value search syntax
oSC.Expression.SetValueListItemExpression(MFValueListItemPropertyDef.MFValueListItemPropertyDefName, MFParentChildBehavior.MFParentChildBehaviorNone);
oSC.ConditionType = MFConditionType.MFConditionTypeEqual;
oSC.TypedValue.SetValue(MFDataType.MFDatatypeText, value);
oSCs.Add(-1, oSC);
}
}
// execute the final search
if (searchType == LookupOrValuelistStrategy.SearchLookup)
{
var oResult = vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(oSCs, MFSearchFlags.MFSearchFlagNone, false);
if (oResult.Count == 0)
{
return(-1);
}
else
{
return(oResult[1].ObjVer.ObjID.ID);
}
}
else
{
var vlResult = vault.ValueListItemOperations.SearchForValueListItemsEx(ObjectID, oSCs, false);
if (vlResult.Count == 0)
{
return(-1);
}
else
{
return(vlResult[1].ObjID.ID);
}
}
}
/// <summary>
/// search condition of whether the property has the specified value
/// </summary>
/// <param name="propertyID">property to look for</param>
/// <param name="propertyValue">value of property</param>
/// <returns>search condition</returns>
public static SearchCondition hasProperty(int propertyID, string propertyValue, MFDataType type)
{
SearchCondition hasProp = new SearchCondition();
hasProp.Expression.SetPropertyValueExpression(propertyID, MFParentChildBehavior.MFParentChildBehaviorNone);
hasProp.ConditionType = MFConditionType.MFConditionTypeEqual;
hasProp.TypedValue.SetValue(type, propertyValue);
return(hasProp);
}
