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);
}
