private DataFieldDescriptor CreateReferenceDataFieldDescriptor(DataTypeDescriptor targetDataTypeDescriptor, out string foreignKeyFieldName, string fieldName = null) { Type targetType = TypeManager.GetType(targetDataTypeDescriptor.TypeManagerTypeName); string targetKeyFieldName = targetDataTypeDescriptor.KeyPropertyNames.First(); DataFieldDescriptor targetKeyDataFieldDescriptor = targetDataTypeDescriptor.Fields[targetKeyFieldName]; foreignKeyFieldName = fieldName ?? string.Format("{0}{1}ForeignKey", targetDataTypeDescriptor.Name, targetKeyFieldName); WidgetFunctionProvider widgetFunctionProvider = StandardWidgetFunctions.GetDataReferenceWidget(targetType); return(new DataFieldDescriptor( Guid.NewGuid(), foreignKeyFieldName, targetKeyDataFieldDescriptor.StoreType, targetKeyDataFieldDescriptor.InstanceType ) { IsNullable = targetKeyDataFieldDescriptor.IsNullable, DefaultValue = targetKeyDataFieldDescriptor.DefaultValue, ValidationFunctionMarkup = targetKeyDataFieldDescriptor.ValidationFunctionMarkup, ForeignKeyReferenceTypeName = targetDataTypeDescriptor.TypeManagerTypeName, FormRenderingProfile = new DataFieldFormRenderingProfile { Label = foreignKeyFieldName, HelpText = foreignKeyFieldName, WidgetFunctionMarkup = widgetFunctionProvider.SerializedWidgetFunction.ToString(SaveOptions.DisableFormatting) } }); }
private ParameterProfile BuildParameterProfile(IParameter parameter) { Type parameterType = TypeManager.GetType(parameter.TypeManagerName); bool isRequired = false; BaseValueProvider defaultValueProvider; if (string.IsNullOrEmpty(parameter.DefaultValueFunctionMarkup)) { defaultValueProvider = new NoValueValueProvider(); isRequired = true; } else { defaultValueProvider = new FunctionValueProvider(XElement.Parse(parameter.DefaultValueFunctionMarkup)); } WidgetFunctionProvider widgetFunctionProvider; if (string.IsNullOrEmpty(parameter.WidgetFunctionMarkup) == false) { widgetFunctionProvider = new WidgetFunctionProvider(XElement.Parse(parameter.WidgetFunctionMarkup)); } else { widgetFunctionProvider = WidgetFunctionProvider.BuildNoWidgetProvider(); } return(new ParameterProfile(parameter.Name, parameterType, isRequired, defaultValueProvider, widgetFunctionProvider, parameter.Label, new HelpDefinition(parameter.HelpText))); }
public MediaFileSelectorWidgetFunction(EntityTokenFactory entityTokenFactory) : base(CompositeName, typeof(NullableDataReference <IMediaFile>), entityTokenFactory) { var widget = new WidgetFunctionProvider(MediaFileFolderSelectorWidget.CompositeName); base.AddParameterProfile( new ParameterProfile("MediaFileFolderReference", typeof(DataReference <IMediaFileFolder>), false, new ConstantValueProvider(new DataReference <IMediaFileFolder>()), widget, new Dictionary <string, object>(), "Media Folder", new HelpDefinition("Select a media folder to choose files from. Default is all media files."))); base.AddParameterProfile( new ParameterProfile("FileExtensionFilter", typeof(string), false, new ConstantValueProvider(""), StandardWidgetFunctions.TextBoxWidget, null, "File Extension Filter", new HelpDefinition("Limit the list to files which have the specified extension. Default is no filter."))); base.AddParameterProfile( new ParameterProfile("IncludeSubfolders", typeof(bool), false, new ConstantValueProvider(true), StandardWidgetFunctions.GetBoolSelectorWidget("Include files from subfolders", "Only show files from the specified Media folder"), null, "Include Subfolders", new HelpDefinition("When false files from subfolders will no be included."))); var requiredWidget = StandardWidgetFunctions.GetBoolSelectorWidget("Yes, require selection", "No, optional"); base.AddParameterProfile( new ParameterProfile(RequiredParameterName, typeof(bool), false, new ConstantValueProvider(true), requiredWidget, new Dictionary <string, object>(), "Selection required", new HelpDefinition("Specify if selecting a media file should be required.")) ); }
public StandardFunctionParameterProfile( string name, Type type, bool isRequired, BaseValueProvider fallbackValueProvider, WidgetFunctionProvider widgetFunctionProvider, string customResourceHandleNamespace) : this(name, type, isRequired, fallbackValueProvider, widgetFunctionProvider) { this.CustomResourceHandleNamespace = customResourceHandleNamespace; }
public ImageSelectorWidgetFunction(EntityTokenFactory entityTokenFactory) : base(CompositeName, typeof(NullableDataReference <IImageFile>), entityTokenFactory) { var mediaFolderSelectorWidget = new WidgetFunctionProvider(MediaFileFolderSelectorWidget.CompositeName); base.AddParameterProfile( new ParameterProfile(MediaFileFolderReferenceParameterName, typeof(DataReference <IMediaFileFolder>), false, new ConstantValueProvider(new DataReference <IMediaFileFolder>()), mediaFolderSelectorWidget, new Dictionary <string, object>(), "Image folder", new HelpDefinition("Select a media folder to choose images from. Default is 'all media'.")) ); var requiredWidget = StandardWidgetFunctions.GetBoolSelectorWidget("Yes, require selection", "No, optional"); base.AddParameterProfile( new ParameterProfile(RequiredParameterName, typeof(bool), false, new ConstantValueProvider(true), requiredWidget, new Dictionary <string, object>(), "Selection required", new HelpDefinition("Specify if selecting an image should be required.")) ); }
public FunctionParameterHolder(string name, Type type, FunctionParameterAttribute att, WidgetFunctionProvider widgetProvider) { Name = name; Type = type; Attribute = att; WidgetProvider = widgetProvider; }
public StandardFunctionParameterProfile( string name, Type type, bool isRequired, BaseValueProvider fallbackValueProvider, WidgetFunctionProvider widgetFunctionProvider) { this.Name = name; this.Type = type; this.IsRequired = isRequired; this.FallbackValueProvider = fallbackValueProvider; this.WidgetFunctionProvider = widgetFunctionProvider; }
private static void RegisterSearchQueryController <T>(FunctionCollection functions, string searchQueryType) where T : Controller { WidgetFunctionProvider searhQueryListWidgetFunctionProvider = new WidgetFunctionProvider(XElement.Parse($@"<f:widgetfunction xmlns:f='http://www.composite.net/ns/function/1.0' name='Composite.Widgets.String.Selector'> <f:param name='Options'> <f:function name='Composer.SearchQuery.Functions.GetSearchQueryList'> <f:param name='type' value='{searchQueryType}' /> </f:function> </f:param> </f:widgetfunction>")); }
private IDictionary <string, FunctionParameterHolder> GetParameters(object obj) { var dict = new Dictionary <string, FunctionParameterHolder>(); ParameterWidgets widgetProviders = null; var type = obj.GetType(); while (type != BaseType) { var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.DeclaredOnly); foreach (var prop in properties) { var propType = prop.PropertyType; var name = prop.Name; var att = prop.GetCustomAttributes(typeof(FunctionParameterAttribute), false).Cast <FunctionParameterAttribute>().FirstOrDefault(); WidgetFunctionProvider widgetProvider = null; if (att != null && !String.IsNullOrEmpty(att.WidgetMarkup)) { var el = XElement.Parse(att.WidgetMarkup); widgetProvider = new WidgetFunctionProvider(el); } else { if (widgetProviders == null) { var widgetProviderMethod = type.GetMethod("GetParameterWidgets"); if (widgetProviderMethod != null && widgetProviderMethod.ReturnType == typeof(ParameterWidgets)) { widgetProviders = (ParameterWidgets)widgetProviderMethod.Invoke(obj, null); } else { widgetProviders = new ParameterWidgets(); } } if (widgetProviders.ContainsKey(prop)) { widgetProvider = widgetProviders[prop]; } } if (!dict.ContainsKey(name)) { dict.Add(name, new FunctionParameterHolder(name, propType, att, widgetProvider)); } } type = type.BaseType; } return(dict); }
public static WidgetFunctionProvider GetWidgetFunctionProvider(DataFieldDescriptor dataFieldDescriptor) { if ((dataFieldDescriptor.FormRenderingProfile != null) && (string.IsNullOrEmpty(dataFieldDescriptor.FormRenderingProfile.WidgetFunctionMarkup) == false)) { WidgetFunctionProvider widgetFunctionProvider = new WidgetFunctionProvider(XElement.Parse(dataFieldDescriptor.FormRenderingProfile.WidgetFunctionMarkup)); return(widgetFunctionProvider); } else { return(StandardWidgetFunctions.GetDefaultWidgetFunctionProviderByType(dataFieldDescriptor.InstanceType)); } }
private static IDictionary <string, FunctionParameter> GetModelParameters(Type modelType) { var dictionary = new Dictionary <string, FunctionParameter>(); foreach (var info in modelType.GetProperties(BindingFlags.SetProperty | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)) { if (((info.GetSetMethod(false) == null)) || info.GetCustomAttributes(typeof(FunctionParameterIgnoreAttribute), false).Any()) { continue; } var propertyType = info.PropertyType; var name = info.Name; FunctionParameterAttribute functionParameterAttribute = null; var source = info.GetCustomAttributes <FunctionParameterAttribute>(false).ToList(); if (source.Count > 1) { Log.LogWarning(LogTitle, String.Format("More than one '{0}' attribute defined on property '{1}'", typeof(FunctionParameterAttribute).Name, name)); } else { functionParameterAttribute = source.FirstOrDefault(); } WidgetFunctionProvider widgetProvider = null; if ((functionParameterAttribute != null) && functionParameterAttribute.HasWidgetMarkup) { try { widgetProvider = functionParameterAttribute.GetWidgetFunctionProvider(modelType, info); } catch (Exception exception) { Log.LogWarning(LogTitle, String.Format("Failed to get widget function provider for parameter property {0}.", info.Name)); Log.LogWarning(LogTitle, exception); } } if (!dictionary.ContainsKey(name)) { dictionary.Add(name, new FunctionParameter(name, propertyType, functionParameterAttribute, widgetProvider)); } } return(dictionary); }
private void SetParameterProfiles() { WidgetFunctionProvider dropDown = StandardWidgetFunctions.DropDownList(GetType(), nameof(GetAssociationPageRestrictions), "Key", "Value", false, true); AddParameterProfile( new ParameterProfile( typeof(SitemapScope).Name, typeof(SitemapScope), true, new ConstantValueProvider(SitemapScope.Current), dropDown, null, "Sitemap scope", new HelpDefinition(Resources.default_text.SelectFilteredDataWidgetFuncSitescopeHelp))); }
private void ResetWidgetSelector() { string widgetFunctionMarkup = ""; WidgetFunctionProvider widgetFunctionProvider = StandardWidgetFunctions.GetDefaultWidgetFunctionProviderByType(this.CurrentlySelectedWidgetReturnType); if (widgetFunctionProvider != null) { widgetFunctionMarkup = widgetFunctionProvider.SerializedWidgetFunction.ToString(SaveOptions.DisableFormatting); } btnWidgetFunctionMarkup.Value = widgetFunctionMarkup; if (widgetFunctionMarkup == "") { if (FunctionFacade.GetWidgetFunctionNamesByType(this.CurrentlySelectedWidgetReturnType).Any()) { Baloon(btnWidgetFunctionMarkup.ClientID, GetString("SpecifyWidgetTip")); } } }
private void SetParameterProfiles() { WidgetFunctionProvider tb = StandardWidgetFunctions.TextBoxWidget; AddParameterProfile( new ParameterProfile( Constants.PageIdParamName, typeof(string), true, new ConstantValueProvider(null), tb, null, "Page id", new HelpDefinition(Resources.default_text.SerializeMarkupParamsFuncPageIdHelp))); AddParameterProfile( new ParameterProfile( Constants.TypeNameParamName, typeof(string), true, new ConstantValueProvider(null), tb, null, "Type name", new HelpDefinition(Resources.default_text.SerializeMarkupParamsFuncTypeNameHelp))); AddParameterProfile( new ParameterProfile( Constants.SitemapScopeIdParamName, typeof(string), true, new ConstantValueProvider(null), tb, null, "Sitemap scope id", new HelpDefinition(Resources.default_text.SerializeMarkupParamsFuncSitemapScopeIdHelp))); }
private DataFieldDescriptor CreateWeakReferenceDataFieldDescriptor(DataTypeDescriptor targetDataTypeDescriptor, DataFieldDescriptor targetDataFieldDescriptor, string fieldName) { TypeManager.GetType(targetDataTypeDescriptor.TypeManagerTypeName); WidgetFunctionProvider widgetFunctionProvider = StandardWidgetFunctions.TextBoxWidget; return(new DataFieldDescriptor( Guid.NewGuid(), fieldName, targetDataFieldDescriptor.StoreType, targetDataFieldDescriptor.InstanceType ) { IsNullable = targetDataFieldDescriptor.IsNullable, DefaultValue = targetDataFieldDescriptor.DefaultValue, ValidationFunctionMarkup = targetDataFieldDescriptor.ValidationFunctionMarkup, FormRenderingProfile = new DataFieldFormRenderingProfile { Label = fieldName, HelpText = fieldName, WidgetFunctionMarkup = widgetFunctionProvider.SerializedWidgetFunction.ToString(SaveOptions.DisableFormatting) } }); }
internal static ParameterProfile BuildParameterProfile(string name, Type type, FunctionParameterAttribute attribute, Type controllerType) { BaseValueProvider defaultValueProvider = new NoValueValueProvider(); string label = name; string helpText = String.Empty; if (!attribute.Label.IsNullOrEmpty()) { label = attribute.Label; } if (!attribute.Help.IsNullOrEmpty()) { helpText = attribute.Help; } bool isRequired = !attribute.HasDefaultValue; if (!isRequired) { defaultValueProvider = new ConstantValueProvider(attribute.DefaultValue); } WidgetFunctionProvider widgetProvider = attribute.GetWidgetFunctionProvider(controllerType, null); bool hideInSimpleView = attribute.HideInSimpleView; if (widgetProvider == null) { widgetProvider = StandardWidgetFunctions.GetDefaultWidgetFunctionProviderByType(type, isRequired); } return(new ParameterProfile(name, type, isRequired, defaultValueProvider, widgetProvider, label, new HelpDefinition(helpText), hideInSimpleView)); }
private IList <ParameterProfile> InitializeParamteres() { ParameterInfo[] parameterInfos = this.MethodInfo.GetParameters(); var defaultValues = new Dictionary <string, object>(); var labels = new Dictionary <string, string>(); var helpTexts = new Dictionary <string, string>(); var widgetProviders = new Dictionary <string, WidgetFunctionProvider>(); var parametersToHideInSimpleView = new HashSet <string>(); foreach (object obj in this.MethodInfo.GetCustomAttributes(typeof(MethodBasedDefaultValueAttribute), true)) { MethodBasedDefaultValueAttribute attribute = (MethodBasedDefaultValueAttribute)obj; defaultValues.Add(attribute.ParameterName, attribute.DefaultValue); } // Run through obsolete FunctionParameterDescriptionAttribute #pragma warning disable 612,618 foreach ( object obj in this.MethodInfo.GetCustomAttributes(typeof(FunctionParameterDescriptionAttribute), true)) { FunctionParameterDescriptionAttribute attribute = (FunctionParameterDescriptionAttribute)obj; if (attribute.HasDefaultValue && !defaultValues.ContainsKey(attribute.ParameterName)) { defaultValues.Add(attribute.ParameterName, attribute.DefaultValue); } labels.Add(attribute.ParameterName, attribute.ParameterLabel); helpTexts.Add(attribute.ParameterName, attribute.ParameterHelpText); } #pragma warning restore 612,618 // Run trhough new and improved FunctionParameterAttribute. Many may exist for one parameter. foreach (object obj in this.MethodInfo.GetCustomAttributes(typeof(FunctionParameterAttribute), true)) { var attribute = (FunctionParameterAttribute)obj; Verify.That(attribute.HasName, "All [FunctionParameter(...)] definitions on the method '{0}' must have 'Name' specified.", this.MethodInfo.Name); string parameterName = attribute.Name; if (attribute.HasDefaultValue && !defaultValues.ContainsKey(parameterName)) { defaultValues.Add(parameterName, attribute.DefaultValue); } if (attribute.HasLabel && !labels.ContainsKey(parameterName)) { labels.Add(parameterName, attribute.Label); } if (attribute.HasHelp && !helpTexts.ContainsKey(parameterName)) { helpTexts.Add(parameterName, attribute.Help); } if (attribute.HasWidgetMarkup && !widgetProviders.ContainsKey(parameterName)) { try { var widgetFunctionProvider = attribute.GetWidgetFunctionProvider(null, null); widgetProviders.Add(parameterName, widgetFunctionProvider); } catch (Exception ex) { string errText = "Failed to set Widget Markup for parameter '{0}' on method '{1}'. {2}" .FormatWith(parameterName, this.MethodInfo.Name, ex.Message); throw new InvalidOperationException(errText); } } if (attribute.HideInSimpleView) { parametersToHideInSimpleView.Add(parameterName); } } var result = new List <ParameterProfile>(); foreach (ParameterInfo parameterInfo in parameterInfos) { string parameterName = parameterInfo.Name; BaseValueProvider valueProvider; object defaultValue = null; if (defaultValues.TryGetValue(parameterName, out defaultValue)) { valueProvider = new ConstantValueProvider(defaultValue); } else { valueProvider = new NoValueValueProvider(); } bool isRequired = !defaultValues.ContainsKey(parameterName); string parameterLabel = parameterInfo.Name; if (labels.ContainsKey(parameterName)) { parameterLabel = labels[parameterName]; } string parameterHelpText = ""; if (helpTexts.ContainsKey(parameterName)) { parameterHelpText = helpTexts[parameterName]; } WidgetFunctionProvider widgetFunctionProvider = (widgetProviders.ContainsKey(parameterName) ? widgetProviders[parameterName] : StandardWidgetFunctions.GetDefaultWidgetFunctionProviderByType(parameterInfo.ParameterType)); bool hideInSimpleView = parametersToHideInSimpleView.Contains(parameterName); result.Add(new ParameterProfile(parameterName, parameterInfo.ParameterType, isRequired, valueProvider, widgetFunctionProvider, parameterLabel, new HelpDefinition(parameterHelpText), hideInSimpleView)); } return(result); }
/// <summary> /// Extracts the function paramteres from an object that represents a function. /// </summary> /// <param name="functionObject">The object that represents a function.</param> /// <param name="baseFunctionType">Type of the base function.</param> /// <param name="filePath">Physical file location of the file behind the function, used for logging.</param> /// <returns></returns> public static IDictionary <string, FunctionParameter> GetParameters(object functionObject, Type baseFunctionType, string filePath) { var functionParameters = new Dictionary <string, FunctionParameter>(); IDictionary <string, WidgetFunctionProvider> parameterWidgets = GetParameterWidgets(functionObject); var type = functionObject.GetType(); while (type != baseFunctionType && type != null) { var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.DeclaredOnly); foreach (var property in properties) { // Skipping overriden base properties if (property.GetAccessors()[0].GetBaseDefinition().DeclaringType == baseFunctionType) { continue; } // Skipping private setters if (property.GetSetMethod(false) == null) { continue; } // Skipping explicitly ignored attributes if (property.GetCustomAttributes(typeof(FunctionParameterIgnoreAttribute), false).Any()) { continue; } var propType = property.PropertyType; var name = property.Name; FunctionParameterAttribute attr = null; var attributes = property.GetCustomAttributes(typeof(FunctionParameterAttribute), false).Cast <FunctionParameterAttribute>().ToList(); if (attributes.Count > 1) { Log.LogWarning(LogTitle, "More than one '{0}' attribute defined on property '{1}'. Location: '{2}'" .FormatWith(typeof(FunctionParameterAttribute).Name, name, filePath)); } else { attr = attributes.FirstOrDefault(); } WidgetFunctionProvider attibuteBasedWidgetProvider = null; WidgetFunctionProvider methodBasedWidgetProvider = null; if (attr != null && attr.HasWidgetMarkup) { try { attibuteBasedWidgetProvider = attr.GetWidgetFunctionProvider(type, property); } catch (Exception ex) { Log.LogWarning(LogTitle, "Failed to get widget function provider for parameter property {0}. Location: '{1}'" .FormatWith(property.Name, filePath)); Log.LogWarning(LogTitle, ex); } } parameterWidgets.TryGetValue(name, out methodBasedWidgetProvider); if (methodBasedWidgetProvider != null && attibuteBasedWidgetProvider != null) { Log.LogWarning(LogTitle, "Widget for property {0} is defined in both {1} attribute and in {2}() method. Remove one of the definitions. Location: '{3}'" .FormatWith(property.Name, nameof(FunctionParameterAttribute), nameof(IParameterWidgetsProvider.GetParameterWidgets), filePath)); } if (!functionParameters.ContainsKey(name)) { functionParameters.Add(name, new FunctionParameter(name, propType, attr, attibuteBasedWidgetProvider ?? methodBasedWidgetProvider)); } } type = type.BaseType; } return(functionParameters); }
private static void RegisterSearchQueryController <T>(FunctionCollection functions, string searchQueryType) where T : Controller { WidgetFunctionProvider searhQueryListWidgetFunctionProvider = new WidgetFunctionProvider(XElement.Parse($@"<f:widgetfunction xmlns:f='http://www.composite.net/ns/function/1.0' name='Composite.Widgets.String.Selector'> <f:param name='Options'> <f:function name='Composer.SearchQuery.Functions.GetSearchQueryList'> <f:param name='type' value='{searchQueryType}' /> </f:function> </f:param> </f:widgetfunction>")); functions.RegisterAction <T>("Index", $"Composer.Queries.{searchQueryType}.Results") .AddParameter("QueryName", typeof(string), label: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.QueryNameLabel"), helpText: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.QueryNameHelp"), isRequired: true, widgetFunctionProvider: searhQueryListWidgetFunctionProvider ); functions.RegisterAction <T>("Top", $"Composer.Queries.{searchQueryType}.Top") .AddParameter("QueryName", typeof(string), label: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.QueryNameLabel"), helpText: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.QueryNameHelp"), isRequired: true, widgetFunctionProvider: searhQueryListWidgetFunctionProvider ) .AddParameter("Number", typeof(string), label: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.NumberLabel"), helpText: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.NumberHelp") ); functions.RegisterAction <T>("SelectedSearchFacets", $"Composer.Queries.{searchQueryType}.SelectedFacets") .AddParameter("QueryName", typeof(string), label: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.QueryNameLabel"), helpText: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.QueryNameHelp"), isRequired: true, widgetFunctionProvider: searhQueryListWidgetFunctionProvider ); functions.RegisterAction <T>("Facets", $"Composer.Queries.{searchQueryType}.Facets") .AddParameter("QueryName", typeof(string), label: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.QueryNameLabel"), helpText: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.QueryNameHelp"), isRequired: true, widgetFunctionProvider: searhQueryListWidgetFunctionProvider ); functions.RegisterAction <T>("ChildCategories", $"Composer.Queries.{searchQueryType}.ChildCategories") .AddParameter("QueryName", typeof(string), label: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.QueryNameLabel"), helpText: StringResourceSystemFacade.GetString("Orckestra.ExperienceManagement.SearchQueryBuilder", "Parameters.QueryNameHelp"), isRequired: true, widgetFunctionProvider: searhQueryListWidgetFunctionProvider ); }
public MvcFunctionBuilder AddParameter(string name, Type type = null, bool?isRequired = null, BaseValueProvider defaultValueProvider = null, string label = null, string helpText = null, WidgetFunctionProvider widgetFunctionProvider = null, bool hideInSimpleView = false) { Verify.ArgumentNotNullOrEmpty(name, "name"); var info = _function.GetParameterInformation().FirstOrDefault(p => string.Equals(p.Name, name, StringComparison.OrdinalIgnoreCase)); var reflectedInfo = info != null?GetParameterDefaults(info) : null; if (type == null) { Verify.IsNotNull(reflectedInfo, "Failed to find the type of the parameter '{0}' through reflection", name); type = reflectedInfo.Type; } if (label == null) { label = name; } if (helpText == null) { helpText = String.Empty; } bool isRequired2 = isRequired ?? reflectedInfo?.IsRequired ?? false; if (defaultValueProvider == null) { defaultValueProvider = reflectedInfo != null ? (BaseValueProvider) new ConstantValueProvider(reflectedInfo.DefaultValue) : new NoValueValueProvider(); } widgetFunctionProvider = widgetFunctionProvider ?? StandardWidgetFunctions.GetDefaultWidgetFunctionProviderByType(type, isRequired2); _function.AddParameter(new ParameterProfile(name, type, isRequired2, defaultValueProvider, widgetFunctionProvider, label, new HelpDefinition(helpText), hideInSimpleView)); return(this); }