public void Test_can_resolve_meta_data_property_type(string propertyName, PropertyDataType expectedResult)
{
// Arrange
PropertyDataTypeResolver resolver = new PropertyDataTypeResolver(null);
// Act
bool successfullyResolvedProperty =
resolver.TryResolve(propertyName, out PropertyDataType resolvedPropertyDataType);
// Assert
successfullyResolvedProperty.Should().BeTrue();
resolvedPropertyDataType.ShouldBeEquivalentTo(expectedResult);
}
/// <summary>
/// Deserialize next object from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void ConsumeNext(FastTransferStream stream)
{
base.ConsumeNext(stream);
PropertyDataType type = (PropertyDataType)this.PropType;
switch (type)
{
case PropertyDataType.PtypInteger16:
this.fixedValue = stream.ReadInt16();
break;
case PropertyDataType.PtypInteger32:
this.fixedValue = stream.ReadInt32();
break;
case PropertyDataType.PtypFloating32:
this.fixedValue = stream.ReadFloating32();
break;
case PropertyDataType.PtypFloating64:
this.fixedValue = stream.ReadFloating64();
break;
case PropertyDataType.PtypCurrency:
this.fixedValue = stream.ReadCurrency();
break;
case PropertyDataType.PtypFloatingTime:
this.fixedValue = stream.ReadFloatingTime();
break;
case PropertyDataType.PtypBoolean:
this.fixedValue = stream.ReadBoolean();
break;
case PropertyDataType.PtypInteger64:
this.fixedValue = stream.ReadInt64();
break;
case PropertyDataType.PtypTime:
this.fixedValue = stream.ReadTime();
break;
case PropertyDataType.PtypGuid:
this.fixedValue = stream.ReadGuid();
break;
}
}
private IDictionary <long, PropertyDataType> BuildDataTypeMap(long[] dataTypeIds, IDictionary <long, ObjectContainer> idToObj)
{
var r = new Dictionary <long, PropertyDataType>();
foreach (var dataTypeId in dataTypeIds)
{
if (!idToObj.ContainsKey(dataTypeId))
{
throw new Exception("Unknown datatype object ID=" + dataTypeId.ToString());
}
var dataTypeObj = idToObj[dataTypeId];
var dataType = dataTypeObj[OwlConfig.SuperIdPropertyID] as string;
r[dataTypeId] = PropertyDataType.FindByID(dataType);
}
return(r);
}
public void WHEN_Passing_Known_PropertyName_SHOULD_Use_Known_Format(PropertyDataType dataType, string expectedFormatted)
{
//Arrange
ProductFormatter productFormatter = _container.CreateInstance <ProductFormatter>();
ProductPropertyDefinition ppd = new ProductPropertyDefinition
{
PropertyName = "KnownPropertyName",
DataType = dataType
};
object value = new object();
//Act
string formatted = productFormatter.FormatValue(ppd, value, GetRandomCulture());
//Assert
formatted.Should().BeEquivalentTo(expectedFormatted);
}
/// <summary>
/// 基本类型转换到PropertyDataType
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static PropertyDataType ToPropertyDataType(this System.Type type)
{
type.NullCheck("type");
PropertyDataType result = PropertyDataType.DataObject;
foreach (KeyValuePair <PropertyDataType, System.Type> kp in _DataTypeMappings)
{
if (kp.Value == type)
{
result = kp.Key;
break;
}
}
return(result);
}
public void Test_can_resolve_property_type()
{
// Arrange
const string propertyName = "TestProperty";
const PropertyDataType propertyDataType = PropertyDataType.Boolean;
ContentType contentType = new ContentType();
contentType.PropertyDefinitions.Add(new PropertyDefinition
{
Name = propertyName,
Type = new PropertyDefinitionType(1, propertyDataType, "Boolean")
});
PropertyDataTypeResolver resolver = new PropertyDataTypeResolver(contentType);
// Act
bool successfullyResolvedProperty =
resolver.TryResolve(propertyName, out PropertyDataType resolvedPropertyDataType);
// Assert
successfullyResolvedProperty.Should().BeTrue();
resolvedPropertyDataType.ShouldBeEquivalentTo(propertyDataType);
}
internal bool TryResolve(string propertyIdentifier, out PropertyDataType propertyDataType)
{
Debug.Assert(!string.IsNullOrWhiteSpace(propertyIdentifier));
propertyDataType = PropertyDataType.String;
if (MetaDataPropertyTypeMappings.ContainsKey(propertyIdentifier))
{
propertyDataType = MetaDataPropertyTypeMappings[propertyIdentifier];
return(true);
}
PropertyDefinition propDef = _contentType
.PropertyDefinitions
.SingleOrDefault(prop =>
prop.Name.Equals(propertyIdentifier, StringComparison.InvariantCultureIgnoreCase));
if (propDef != null)
{
propertyDataType = propDef.Type.DataType;
return(true);
}
return(false);
}
/// <summary>
/// Indicate whether a PropertyDataType is a multi-valued property type.
/// </summary>
/// <param name="type">A PropertyDataType.</param>
/// <returns>If the PropertyDataType is a multi-value type
/// return true, else false.</returns>
public static bool IsMVType(PropertyDataType type)
{
return(mvtypes.Contains(type));
}
private object CovertValueToRequiredDataType(string value,
PropertyDataType propertyDataType = PropertyDataType.String,
Type enumType = null,
string dateTimeFormat = null)
{
if (value == null || string.IsNullOrWhiteSpace(value))
{
return(null);
}
switch (propertyDataType)
{
case PropertyDataType.String:
return(value);
case PropertyDataType.Decimal:
if (Decimal.TryParse(value, out decimal decVal))
{
return(decVal);
}
else
{
return(null);
}
case PropertyDataType.Boolean:
if (bool.TryParse(value, out bool boolVal))
{
return(boolVal);
}
else
{
return(null);
}
case PropertyDataType.Time:
var format = dateTimeFormat ?? "MM/dd/yyyy-HH:mm:ss.FFF";
if (DateTime.TryParseExact(value, format, new CultureInfo("en-US"), DateTimeStyles.None, out DateTime datetimeVal))
{
return(datetimeVal);
}
else
{
return(null);
}
case PropertyDataType.Hexadecimal:
return(Convert.ToSByte(value, 16));
case PropertyDataType.Enum:
if (enumType != null)
{
if (NongenericEnumHelper.TryParse(enumType, value, true, out object enumValue))
{
return(enumValue);
}
else
{
return(null);
}
}
else
{
return(null);
}
default:
return(value);
}
}
/// <summary>
/// 试图转换成真实的类型
/// </summary>
/// <param name="pdt"></param>
/// <param name="type"></param>
/// <returns></returns>
public static bool TryToRealType(this PropertyDataType pdt, out Type type)
{
type = typeof(string);
return(_DataTypeMappings.TryGetValue(pdt, out type));
}
public PropertyDataTypeAttribute(PropertyDataType dataType)
{
this.DataType = dataType;
}
/// <summary>
/// Indicate whether a PropertyDataType is either PtypString, PtypString8 or PtypBinary, PtypServerId, or PtypObject.
/// </summary>
/// <param name="type">A PropertyDataType.</param>
/// <returns>If the PropertyDataType is a either PtypString, PtypString8 or PtypBinary, PtypServerId, or PtypObject return true, else false.</returns>
public static bool IsVarType(PropertyDataType type)
{
return VarTypes.Contains(type);
}
/// <summary>
/// Parse the AddressBookFlaggedPropertyValueWithType structure.
/// </summary>
/// <param name="s">An stream containing AddressBookFlaggedPropertyValueWithType structure.</param>
public override void Parse(Stream s)
{
base.Parse(s);
this.PropertyType = (PropertyDataType)ReadUshort();
this.Flag = ReadByte();
if (this.Flag != 0x01)
{
if (this.Flag == 0x00)
{
AddressBookPropertyValue addressPropValue = new AddressBookPropertyValue(PropertyType);
addressPropValue.Parse(s);
this.PropertyValue = addressPropValue;
}
else if (this.Flag == 0x0A)
{
AddressBookPropertyValue addressPropValueForErrorCode = new AddressBookPropertyValue(PropertyDataType.PtypErrorCode);
addressPropValueForErrorCode.Parse(s);
this.PropertyValue = addressPropValueForErrorCode;
}
}
}
/// <summary>
/// Parse the AddressBookTypedPropertyValue structure.
/// </summary>
/// <param name="s">An stream containing AddressBookTypedPropertyValue structure.</param>
public override void Parse(Stream s)
{
base.Parse(s);
this.PropertyType = (PropertyDataType)ReadUshort();
AddressBookPropertyValue addressBookPropValue = new AddressBookPropertyValue(this.PropertyType);
addressBookPropValue.Parse(s);
this.PropertyValue = addressBookPropValue;
}
private void SetGenericProperties(int patternIndex, object parsedValue, string name, PropertyDataType dataType, string format)
{
if (_currentObj == null)
{
return;
}
_currentObj.SetDynProperty("Name", name);
_currentObj.SetDynProperty("PatternIndex", patternIndex, PropertyDataType.Decimal);
_currentObj.SetDynProperty("DataType", dataType, PropertyDataType.Enum, format, typeof(PropertyDataType));
if (string.Equals(name, "Time", StringComparison.InvariantCultureIgnoreCase))
{
_currentObj.SetDynProperty("Time", parsedValue, PropertyDataType.Time, format);
}
}
public void WHEN_Passing_Unknown_PropertyName_For_Lookup_SHOULD_Format_Using_BasePropertyTypeKey(PropertyDataType dataType, string expectedFormatted)
{
//Arrange
ProductFormatter productFormatter = _container.CreateInstance <ProductFormatter>();
ProductPropertyDefinition ppd = new ProductPropertyDefinition
{
PropertyName = GetRandom.String(32),
DataType = dataType,
LookupDefinition = new ProductLookupDefinition
{
LookupName = GetRandom.String(32)
}
};
object value = new object();
//Act
string formatted = productFormatter.FormatValue(ppd, value, GetRandomCulture());
//Assert
formatted.Should().BeEquivalentTo(expectedFormatted);
}
public virtual PropertyMetadata GetMetadataForClaim(string type, string name = null, PropertyDataType dataType = PropertyDataType.String, bool required = false)
{
return(PropertyMetadata.FromFunctions(type, this.GetForClaim(type), this.SetForClaim(type), name, dataType, required));
}
internal static TBuilder SetDataTypeCore <TBuilder>(TBuilder builder, PropertyDataType dataType) where TBuilder : IAttributeBuilderInternal <TBuilder>
{
return(builder.AddOrReplaceAttribute(new DataTypeAttribute(ToDataType(dataType))));
}
/// <summary>
/// Indicate whether a PropertyDataType is a multi-valued property type.
/// </summary>
/// <param name="type">A PropertyDataType.</param>
/// <returns>If the PropertyDataType is a multi-value type
/// return true, else false.</returns>
public static bool IsMVType(PropertyDataType type)
{
return mvtypes.Contains(type);
}
/// <summary>
/// Indicate whether a property type value of any type that has a fixed length.
/// </summary>
/// <param name="type">A property type.</param>
/// <returns>If a property type value of any type that has a fixed length,
/// return true , else return false.
/// </returns>
public static bool IsFixedType(PropertyDataType type)
{
return(fixedTypes.Contains(type));
}
/// <summary>
/// Indicate whether a PropertyDataType is either
/// PtypString, PtypString8 or PtypBinary, PtypServerId, or PtypObject.
/// </summary>
/// <param name="type">A PropertyDataType.</param>
/// <returns>If the PropertyDataType is a either
/// PtypString, PtypString8 or PtypBinary, PtypServerId, or PtypObject
/// return true, else false.
/// </returns>
public static bool IsVarType(PropertyDataType type)
{
return(varTypes.Contains(type));
}
/// <summary>
/// Parse the TypedPropertyValue structure.
/// </summary>
/// <param name="s">A stream containing the TypedPropertyValue structure</param>
public override void Parse(Stream s)
{
base.Parse(s);
this.PropertyType = (PropertyDataType)ReadUshort();
PropertyValue propertyValue = new PropertyValue();
this.PropertyValue = propertyValue.ReadPropertyValue(this.PropertyType, s, countWide);
}
public static ClientPropertyDataType ToClientPropertyDataType(this PropertyDataType pdt)
{
return((ClientPropertyDataType)pdt);
}
public DataFieldDefine(PropertyDataType dataType)
{
this.LoadPropertiesFromDataType(dataType);
this._DataType = dataType;
}
private bool ValidateProfileDefinition(XElement profilePropDefinition, int lineNum, out string name, out PropertyDataType dataType, out string format)
{
dataType = PropertyDataType.String;
format = null;
name = null;
if (profilePropDefinition.Element("Name") == null)
{
AppLogger.LogLine("Invalid profile definition: missing element 'Name' of the property", lineNum);
return(false);
}
name = profilePropDefinition.Element("Name").Value;
if (string.IsNullOrWhiteSpace(name))
{
AppLogger.LogLine("Invalid profile definition: element 'Name' is null or empty", lineNum);
return(false);
}
if (profilePropDefinition.Element("DataType") == null)
{
AppLogger.LogLine(string.Format("Invalid profile definition: missing element '{0}' of property '{1}'", "DataType", name), lineNum);
return(false);
}
dataType = profilePropDefinition.Element("DataType").Value.ToEnum <PropertyDataType>();
format = dataType == PropertyDataType.Time ?
profilePropDefinition.Element("DataType").Attribute("Format").Value :
null;
return(true);
}
/// <summary>
/// The constructed function for AddressBookPropertyValue.
/// </summary>
/// <param name="propertyDataType">The PropertyDataType for this structure</param>
/// <param name="ptypMultiCountSize">The CountWideEnum for this structure</param>
public AddressBookPropertyValue(PropertyDataType propertyDataType, CountWideEnum ptypMultiCountSize = CountWideEnum.fourBytes)
{
this.propertyDataType = propertyDataType;
this.countWide = ptypMultiCountSize;
}
public PropertyMetadata GetMetadataForClaim(string type, string name = null, PropertyDataType dataType = PropertyDataType.String, bool required = false)
{
return(PropertyMetadata.FromFunctions <TUser, string>(type, GetForClaim(type), SetForClaim(type), name, dataType, required));
}
protected void SetPropertyDataType(PropertyDataType type)
{
_dataType = type;
}
protected DXDataTypeAttribute(Func <string> errorMessageAccessor, Func <string> defaultErrorMessageAccessor, PropertyDataType dataType)
: base(errorMessageAccessor, defaultErrorMessageAccessor)
{
this.DataType = dataType;
}
/// <summary>
/// Indicate whether a property type value of any type that has a fixed length.
/// </summary>
/// <param name="type">A property type.</param>
/// <returns>If a property type value of any type that has a fixed length, return true , else return false.</returns>
public static bool IsFixedType(PropertyDataType type)
{
return FixedTypes.Contains(type);
}
/// <summary>
/// The Constructor to set the Property data type and the Count wide size.
/// </summary>
/// <param name="propertyType">The Property data type.</param>
/// <param name="ptypMultiCountSize">The Count wide size.</param>
public FlaggedPropertyValue(PropertyDataType propertyType, CountWideEnum ptypMultiCountSize = CountWideEnum.twoBytes)
{
PropertyType = propertyType;
countWide = ptypMultiCountSize;
}
/// <summary>
/// Parse the PropertyTagWithGroupPropertyName structure.
/// </summary>
/// <param name="s">A stream containing the PropertyTagWithGroupPropertyName structure</param>
public void Parse(FastTransferStream stream)
{
this.PropertyType = (PropertyDataType)stream.ReadUInt16();
this.PropertyId = stream.ReadUInt16();
if (this.PropertyId >= 0x8000)
{
this.groupPropertyName = new GroupPropertyName();
this.groupPropertyName.Parse(stream);
}
}
/// <summary>
/// Initializes a new instance of the PropertyTag class with parameters.
/// </summary>
/// <param name="PType">The Type of the PropertyTag.</param>
/// /// <param name="PId">The Id of the PropertyTag.</param>
public PropertyTag(PropertyDataType PType, PidTagPropertyEnum PId)
{
this.PropertyType = PType;
this.PropertyId = PId;
}
static PropertyMetadataBuilder <T, TProperty> SetDataTypeCore <T, TProperty>(this PropertyMetadataBuilder <T, TProperty> builder, PropertyDataType dataType)
{
return(DataAnnotationsAttributeHelper.SetDataTypeCore(builder, dataType));
}
/// <summary>
/// The method to return the object of PropertyValue.
/// </summary>
/// <param name="dataType">The Property data type.</param>
/// <param name="s">A stream containing the PropertyValue structure</param>
/// <param name="ptypMultiCountSize">The Count wide size of ptypMutiple type.</param>
/// <returns>The object of PropertyValue.</returns>
public object ReadPropertyValue(PropertyDataType dataType, Stream s, CountWideEnum ptypMultiCountSize = CountWideEnum.twoBytes)
{
base.Parse(s);
object propertyValue;
switch (dataType)
{
case PropertyDataType.PtypInteger16:
{
PtypInteger16 tempPropertyValue = new PtypInteger16();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypInteger32:
{
PtypInteger32 tempPropertyValue = new PtypInteger32();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypFloating32:
{
PtypFloating32 tempPropertyValue = new PtypFloating32();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypFloating64:
{
PtypFloating64 tempPropertyValue = new PtypFloating64();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypCurrency:
{
PtypCurrency tempPropertyValue = new PtypCurrency();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypFloatingTime:
{
PtypFloatingTime tempPropertyValue = new PtypFloatingTime();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypErrorCode:
{
PtypErrorCode tempPropertyValue = new PtypErrorCode();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypBoolean:
{
PtypBoolean tempPropertyValue = new PtypBoolean();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypInteger64:
{
PtypInteger64 tempPropertyValue = new PtypInteger64();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypString:
{
PtypString tempPropertyValue = new PtypString();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypString8:
{
PtypString8 tempPropertyValue = new PtypString8();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypTime:
{
PtypTime tempPropertyValue = new PtypTime();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypGuid:
{
PtypGuid tempPropertyValue = new PtypGuid();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypServerId:
{
PtypServerId tempPropertyValue = new PtypServerId();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypRestriction:
{
PtypRestriction tempPropertyValue = new PtypRestriction();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypRuleAction:
{
PtypRuleAction tempPropertyValue = new PtypRuleAction();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypUnspecified:
{
PtypUnspecified tempPropertyValue = new PtypUnspecified();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypNull:
{
PtypNull tempPropertyValue = new PtypNull();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypBinary:
{
PtypBinary tempPropertyValue = new PtypBinary(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleInteger16:
{
PtypMultipleInteger16 tempPropertyValue = new PtypMultipleInteger16(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleInteger32:
{
PtypMultipleInteger32 tempPropertyValue = new PtypMultipleInteger32(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleFloating32:
{
PtypMultipleFloating32 tempPropertyValue = new PtypMultipleFloating32(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleFloating64:
{
PtypMultipleFloating64 tempPropertyValue = new PtypMultipleFloating64(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleCurrency:
{
PtypMultipleCurrency tempPropertyValue = new PtypMultipleCurrency(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleFloatingTime:
{
PtypMultipleFloatingTime tempPropertyValue = new PtypMultipleFloatingTime(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleInteger64:
{
PtypMultipleInteger64 tempPropertyValue = new PtypMultipleInteger64(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleString:
{
PtypMultipleString tempPropertyValue = new PtypMultipleString(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleString8:
{
PtypMultipleString8 tempPropertyValue = new PtypMultipleString8(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleTime:
{
PtypMultipleTime tempPropertyValue = new PtypMultipleTime(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleGuid:
{
PtypMultipleGuid tempPropertyValue = new PtypMultipleGuid(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypMultipleBinary:
{
PtypMultipleBinary tempPropertyValue = new PtypMultipleBinary(ptypMultiCountSize);
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
case PropertyDataType.PtypObject_Or_PtypEmbeddedTable:
{
PtypObject_Or_PtypEmbeddedTable tempPropertyValue = new PtypObject_Or_PtypEmbeddedTable();
tempPropertyValue.Parse(s);
propertyValue = tempPropertyValue;
break;
}
default:
propertyValue = null;
break;
}
return propertyValue;
}
/// <summary>
/// Creates a PropertyCriteria.
/// </summary>
/// <param name="condition">The condition for the comparison.</param>
/// <param name="name">The name of the property.</param>
/// <param name="dataType">Type of property data.</param>
/// <param name="value">The value to evalute the property against.</param>
/// <param name="required">If set to <c>true</c> the criteria is required, which makes it an AND search.</param>
/// <returns></returns>
public static PropertyCriteria CreateCriteria(CompareCondition condition, string name, PropertyDataType dataType, string value, bool required)
{
PropertyCriteria criteria = new PropertyCriteria();
criteria.Condition = condition;
criteria.Name = name;
criteria.Type = dataType;
criteria.Value = value;
criteria.Required = required;
return(criteria);
}
public PropertyDefinition(string name, PropertyDataType dataType, bool isRequired)
{
Name = name;
DataType = dataType;
IsRequired = isRequired;
}
public RegexAttributeBase(Regex regex, Func <string> errorMessageAccessor, Func <string> defaultErrorMessageAccessor, PropertyDataType dataType)
: base(errorMessageAccessor, defaultErrorMessageAccessor, dataType)
{
this.regex = regex;
}
public RegexAttributeBase(Regex regex, Func<string> errorMessageAccessor, Func<string> defaultErrorMessageAccessor, PropertyDataType dataType)
: base(errorMessageAccessor, defaultErrorMessageAccessor, dataType) {
this.regex = regex;
}
private IDataType GetDataType(PropertyDataType dataType)
{
return(_DataTypeService.GetDataType((int)dataType));
}
protected DXDataTypeAttribute(Func<string> errorMessageAccessor, Func<string> defaultErrorMessageAccessor, PropertyDataType dataType)
: base(errorMessageAccessor, defaultErrorMessageAccessor) {
this.DataType = dataType;
}
/// <summary>
/// Parse the FlaggedPropertyValueWithType structure.
/// </summary>
/// <param name="s">A stream containing the FlaggedPropertyValueWithType structure</param>
public override void Parse(Stream s)
{
base.Parse(s);
this.PropertyType = (PropertyDataType)ReadUshort();
this.Flag = ReadByte();
if (this.Flag == 0x00)
{
PropertyValue propertyValue = new PropertyValue();
this.PropertyValue = propertyValue.ReadPropertyValue(this.PropertyType, s, countWide);
}
else if (this.Flag == 0x0A)
{
PropertyValue propertyValue = new PropertyValue();
this.PropertyValue = propertyValue.ReadPropertyValue(PropertyDataType.PtypErrorCode, s, countWide);
}
else
{
this.PropertyValue = null;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyMatchExpression"/> class.
/// </summary>
/// <param name="xpathOrMacro">The xpath or macro for the property.</param>
/// <param name="dataType">The type of the data.</param>
public PropertyMatchExpression(string xpathOrMacro, PropertyDataType dataType)
{
this.XpathOrMacro = xpathOrMacro;
this.DataType = dataType;
}
/// <summary>
/// The Constructor to set the property type and Count wide size.
/// </summary>
/// <param name="ptypMultiCountSize">The Count wide size of ptypMutiple type.</param>
public PropertyValue(PropertyDataType ProType, CountWideEnum ptypMultiCountSize = CountWideEnum.twoBytes)
{
countWide = ptypMultiCountSize;
PropertyType = ProType;
}
public PsetProperty getPropertyDef(XNamespace ns, XElement pDef)
{
PsetProperty prop = new PsetProperty();
if (pDef.Attribute("ifdguid") != null)
{
prop.IfdGuid = pDef.Attribute("ifdguid").Value;
}
prop.Name = pDef.Element(ns + "Name").Value;
IList <NameAlias> aliases = new List <NameAlias>();
XElement nAliasesElem = pDef.Elements(ns + "NameAliases").FirstOrDefault();
if (nAliasesElem != null)
{
var nAliases = from el in nAliasesElem.Elements(ns + "NameAlias") select el;
foreach (XElement alias in nAliases)
{
NameAlias nameAlias = new NameAlias();
nameAlias.Alias = alias.Value;
nameAlias.lang = alias.Attribute("lang").Value;
aliases.Add(nameAlias);
}
}
if (aliases.Count > 0)
{
prop.NameAliases = aliases;
}
PropertyDataType dataTyp = null;
var propType = pDef.Elements(ns + "PropertyType").FirstOrDefault();
XElement propDetType = propType.Elements().FirstOrDefault();
if (propDetType == null)
{
#if DEBUG
logF.WriteLine("%Warning: Missing PropertyType for {0}.{1}", pDef.Parent.Parent.Element(ns + "Name").Value, prop.Name);
#endif
return(prop);
}
if (propDetType.Name.LocalName.Equals("TypePropertySingleValue"))
{
XElement dataType = propDetType.Element(ns + "DataType");
PropertySingleValue sv = new PropertySingleValue();
if (dataType.Attribute("type") != null)
{
sv.DataType = dataType.Attribute("type").Value;
}
else
{
sv.DataType = "IfcLabel"; // Set this to default if missing
#if DEBUG
logF.WriteLine("%Warning: Missing TypePropertySingleValue for {0}.{1}", pDef.Parent.Parent.Element(ns + "Name").Value, prop.Name);
#endif
}
dataTyp = sv;
}
else if (propDetType.Name.LocalName.Equals("TypePropertyReferenceValue"))
{
PropertyReferenceValue rv = new PropertyReferenceValue();
// Older versions uses Element DataType!
XElement dt = propDetType.Element(ns + "DataType");
if (dt == null)
{
rv.RefEntity = propDetType.Attribute("reftype").Value;
}
else
{
rv.RefEntity = dt.Attribute("type").Value;
}
dataTyp = rv;
}
else if (propDetType.Name.LocalName.Equals("TypePropertyEnumeratedValue"))
{
PropertyEnumeratedValue pev = new PropertyEnumeratedValue();
var enumItems = propDetType.Descendants(ns + "EnumItem");
if (enumItems.Count() > 0)
{
pev.Name = propDetType.Element(ns + "EnumList").Attribute("name").Value;
pev.EnumDef = new List <PropertyEnumItem>();
foreach (var en in enumItems)
{
string enumItemName = en.Value.ToString();
IEnumerable <XElement> consDef = null;
if (propDetType.Element(ns + "ConstantList") != null)
{
consDef = from el in propDetType.Element(ns + "ConstantList").Elements(ns + "ConstantDef")
where (el.Element(ns + "Name").Value.Equals(enumItemName, StringComparison.CurrentCultureIgnoreCase))
select el;
}
if (propDetType.Element(ns + "ConstantList") != null)
{
var consList = propDetType.Element(ns + "ConstantList").Elements(ns + "ConstantDef");
if (consList != null && consList.Count() != enumItems.Count())
{
#if DEBUG
logF.WriteLine("%Warning: EnumList (" + enumItems.Count().ToString() + ") is not consistent with the ConstantList ("
+ consList.Count().ToString() + ") for: {0}.{1}",
pDef.Parent.Parent.Element(ns + "Name").Value, prop.Name);
#endif
}
}
if (consDef != null && consDef.Count() > 0)
{
foreach (var cD in consDef)
{
PropertyEnumItem enumItem = new PropertyEnumItem();
enumItem.EnumItem = cD.Elements(ns + "Name").FirstOrDefault().Value;
enumItem.Aliases = new List <NameAlias>();
var eAliases = from el in cD.Elements(ns + "NameAliases").FirstOrDefault().Elements(ns + "NameAlias") select el;
if (eAliases.Count() > 0)
{
foreach (var aliasItem in eAliases)
{
NameAlias nal = new NameAlias();
nal.Alias = aliasItem.Value;
nal.lang = aliasItem.Attribute("lang").Value;
enumItem.Aliases.Add(nal);
}
}
pev.EnumDef.Add(enumItem);
}
}
else
{
PropertyEnumItem enumItem = new PropertyEnumItem();
enumItem.EnumItem = enumItemName;
enumItem.Aliases = new List <NameAlias>();
pev.EnumDef.Add(enumItem);
}
}
}
else
{
{
#if DEBUG
logF.WriteLine("%Warning: EnumList {0}.{1} is empty!", pDef.Parent.Parent.Element(ns + "Name").Value, prop.Name);
#endif
}
// If EnumList is empty, try to see whether ConstantDef has values. The Enum item name will be taken from the ConstantDef.Name
pev.Name = "PEnum_" + prop.Name;
pev.EnumDef = new List <PropertyEnumItem>();
var consDef = from el in propDetType.Element(ns + "ConstantList").Elements(ns + "ConstantDef")
select el;
if (consDef != null && consDef.Count() > 0)
{
foreach (var cD in consDef)
{
PropertyEnumItem enumItem = new PropertyEnumItem();
enumItem.EnumItem = cD.Elements(ns + "Name").FirstOrDefault().Value;
enumItem.Aliases = new List <NameAlias>();
var eAliases = from el in cD.Elements(ns + "NameAliases").FirstOrDefault().Elements(ns + "NameAlias") select el;
if (eAliases.Count() > 0)
{
foreach (var aliasItem in eAliases)
{
NameAlias nal = new NameAlias();
nal.Alias = aliasItem.Value;
nal.lang = aliasItem.Attribute("lang").Value;
enumItem.Aliases.Add(nal);
}
}
pev.EnumDef.Add(enumItem);
}
}
}
dataTyp = pev;
}
else if (propDetType.Name.LocalName.Equals("TypePropertyBoundedValue"))
{
XElement dataType = propDetType.Element(ns + "DataType");
PropertyBoundedValue bv = new PropertyBoundedValue();
bv.DataType = dataType.Attribute("type").Value;
dataTyp = bv;
}
else if (propDetType.Name.LocalName.Equals("TypePropertyListValue"))
{
XElement dataType = propDetType.Descendants(ns + "DataType").FirstOrDefault();
PropertyListValue lv = new PropertyListValue();
lv.DataType = dataType.Attribute("type").Value;
dataTyp = lv;
}
else if (propDetType.Name.LocalName.Equals("TypePropertyTableValue"))
{
PropertyTableValue tv = new PropertyTableValue();
var tve = propDetType.Element(ns + "Expression");
if (tve != null)
{
tv.Expression = tve.Value;
}
XElement el = propDetType.Element(ns + "DefiningValue");
if (el != null)
{
XElement el2 = propDetType.Element(ns + "DefiningValue").Element(ns + "DataType");
if (el2 != null)
{
tv.DefiningValueType = el2.Attribute("type").Value;
}
}
el = propDetType.Element(ns + "DefinedValue");
if (el != null)
{
XElement el2 = propDetType.Element(ns + "DefinedValue").Element(ns + "DataType");
if (el2 != null)
{
tv.DefinedValueType = el2.Attribute("type").Value;
}
}
dataTyp = tv;
}
else if (propDetType.Name.LocalName.Equals("TypeComplexProperty"))
{
ComplexProperty compProp = new ComplexProperty();
compProp.Name = propDetType.Attribute("name").Value;
compProp.Properties = new List <PsetProperty>();
foreach (XElement cpPropDef in propDetType.Elements(ns + "PropertyDef"))
{
PsetProperty pr = getPropertyDef(ns, cpPropDef);
if (pr == null)
{
#if DEBUG
logF.WriteLine("%Error: Mising PropertyType data in complex property {0}.{1}.{2}", propDetType.Parent.Parent.Element(ns + "Name").Value,
prop.Name, cpPropDef.Element(ns + "Name").Value);
#endif
}
else
{
compProp.Properties.Add(pr);
}
}
dataTyp = compProp;
}
prop.PropertyType = dataTyp;
return(prop);
}
/// <summary>
/// Parse the SortOrder structure.
/// </summary>
/// <param name="s">A stream containing the SortOrder structure</param>
public override void Parse(Stream s)
{
base.Parse(s);
this.PropertyType = (PropertyDataType)ReadUshort();
this.PropertyId = (PidTagPropertyEnum)ReadUshort();
this.Order = (OrderType)ReadByte();
}
/// <summary>
/// The constructed function for AddressBookFlaggedPropertyValue
/// </summary>
/// <param name="propertyDataType">The PropertyDataType parameter for AddressBookFlaggedPropertyValue</param>
public AddressBookFlaggedPropertyValue(PropertyDataType propertyDataType)
{
this.propertyDataType = propertyDataType;
}
public ValidatorParameter(string name, string paramValue, PropertyDataType dataType)
{
this._name = name;
this._paramValue = paramValue;
this._dataType = dataType;
}
public PropertyReference(string name, PropertyDataType propertyDataType)
{
if (name == null) throw new ArgumentNullException("name");
PropertyName = name;
Type = propertyDataType;
}