internal IEntityList GetEntetiesAfterFiltering(Dictionary <string, string> fieldsAndValues) { IFactory factory = null; switch (EntityType) { case EntityType.Defect: { factory = Connection.GetFactory <IBug>(); break; } case EntityType.Requirement: { factory = Connection.GetFactory <IRequirement>(); break; } } if (factory != null) { IListConfiguration listConfiguration = factory.NewListConfiguration(); foreach (var fieldAndValue in fieldsAndValues) { listConfiguration.Filter[fieldAndValue.Key] = fieldAndValue.Value; } return(factory.NewList(listConfiguration)); } return(null); }
/// <summary> /// Attempts to create an instance of <see cref="IListConfiguration.RequestType"/>. /// </summary> /// <param name="source"></param> /// <exception cref="NullReferenceException"> /// An instance of <see cref="IModelFactory"/> could not be created by <see cref="ActivatorUtilities.GetServiceOrCreateInstance"/>. /// </exception> /// <exception cref="ArgumentException"> /// No model factories or factory methods have been defined in <see cref="IListConfiguration.ModelActivatorConfiguration"/>. /// </exception> /// <returns></returns> public object CreateInstance(IListConfiguration source) { var configuration = source.ModelActivatorConfiguration; if (configuration.Method != null) { return(configuration.Method(source.RequestType)); } // TODO: Add some sort of null check for httpContextAccessor? if (configuration.Factory != null) { return(configuration.Factory(httpContextAccessor.HttpContext.RequestServices, source.RequestType)); } if (configuration.FactoryType != null) { var factory = ActivatorUtilities.GetServiceOrCreateInstance(httpContextAccessor.HttpContext.RequestServices, configuration.FactoryType) as IModelFactory; if (factory == null) { throw new NullReferenceException($"Unable to create an instance of '{configuration.FactoryType.FullName}'."); } return(factory.Create(source.RequestType)); } throw new ArgumentException($"No suitable factory methods defined", nameof(source.ModelActivatorConfiguration)); }
/// <summary> /// Initializes a new instance of <see cref="ModelPropertyVisitor"/> /// </summary> /// <param name="configuration">Filter Configuration</param> /// <param name="model">Value of the model property</param> /// <param name="routeValueDictionary">RouteValueDictionary to populate</param> public ModelPropertyVisitor(IListConfiguration configuration, object model, RouteValueDictionary routeValueDictionary) : base(routeValueDictionary) { this.configuration = configuration; this.model = model; this.routeValueDictionary = routeValueDictionary; }
/// <summary> /// Activates <see cref="ISearch"/> type properties on the provided <paramref name="model"/>. /// </summary> /// <param name="configuration"></param> /// <param name="model"></param> protected virtual void ActivateSearchProperties(IListConfiguration configuration, object model) { foreach (var searchConfiguration in configuration.SearchConfigurations) { var value = ActivateSearchProperty(searchConfiguration); searchConfiguration.RequestProperty.SetValue(model, value); } }
public GenericSearchModelBinder(IListConfiguration configuration, IModelActivator modelActivator, IModelPropertyActivator modelPropertyActivator, IModelCache modelCache, IModelBinder fallbackModelBinder) { this.configuration = configuration; this.modelActivator = modelActivator; this.modelPropertyActivator = modelPropertyActivator; this.modelCache = modelCache; this.fallbackModelBinder = fallbackModelBinder; }
private IListConfiguration GetListConfiguration(string name, IContainer container) { IListConfiguration listConfig = container.Configuration.GetListConfiguration(name); if (listConfig == null) { listConfig = new ListConfiguration(); listConfig.Name = name; container.Configuration.AddListConfiguration(listConfig); } return(listConfig); }
/// <summary> /// Attempts to activate all relevant search, sort, pagination, and other specified /// properties of the <paramref name="model"/>. /// </summary> /// <param name="configuration">Relevant <see cref="IListConfiguration"/> for the <paramref name="model"/> type.</param> /// <param name="model">Instance of the model type.</param> /// <exception cref="ArgumentNullException">Provided <paramref name="configuration"/> is null.</exception> /// <exception cref="ArgumentNullException">Provided <paramref name="model"/> is null.</exception> public void Activate(IListConfiguration configuration, object model) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration), "Provided configuration is null"); } if (model == null) { throw new ArgumentNullException(nameof(model), "Provided model is null."); } ActivateSearchProperties(configuration, model); ActivateSortDirection(configuration.SortDirectionConfiguration, model); ActivateSortColumn(configuration.SortColumnConfiguration, model); ActivatePage(configuration.PageConfiguration, model); ActivateRows(configuration.RowsConfiguration, model); ActivateProperties(configuration.PropertyConfigurations, model); }
private IListConfiguration ConfigureList(XmlNode configNode, IContainer container) { string listName = configNode.Attributes["name"].Value; IListConfiguration listConfig = GetListConfiguration(listName, container); listConfig.Name = listName; foreach (XmlNode listNode in configNode) { if (listNode.Name == "item") { ListItemConfiguration listItemConfig = new ListItemConfiguration(); listConfig.ListItemConfigurations.Add(listItemConfig); ConfigureElement(listNode, listItemConfig, container, null); } } container.Configuration.AddListConfiguration(listConfig); return(listConfig); }
private void ConfigureElement(XmlNode node, ElementConfiguration config, IContainer container, Type valueType) { config.Type = valueType; if (node.Attributes["value"] != null) { string propertyValueString = node.Attributes["value"].Value; ValueConfiguration propertyValueConfig = new ValueConfiguration(); propertyValueConfig.Value = propertyValueString; config.Value = propertyValueConfig; if (node.Attributes["type-converter"] != null) { string typeConverterString = node.Attributes["type-converter"].Value; Type typeConverterType = ResolveType(typeConverterString); TypeConverter typeConverter = (TypeConverter)Activator.CreateInstance(typeConverterType); propertyValueConfig.TypeConverter = typeConverter; } if (node.Attributes["type"] != null) { string typeString = node.Attributes["type"].Value; Type type = ResolveType(typeString); config.Type = type; } } if (node.Attributes["object"] != null) { string propertyObjectName = node.Attributes["object"].Value; IObjectConfiguration propertyObjectConfig = GetObjectConfiguration(propertyObjectName, container); config.Value = propertyObjectConfig; //done if (node.Attributes["instance-mode"] != null) { string instanceModeString = node.Attributes["instance-mode"].Value; config.InstanceMode = (InstanceMode)InstanceMode.Parse(typeof(InstanceMode), instanceModeString); } } if (node.Attributes["list"] != null) { string propertyListName = node.Attributes["list"].Value; IListConfiguration propertyListConfig = GetListConfiguration(propertyListName, container); config.Value = propertyListConfig; config.Type = typeof(IList); } if (node.Attributes["factory"] != null) { string itemFactoryName = node.Attributes["factory"].Value; IFactoryConfiguration propertyFactoryConfig = GetFactoryConfiguration(itemFactoryName, container); config.Value = propertyFactoryConfig; } }
public IContainer Configure(XmlElement xmlRoot) { IContainer container = new Container(); XmlElement o = xmlRoot; if (o == null) { return(container); } ArrayList objectConfigurations = new ArrayList(); ArrayList listConfigurations = new ArrayList(); ArrayList factoryConfigurations = new ArrayList(); foreach (XmlNode configNode in o) { if (configNode.Name == "object") { IObjectConfiguration objectConfig = ConfigureObject(configNode, container); objectConfigurations.Add(objectConfig); } if (configNode.Name == "list") { IListConfiguration listConfig = ConfigureList(configNode, container); listConfigurations.Add(listConfig); } if (configNode.Name == "factory") { IFactoryConfiguration factoryConfig = ConfigureFactory(configNode, container); factoryConfigurations.Add(factoryConfig); } } foreach (FactoryConfiguration factoryConfig in factoryConfigurations) { FillFactoryParameterTypes(factoryConfig); if (factoryConfig.Object != null) { factoryConfig.Type = factoryConfig.Object.Type; } bool isStatic = factoryConfig.Object == null; MethodInfo bestMethodMatch = MatchMethods(factoryConfig, factoryConfig.Type, factoryConfig.MethodName, isStatic) ; if (bestMethodMatch == null) { throw new Exception(string.Format("Can not find Method for type '{0}' that matches your parameters", factoryConfig.Type)); } factoryConfig.Method = bestMethodMatch; } foreach (ObjectConfiguration objectConfig in objectConfigurations) { FillCtorParameterTypes(objectConfig); if (objectConfig.InstanceValue is FactoryConfiguration) { FactoryConfiguration factory = objectConfig.InstanceValue as FactoryConfiguration; objectConfig.Type = factory.Method.ReturnType; } else { ConstructorInfo bestCtorMatch = MatchConstructors(objectConfig); if (bestCtorMatch == null) { throw new Exception(string.Format("Can not find CTOR for type '{0}' that matches your parameters", objectConfig.Type)); } objectConfig.Constructor = bestCtorMatch; } } foreach (ListConfiguration listConfig in listConfigurations) { FillItemTypes(listConfig); } //cache configuration return(container); }
public object CreateInstance(IListConfiguration source) { throw new NotImplementedException(); }
public void AddListConfiguration(IListConfiguration config) { this.listConfigurations[config.Name] = config; }
public static string[] ItemPropertyPathFor(this IListConfiguration configuration, string requestPropertyName) { return(configuration.SearchConfigurations.ItemPropertyPathFor(requestPropertyName)); }
public static PropertyInfo ResultPropertyFor(this IListConfiguration configuration, string requestPropertyName) { return(configuration.SearchConfigurations.ResultPropertyFor(requestPropertyName)); }