public static TriggerBaseNode CreateTrigger(TriggerSourceInformation triggerSource, SceneViewModel viewModel)
{
RoutedEventInformation eventInformation = triggerSource as RoutedEventInformation;
PropertyInformation propertyInformation = triggerSource as PropertyInformation;
if ((TriggerSourceInformation)eventInformation != (TriggerSourceInformation)null)
{
EventTriggerNode eventTriggerNode = EventTriggerNode.Factory.Instantiate(viewModel);
eventTriggerNode.RoutedEvent = eventInformation.RoutedEvent;
return((TriggerBaseNode)eventTriggerNode);
}
if (!((TriggerSourceInformation)propertyInformation != (TriggerSourceInformation)null))
{
return((TriggerBaseNode)null);
}
TriggerNode triggerNode = (TriggerNode)null;
DependencyProperty dependencyProperty = propertyInformation.DependencyProperty;
if (dependencyProperty != null)
{
triggerNode = TriggerNode.Factory.Instantiate(viewModel);
ITriggerConditionNode triggerConditionNode = (ITriggerConditionNode)triggerNode;
triggerConditionNode.PropertyKey = dependencyProperty;
triggerConditionNode.Value = dependencyProperty.DefaultMetadata.DefaultValue;
}
return((TriggerBaseNode)triggerNode);
}
public static TriggerBaseNode FindOrCreateTrigger(TriggerSourceInformation triggerSource, ITriggerContainer triggerContainer, SceneViewModel viewModel)
{
RoutedEventInformation eventInformation = triggerSource as RoutedEventInformation;
PropertyInformation propertyInformation = triggerSource as PropertyInformation;
foreach (TriggerBaseNode triggerBaseNode in (IEnumerable <TriggerBaseNode>)triggerContainer.VisualTriggers)
{
EventTriggerNode eventTriggerNode = triggerBaseNode as EventTriggerNode;
TriggerNode triggerNode = triggerBaseNode as TriggerNode;
if (eventTriggerNode != null && (TriggerSourceInformation)eventInformation != (TriggerSourceInformation)null && eventTriggerNode.RoutedEvent == eventInformation.RoutedEvent)
{
return((TriggerBaseNode)eventTriggerNode);
}
if (triggerNode != null && (TriggerSourceInformation)propertyInformation != (TriggerSourceInformation)null && ((ITriggerConditionNode)triggerNode).PropertyKey == propertyInformation.DependencyProperty)
{
return((TriggerBaseNode)triggerNode);
}
}
TriggerBaseNode trigger = TriggersHelper.CreateTrigger(triggerSource, viewModel);
if (trigger != null)
{
triggerContainer.VisualTriggers.Add(trigger);
}
return(trigger);
}
private void InsertInPropertOrder(PropertyInformation property)
{
if (this.Properties.Count == 0)
{
this.Properties.Add(property);
return;
}
if (this.PropertiesAreInOrder(property, this.Properties[0]))
{
this.Properties.Insert(0, property);
return;
}
for (var i = 0; i < this.Properties.Count - 1; i++)
{
if (this.PropertiesAreInOrder(this.Properties[i], property) && this.PropertiesAreInOrder(property, this.Properties[i + 1]))
{
this.Properties.Insert(i + 1, property);
return;
}
}
this.Properties.Add(property);
}
/// <summary>
/// Generate a randerable section for the given property information.
/// </summary>
/// <typeparam name="TValue">Property value type.</typeparam>
/// <param name="builder">Render tree.</param>
private void GenerateRenderTreeForInputField <TValue>(RenderTreeBuilder builder)
{
var componentType = GetComponentTypeToRenderForValueType <TValue>();
if (componentType == default)
{
GenerateRenderTreeForChildInputFields <TValue>(builder);
return;
}
var constant = Expression.Constant(CascadedEditContext.Model, CascadedEditContext.Model.GetType());
var exp = Expression.Property(constant, PropertyInformation.Name);
var lambda = Expression.Lambda(exp);
var castedLambda = (Expression <Func <TValue> >)lambda;
var currentValue = (TValue)PropertyInformation.GetValue(CascadedEditContext.Model);
builder.OpenComponent(0, componentType);
builder.AddAttribute(1, "id", PropertyInformation.Name);
builder.AddAttribute(2, nameof(InputBase <TValue> .Value), currentValue);
builder.AddAttribute(3, nameof(InputBase <TValue> .ValueExpression), castedLambda);
builder.AddAttribute(4, nameof(InputBase <TValue> .ValueChanged), RuntimeHelpers.TypeCheck(
EventCallback.Factory.Create(
this,
EventCallback.Factory.CreateInferred(this, val => PropertyInformation.SetValue(CascadedEditContext.Model, val),
(TValue)PropertyInformation.GetValue(CascadedEditContext.Model)))));
builder.CloseComponent();
}
public void GetTypeInformation_WhenListDatasetsThenDatasetPropertyDescriptionsShouldBeReturned()
{
// Act
IEnumerable <TypeInformation> result = WhenTypeInformationForTheAssemblyIsCreated(GetCalculationClassWithListDescriptionsExampleAssembly());
// Assert
result.Should().NotBeNull("Result should not be null");
result.Should().ContainSingle(c => c.Name == "Calculations");
TypeInformation datasetType = result.Where(e => e.Name == "Datasets").FirstOrDefault();
datasetType.Name.Should().Be("Datasets");
datasetType.Description.Should().BeNull();
datasetType.Type.Should().Be("Datasets");
List <PropertyInformation> properties = new List <PropertyInformation>(datasetType.Properties);
PropertyInformation firstDataset = properties[0];
firstDataset.Should().NotBeNull("firstDataset should not be null");
firstDataset.Name.Should().Be("ABTestDataset240301001");
firstDataset.FriendlyName.Should().Be("AB Test Dataset 2403-01-001");
firstDataset.Description.Should().Be("High Needs Student Numbers");
PropertyInformation secondDataset = properties[1];
secondDataset.Should().NotBeNull("firstDataset should not be null");
secondDataset.Name.Should().Be("ABTestDataset24030020011");
secondDataset.FriendlyName.Should().Be("AB Test Dataset 2403-002-0011");
secondDataset.Description.Should().Be("High Needs Student Numbers");
properties.Should().HaveCount(4, "Datasets should contain expected number of properties");
}
public void GetTypeInformation_WithListDatasetsReturnsCalculationObjectWithValidProperties()
{
// Act
IEnumerable <TypeInformation> result = WhenTypeInformationForTheAssemblyIsCreated(GetCalculationClassWithListDatasetsExampleAssembly());
// Assert
result.Should().NotBeNull("Result should not be null");
result.Should().ContainSingle(c => c.Name == "Calculations");
TypeInformation calculationType = result.Where(e => e.Name == "Calculations").FirstOrDefault();
calculationType.Name.Should().Be("Calculations");
calculationType.Description.Should().BeNull();
calculationType.Type.Should().Be("Calculations");
calculationType.Properties.Should().NotBeNull();
PropertyInformation datasetsProperty = calculationType.Properties.Where(p => p.Name == "Datasets").SingleOrDefault();
datasetsProperty.Should().NotBeNull();
datasetsProperty.Type.Should().Be("Datasets");
result.Should().ContainSingle(t => t.Name == "Datasets");
TypeInformation datasetsType = result.Where(t => t.Name == "Datasets").SingleOrDefault();
datasetsType.Should().NotBeNull();
PropertyInformation firstPropertyOfDatasets = datasetsType.Properties.First();
firstPropertyOfDatasets.Type.Should().Be("List(Of DemoTestAPTDatasetSchemaNoRequiredDataset)");
}
private Type ValidateAndGetType(ProtocolElement element, string typeName, Type assignableType, string elementPropertyName)
{
Type type;
try
{
type = Type.GetType(typeName, true);
}
catch (Exception exception)
{
PropertyInformation information = null;
string filename = string.Empty;
int line = 0;
if ((element != null) && (element.ElementInformation != null))
{
information = element.ElementInformation.Properties[elementPropertyName];
if (information != null)
{
filename = information.Source;
line = information.LineNumber;
}
}
throw new ConfigurationErrorsException(exception.Message, exception, filename, line);
}
ConfigUtil.CheckAssignableType(assignableType, type, element, elementPropertyName);
return(type);
}
/// <summary>
/// Delayed loading of the property inspector to avoid creating the entire list of property
/// editors immediately after selection. Keeps that app running smooth.
/// </summary>
/// <returns></returns>
private async void ProcessIncrementalPropertyAddAsync()
{
const int batchAmount = 10;
var propertiesToAdd = PropertyInformation.GetProperties(_target);
await Dispatcher.Yield(DispatcherPriority.Background);
int visiblePropertyCount = 0;
foreach (var property in propertiesToAdd)
{
// iterate over the PropertyInfo objects,
// setting the property grid's filter on each object,
// and adding those properties to the observable collection of propertiesToSort (this.properties)
property.Filter = Filter;
if (property.IsVisible)
{
_properties.Add(property);
}
_allProperties.Add(property);
// checking whether a property is visible ... actually runs the property filtering code
if (property.IsVisible)
{
property.Index = visiblePropertyCount++;
}
if ((visiblePropertyCount % batchAmount) == 0)
{
await Dispatcher.Yield(DispatcherPriority.Background);
}
}
}
// If a configuration section has a default value coming from 4.0 config and the AppDomain is opted in to auto-config upgrade,
// set the configuration section element explicitly to its new 4.5 value. If the property has been explicitly set, no change
// will be made.
internal static void SetFX45DefaultValue(ConfigurationSection configSection, ConfigurationProperty property, object newDefaultValue)
{
if (BinaryCompatibility.Current.TargetsAtLeastFramework45 && !configSection.IsReadOnly())
{
PropertyInformation propInfo = configSection.ElementInformation.Properties[property.Name];
Debug.Assert(propInfo != null);
Debug.Assert(propInfo.Type.IsInstanceOfType(newDefaultValue));
if (propInfo.ValueOrigin == PropertyValueOrigin.Default)
{
try
{
propInfo.Value = newDefaultValue;
}
catch (ConfigurationErrorsException)
{
// Calling the Value setter might throw if the configuration element is locked.
// We can technically override the "is locked?" check by calling the appropriate
// method, but for now let's just honor the locks and ignore these errors. The
// config sections we're touching shouldn't really ever be locked anyway, so
// nobody should ever run into this in practice.
}
}
}
}
/// <summary>
/// Dynamic form editor factory.
/// </summary>
/// <param name="pi">
/// The pi.
/// </param>
/// <returns>
/// A DynamicFormEditor.
/// </returns>
public static DynamicFormEditor DynamicFormEditorFactory(
PropertyInformation pi)
{
var listBoxContent = new DynamicFormListBoxContent
{
AssociatedLabel =
ParsePropertyNameForLabel(
pi.Name),
CanWrite = pi.CanWrite,
BindingMode =
pi.CanWrite
? BindingMode.TwoWay
: BindingMode.OneWay,
BindingPath = pi.Name
};
if (pi.TypeName.IndexOf("Boolean", System.StringComparison.Ordinal) == -1)
{
listBoxContent.ControlType = pi.CanWrite ?
DynamicFormControlType.TextBox : DynamicFormControlType.TextBlock;
}
else
{
listBoxContent.ControlType = DynamicFormControlType.CheckBox;
}
listBoxContent.DataType = pi.TypeName;
listBoxContent.TypeNamespace = pi.TypeNamespace;
if (listBoxContent.DataType.Contains("Int32"))
{
listBoxContent.DataType = "Integer";
}
else if (listBoxContent.DataType.Contains("Int16"))
{
listBoxContent.DataType = "Short";
}
else if (listBoxContent.DataType.Contains("Int64"))
{
listBoxContent.DataType = "Long";
}
if (pi.TypeName.Contains("Decimal"))
{
listBoxContent.StringFormat = "{0:c}";
}
else if (pi.TypeName.Contains("Date"))
{
listBoxContent.StringFormat = "{0:d}";
}
else
{
listBoxContent.StringFormat = string.Empty;
}
return(new DynamicFormEditor
{
DataContext = listBoxContent
});
}
private PropertyInformation CreatePropertyInformation(Type containerType, PropertyDescriptor property)
{
PropertyInformation info = new PropertyInformation();
info.ValueAccessor = CreatePropertyValueAccessor(property);
info.Prototype = CreateMetadataPrototype(AsAttributes(property.Attributes), containerType, property.PropertyType, property.Name);
return(info);
}
private bool PropertiesAreInOrder(PropertyInformation first, PropertyInformation last)
{
if (_direction == ListSortDirection.Ascending)
{
return(first.CompareTo(last) <= 0);
}
return(last.CompareTo(first) <= 0);
}
internal MonitorPropertyInformation(string server, PropertyInformation propertyInfo) : this()
{
this.Server = server;
this.PropertyName = propertyInfo.Name;
this.Description = propertyInfo.Description;
this.IsMandatory = propertyInfo.IsMandatory;
this[SimpleProviderObjectSchema.Identity] = new MonitorPropertyInformation.MonitorPropertyInformationId(this.PropertyName, this.Description, this.IsMandatory);
}
private static bool TryGetValue <T>(ConfigurationElement element, string name, out T value)
{
PropertyInformationCollection properties = element.ElementInformation.Properties;
PropertyInformation property = properties.Cast <PropertyInformation>().FirstOrDefault(p => p.Name == name);
bool hasProperty = property != null;
value = hasProperty ? (T)property.Value : default(T);
return(hasProperty);
}
private bool IsElementSpecified(string name)
{
PropertyInformation p = this.ElementInformation.Properties[name];
if (p != null)
{
return(p.ValueOrigin != PropertyValueOrigin.Default);
}
return(false);
}
private TModelMetadata CreatePropertyMetadata(Func <object> modelAccessor, PropertyInformation propertyInfo)
{
var metadata = CreateMetadataFromPrototype(propertyInfo.Prototype, modelAccessor);
if (propertyInfo.IsReadOnly)
{
metadata.IsReadOnly = true;
}
return(metadata);
}
private PropertyInformation CreatePropertyInformation(Type containerType, PropertyDescriptor property)
{
Contract.Requires(containerType != null);
Contract.Requires(property != null);
PropertyInformation info = new PropertyInformation();
info.ValueAccessor = CreatePropertyValueAccessor(property);
info.Prototype = this.CreateMetadataPrototype(AsAttributes(property.Attributes), containerType, property.PropertyType, property.Name);
return(info);
}
public void BitmapSuffix_Set_GetReturnsExpected(string bitmapSuffix)
{
var section = new SystemDrawingSection {
BitmapSuffix = bitmapSuffix
};
Assert.Equal(bitmapSuffix, section.BitmapSuffix);
PropertyInformation propertyInformation = section.ElementInformation.Properties["bitmapSuffix"];
Assert.Equal(bitmapSuffix, propertyInformation.Value);
}
public static PropertyInformation GetDefaultProperty(Type targetType, IDocumentContext documentContext)
{
IEnumerator <PropertyInformation> enumerator = PropertyInformation.GetPropertiesForType(targetType, documentContext.TypeResolver).GetEnumerator();
while (enumerator.MoveNext())
{
if (documentContext.CreateNode(typeof(DependencyProperty), (object)enumerator.Current.DependencyProperty) != null)
{
return(enumerator.Current);
}
}
return((PropertyInformation)null);
}
public PropertyInformation GetPropertyInformationDetails(Hashtable listingCriteria)
{
var _db = new DBUtility();
var temp = new PropertyInformation();
var _dt = new DataTable();
_cmd = new SqlCommand();
_cmd.CommandType = CommandType.StoredProcedure;
_cmd.CommandText = "GP_SP_GetPropertyInformationDetails";
_cmd.Parameters.AddWithValue("@UserId", Convert.ToString(listingCriteria["UserID"]));
_cmd.Parameters.AddWithValue("@ListingDetailsID", Convert.ToInt64(listingCriteria["ID"]));
_dt = _db.FillDataTable(_cmd, _dt);
if (_dt.Rows.Count > 0)
{
foreach (DataRow dr in _dt.Rows)
{
temp.ID = Convert.ToInt64(dr["ID"]);
temp.PropertyTypeID = (Convert.ToString(dr["PropertyTypeID"])) == "" ? 0 : Convert.ToInt32(dr["PropertyTypeID"]);
temp.PropertyAddress = Convert.ToString(dr["PropertyAddress"]);
temp.City = Convert.ToString(dr["City"]);
temp.Country = Convert.ToString(dr["Country"]);
temp.Zip = Convert.ToInt32(dr["Zip"]);
temp.OccupancyStatusID = (Convert.ToString(dr["OccupancyStatusID"])) == "" ? 0 : Convert.ToInt32(dr["OccupancyStatusID"]);
temp.StateName = Convert.ToString(dr["StateName"]);
temp.PropertyMarketValue = Convert.ToDouble(dr["PropertyMarketValue"]);
temp.PropertyValuationDate = Convert.ToString(dr["PropertyValuationDate"]);
temp.ValuationTypeID = (Convert.ToString(dr["ValuationTypeID"])) == "" ? 0 : Convert.ToInt32(dr["ValuationTypeID"]);
temp.IsCompany = Convert.ToBoolean(dr["IsCompany"]);
temp.PrimaryBorrowerFirstName = Convert.ToString(dr["PrimaryBorrowerFirstName"]);
temp.LastName = Convert.ToString(dr["LastName"]);
temp.MailingAddress = Convert.ToString(dr["MailingAddress"]);
temp.BorrowerCity = Convert.ToString(dr["BorrowerCity"]);
temp.BorrowerState = Convert.ToString(dr["BorrowerState"]);
temp.BorrowerZip = Convert.ToInt32(dr["BorrowerZip"]);
temp.BorrowerHomePh = Convert.ToInt64(dr["BorrowerHomePh"]);
temp.BorrowerWorkPh = Convert.ToInt64(dr["BorrowerWorkPh"]);
temp.BorrowerMobilePh = Convert.ToInt64(dr["BorrowerMobilePh"]);
temp.BorrowerEmail = Convert.ToString(dr["BorrowerEmail"]);
temp.BorrowerFax = Convert.ToInt64(dr["BorrowerFax"]);
temp.BorrowerSSTaxIDNoPrimary = Convert.ToInt64(dr["BorrowerSSTaxIDNoPrimary"]);
temp.ListingStatusID = Convert.ToInt32(dr["ListingStatusID"]);
}
}
return(temp);
}
public static ConditionNode CreateDefaultCondition(Type targetType, SceneViewModel viewModel, IDocumentContext documentContext)
{
PropertyInformation.GetPropertiesForType(targetType, documentContext.TypeResolver).GetEnumerator();
PropertyInformation defaultProperty = TriggersHelper.GetDefaultProperty(targetType, documentContext);
if (!((TriggerSourceInformation)defaultProperty != (TriggerSourceInformation)null))
{
return((ConditionNode)null);
}
ConditionNode conditionNode = ConditionNode.Factory.Instantiate(viewModel);
conditionNode.PropertyKey = defaultProperty.DependencyProperty;
conditionNode.Value = defaultProperty.DependencyProperty.DefaultMetadata.DefaultValue;
return(conditionNode);
}
public void AddProperty(Guid classId, PropertyInformation property)
{
var propertyId = Guid.NewGuid();
this.writer.AddDocument(new Document
{
new StringField("_id", propertyId.ToString(), Field.Store.NO),
new StringField("_classId", classId.ToString(), Field.Store.NO),
new TextField("name", property.Name, Field.Store.YES),
new TextField("propertyType", property.Type, Field.Store.YES),
new StoredField("HasGetter", property.HasGetter.ToString()),
new StoredField("HasSetter", property.HasGetter.ToString()),
new StringField("type", "Property", Field.Store.YES)
});
}
// Throws a ConfigurationErrorsException (descendant of ConfigurationException) on failure.
private static LoggingProviderBase GetDefaultProvider(LoggingSection loggingSection,
LoggingProviderCollection providerCollection)
{
LoggingProviderBase defaultProvider = providerCollection[loggingSection.DefaultProvider];
if (defaultProvider == null)
{
PropertyInformation property = loggingSection.ElementInformation.Properties["defaultProvider"];
throw new ConfigurationErrorsException(
SR.NoDefaultLoggingProviderFound(SectionName), property.Source, property.LineNumber);
}
return(defaultProvider);
}
public void WriteField(IndentedTextWriter indentWriter, PropertyInformation info)
{
if (info.Relation.HasFlag(Relation.One | Relation.ToOne) && !info.Relation.HasFlag(Relation.DependentSide))
{
indentWriter.Write($"section.AddField(x => x.{info.PascalCaseName} == null ? 0 : x.{info.PascalCaseName}.Id)");
indentWriter.Write(".DisableWhen((e, s) => true)");
}
else if (info.Relation.HasFlag(Relation.ToOne))
{
indentWriter.Write($"section.AddField(x => x.{info.PascalCaseName}Id)");
}
else
{
indentWriter.Write($"section.AddField(x => x.{info.PascalCaseName})");
}
indentWriter.Write($".SetType(typeof({info.EditorType}))");
if (info.Details.FirstOrDefault(x => !string.IsNullOrWhiteSpace(x.DataCollectionType)) is PropertyDetailInformation details)
{
indentWriter.Write($".SetDataCollection<{details.DataCollectionType}");
if (details.ConfigList != null || details.ConfigProperties != null)
{
indentWriter.Write($", {details.ConfigType}>(");
_configObjectBuilder.WriteConfigObject(indentWriter, details);
}
else
{
indentWriter.Write(">(");
}
indentWriter.Write(")");
}
else if (info.Relation.HasFlag(Relation.ToOne) && !string.IsNullOrEmpty(info.RelatedCollectionAlias))
{
indentWriter.Write($".SetCollectionRelation(\"{info.RelatedCollectionAlias}\")");
}
else if (info.Relation.HasFlag(Relation.ToMany) && !string.IsNullOrEmpty(info.RelatedCollectionAlias))
{
indentWriter.Write($".SetCollectionRelation(\"{info.RelatedCollectionAlias}\")");
}
indentWriter.Write($".SetName(\"{info.Name}\")");
indentWriter.WriteLine(";");
}
private IEnumerable <ModelMetadata> GetMetadataForPropertiesImpl(object container, Type containerType)
{
TypeInformation typeInfo = GetTypeInformation(containerType);
foreach (KeyValuePair <string, PropertyInformation> kvp in typeInfo.Properties)
{
PropertyInformation propertyInfo = kvp.Value;
Func <object> modelAccessor = null;
if (container != null)
{
Func <object, object> propertyGetter = propertyInfo.ValueAccessor;
modelAccessor = () => propertyGetter(container);
}
yield return(CreateMetadataFromPrototype(propertyInfo.Prototype, modelAccessor));
}
}
private static InheritanceTypes GetInheritance(PropertyInformation prop)
{
if (Inherits <ConfigurationElementCollection>(prop.Type))
{
//For us all are the same:
// a) We do the sorting anyway,
// b) Basic does not allow remove/clear anyway, so both properties will never occur
return(InheritanceTypes.COLLECTION);
}
if (Inherits <ConfigurationElement>(prop.Type))
{
return(InheritanceTypes.CONFIGURATION_ELEMENT);
}
return(InheritanceTypes.NONE);
}
void WeaveType(TypeDefinition @class, CustomAttribute weaveTypeAttribute)
{
var propertyInformation = new PropertyInformation[@class.Properties.Count];
var arguments = weaveTypeAttribute.ConstructorArguments.ToList();
var propertyImplementationGenericType = arguments[1].Value as TypeDefinition;
// Methods and events are taken from the MixIn's type directly rather than, as
// would be more appropriate, the interfaces it implements. That's because that way
// we don't need to resolve the interface's type.
WeaveMixInWithEventDelegations(@class, weaveTypeAttribute, out var mixInType, out var mixInField);
WeavePropertyDelegations(@class, mixInField, propertyImplementationGenericType, propertyInformation);
WeaveMethodDelegations(@class, mixInType, mixInField, propertyImplementationGenericType, propertyInformation, weaveTypeAttribute);
}
public List <Pair <string, object> > CreateExtensions()
{
var result = new List <Pair <string, object> >();
if (_constructors == null)
{
lock (_syncRoot)
{
if (_constructors == null)
{
var constructors = new List <KeyValuePair <string, ConstructorInfo> >();
if (_providerData == null)
{
return(result);
}
foreach (var configLine in _providerData.XslExtensions)
{
PropertyInformation propertyInformation = configLine.ElementInformation.Properties["type"];
if (propertyInformation == null)
{
continue;
}
Type type = propertyInformation.Value as Type;
if (type == null)
{
continue;
}
ConstructorInfo constructor = type.GetConstructors()[0];
constructors.Add(new KeyValuePair <string, ConstructorInfo>(configLine.Name, constructor));
}
// TODO: uncomment
_constructors = constructors;
}
}
}
foreach (var pair in _constructors)
{
object instance = pair.Value.Invoke(new object[0]);
result.Add(new Pair <string, object>(pair.Key, instance));
}
return(result);
}
public void GetTypeInformation_WhenListDatasetsThenPropertyDescriptionShouldBeReturned()
{
// Arrange
ICodeMetadataGeneratorService generator = GetCodeGenerator();
byte[] assembly = GetCalculationClassWithListDescriptionsExampleAssembly();
// Act
IEnumerable <TypeInformation> result = generator.GetTypeInformation(assembly);
// Assert
result.Should().NotBeNull("Result should not be null");
result.Should().ContainSingle(c => c.Name == "Calculations");
TypeInformation datasetType = result.Where(e => e.Name == "HighNeedsStudentNumbersDataset").FirstOrDefault();
datasetType.Name.Should().Be("HighNeedsStudentNumbersDataset");
datasetType.Description.Should().BeNull();
datasetType.Type.Should().Be("HighNeedsStudentNumbersDataset");
List <PropertyInformation> properties = new List <PropertyInformation>(datasetType.Properties);
PropertyInformation ridProperty = properties[0];
ridProperty.Should().NotBeNull("ridProperty should not be null");
ridProperty.Name.Should().Be("Rid");
ridProperty.FriendlyName.Should().Be("Rid");
ridProperty.Description.Should().Be("Rid is the unique reference from The Store");
PropertyInformation parentRidProperty = properties[1];
parentRidProperty.Should().NotBeNull("parentRidProperty should not be null");
parentRidProperty.Name.Should().Be("ParentRid");
parentRidProperty.FriendlyName.Should().Be("Parent Rid");
parentRidProperty.Description.Should().Be("The Rid of the parent provider (from The Store)");
PropertyInformation highNeedsStudentsProperty = properties[11];
highNeedsStudentsProperty.Should().NotBeNull("parentRidProperty should not be null");
highNeedsStudentsProperty.Name.Should().Be("HighNeedsStudents1924");
highNeedsStudentsProperty.FriendlyName.Should().Be("High Needs Students 19-24");
highNeedsStudentsProperty.Description.Should().Be("Current year high needs students aged 19-24");
properties.Should().HaveCount(22, "HighNeedsStudentNumbersDataset should contain expected number of properties");
}
private static Exception BuildMoreExpressiveException(Exception thrownException,
ProviderSettings settings)
{
PropertyInformation providerInfo = settings.ElementInformation.Properties["type"];
if (thrownException is ArgumentException)
{
// The exception is thrown from within this method. Therefore we do not supply an inner
// exception.
return(new ConfigurationErrorsException(thrownException.Message,
thrownException.InnerException, providerInfo.Source, providerInfo.LineNumber));
}
else
{
return(new ConfigurationErrorsException(thrownException.Message, thrownException,
providerInfo.Source, providerInfo.LineNumber));
}
}
public void CopyTo(PropertyInformation[] array, int index)
{
}
