public XElement GetDefaultMarkup(Field field)
{
var result = new XElement("Field", new XAttribute("name", field.Name));
string functionName = (string)field.FunctionNode.Attribute("name");
IFunction function;
if (functionName != null &&
FunctionFacade.TryGetFunction(out function, functionName))
{
if (function.ParameterProfiles.Any(p => p.Name == "Name" && p.IsRequired))
{
result.Add(new XElement(Namespaces.Function10 + "param",
new XAttribute("name", "Name"),
new XAttribute("value", StringResourceSystemFacade.ParseString(field.Label))));
}
if (function.ParameterProfiles.Any(p => p.Name == "Label"))
{
result.Add(new XElement(Namespaces.Function10 + "param",
new XAttribute("name", "Label"),
new XAttribute("value", StringResourceSystemFacade.ParseString(field.Label))));
}
}
return(result);
}
private object TryExecuteFunction(XElement functionNode)
{
try
{
var tree = FunctionFacade.BuildTree(functionNode);
using (new FakeHttpContext())
{
if (_page != null)
{
PageRenderer.CurrentPage = _page;
C1PageRoute.PageUrlData = new PageUrlData(_page);
}
PageRenderer.RenderingReason = RenderingReason.BuildSearchIndex;
return(tree.GetValue(new FunctionContextContainer
{
SuppressXhtmlExceptions = false
}));
}
}
catch (Exception)
{
return(null);
}
}
private void ValidateFunctionName(object sender, ConditionalEventArgs e)
{
IInlineFunction function = this.GetBinding <IInlineFunction>("NewFunction");
bool exists = FunctionFacade.FunctionExists(function.Namespace, function.Name);
if (exists)
{
string errorMessage = StringResourceSystemFacade.GetString("Composite.Plugins.MethodBasedFunctionProviderElementProvider", "AddFunction.NameAlreadyUsed");
errorMessage = string.Format(errorMessage, FunctionFacade.GetFunctionCompositionName(function.Namespace, function.Name));
ShowFieldMessage("NewFunction.Name", errorMessage);
e.Result = false;
return;
}
ValidationResults validationResults = ValidationFacade.Validate <IInlineFunction>(function);
if (!validationResults.IsValid)
{
foreach (ValidationResult result in validationResults)
{
this.ShowFieldMessage(string.Format("{0}.{1}", "NewFunction", result.Key), result.Message);
}
e.Result = false;
return;
}
e.Result = true;
}
private bool BasicViewApplicable(ICollection <XElement> functionCallsEvaluated)
{
// Basic view is enabled if
// - Only one function is being edited
// - here's no parameters defined as function calls
// - And there no required parameters without widgets
if (MultiMode || IsWidgetSelection || functionCallsEvaluated.Count != 1)
{
return(false);
}
var functionMarkup = functionCallsEvaluated.Single();
if (functionMarkup
.Elements()
.Any(childElement => childElement.Elements().Any(e => e.Name.LocalName == "function")))
{
return(false);
}
string functionName = (string)functionMarkup.Attribute("name");
var function = FunctionFacade.GetFunction(functionName);
if (function == null)
{
return(false);
}
return(!function.ParameterProfiles.Any(p => p.IsRequired && p.WidgetFunction == null && !p.IsInjectedValue));
}
public void ProcessRequest(HttpContext context)
{
// Get the name of the function to execute by copying the current file name
// (without the .ashx extension)
string functionName = Path.GetFileNameWithoutExtension(context.Request.Path);
// Locate the data culture to use - like en-US or nl-NL
CultureInfo dataCulture = GetCurrentDataCulture(context);
using (DataScope dataScope = new DataScope(DataScopeIdentifier.Public, dataCulture))
{
// Grab a function object to execute
IFunction function = FunctionFacade.GetFunction(functionName);
// Execute the function, passing all query string parameters as input parameters
object functionResult = FunctionFacade.Execute <object>(function, context.Request.QueryString);
// output result
if (functionResult != null)
{
context.Response.Write(functionResult.ToString());
if (functionResult is XNode && function.ReturnType != typeof(Composite.Core.Xml.XhtmlDocument))
{
context.Response.ContentType = "text/xml";
}
}
}
}
private void GetFunctionCode(string copyFromFunctionName, out string markupTemplate, out string code)
{
IFunction function = FunctionFacade.GetFunction(copyFromFunctionName);
if (function is FunctionWrapper)
{
function = (function as FunctionWrapper).InnerFunction;
}
var razorFunction = (UserControlBasedFunction)function;
string filePath = PathUtil.Resolve(razorFunction.VirtualPath);
string codeFilePath = filePath + ".cs";
Verify.That(C1File.Exists(codeFilePath), "Codebehind file not found: {0}", codeFilePath);
markupTemplate = C1File.ReadAllText(filePath);
code = C1File.ReadAllText(codeFilePath);
const string quote = "\"";
string codeFileReference = quote + Path.GetFileName(codeFilePath) + quote;
int codeReferenceOffset = markupTemplate.IndexOf(codeFileReference, StringComparison.OrdinalIgnoreCase);
Verify.That(codeReferenceOffset > 0, "Failed to find codebehind file reference '{0}'".FormatWith(codeFileReference));
markupTemplate = markupTemplate.Replace(codeFileReference,
quote + Marker_CodeFile + quote,
StringComparison.OrdinalIgnoreCase);
}
public static IEnumerable GetOptions(string optionsDescriptorSerialized)
{
XElement optionsDescriptor = XElement.Parse(optionsDescriptorSerialized);
string keyFieldName = optionsDescriptor.Attribute("KeyFieldName").Value;
string labelFieldName = optionsDescriptor.Attribute("LabelFieldName").Value;
XElement treeNodeElement = optionsDescriptor.Element("TreeNode").Elements().First();
BaseRuntimeTreeNode runtimeTreeNode = FunctionFacade.BuildTree(treeNodeElement);
IEnumerable optionsSource = runtimeTreeNode.GetValue <IEnumerable>();
if (optionsSource is IEnumerable <XElement> )
{
IEnumerable <XElement> optionElements = (IEnumerable <XElement>)optionsSource;
foreach (XElement optionElement in optionElements)
{
yield return(new
{
Key = optionElement.Attribute(keyFieldName).Value,
Label = optionElement.Attribute(labelFieldName).Value
});
}
}
else if (optionsSource is IDictionary)
{
IDictionary optionsDictionary = (IDictionary)optionsSource;
foreach (var optionKey in optionsDictionary.Keys)
{
yield return(new { Key = optionKey, Label = optionsDictionary[optionKey] });
}
}
else if (string.IsNullOrEmpty(keyFieldName) == false || string.IsNullOrEmpty(labelFieldName))
{
foreach (object optionObject in optionsSource)
{
if (optionObject != null)
{
Type objectType = optionObject.GetType();
string key = (string.IsNullOrEmpty(keyFieldName) ?
optionObject.ToString() :
objectType.GetProperty(keyFieldName).GetValue(optionObject, null).ToString());
string label = (string.IsNullOrEmpty(labelFieldName) ?
optionObject.ToString() :
objectType.GetProperty(labelFieldName).GetValue(optionObject, null).ToString());
yield return(new { Key = key, Label = label });
}
}
}
else
{
foreach (var option in optionsSource)
{
yield return(new { Key = option, Label = option });
}
}
}
public void ProcessRequest(HttpContext context)
{
var functionName = (string)context.Request.RequestContext.RouteData.Values["function"];
var dataCulture = GetCurrentDataCulture(context);
using (var data = new DataConnection())
{
if (!data.Get <IFunctionRoute>().Any())
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
}
IFunction function;
if (!FunctionFacade.TryGetFunction(out function, functionName))
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
using (var dataScope = new DataScope(DataScopeIdentifier.Public, dataCulture))
{
var functionResult = FunctionFacade.Execute <object>(function, context.Request.QueryString);
if (functionResult == null)
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
var xhtmlDocument = functionResult as XhtmlDocument;
if (xhtmlDocument != null)
{
PageRenderer.ExecuteEmbeddedFunctions(xhtmlDocument.Root, new FunctionContextContainer());
PageRenderer.NormalizeXhtmlDocument(xhtmlDocument);
var xhtml = xhtmlDocument.ToString();
xhtml = PageUrlHelper.ChangeRenderingPageUrlsToPublic(functionResult.ToString());
xhtml = MediaUrlHelper.ChangeInternalMediaUrlsToPublic(xhtml);
context.Response.Write(xhtml);
}
else
{
context.Response.Write(functionResult.ToString());
if (functionResult is XNode && function.ReturnType != typeof(XhtmlDocument))
{
context.Response.ContentType = "text/xml";
}
}
}
}
public object GetResult()
{
IFunction function = FunctionFacade.GetFunction(this.name);
FunctionRuntimeTreeNode functionNode = new FunctionRuntimeTreeNode(function, this.Producers);
return(functionNode);
}
/// <summary>
/// Executes all cacheable (not dynamic) functions and returns <value>True</value>
/// if all of the functions were cacheable.
/// </summary>
/// <param name="element"></param>
/// <param name="functionContext"></param>
/// <returns></returns>
internal static bool ExecuteCacheableFunctions(XElement element, FunctionContextContainer functionContext)
{
return(ExecuteFunctionsRec(element, functionContext, name =>
{
var function = FunctionFacade.GetFunction(name);
return !(function is IDynamicFunction df && df.PreventFunctionOutputCaching);
}));
}
/// <exclude />
public static IMetaFunction GetFunction(XElement functionNode)
{
string functionName = functionNode.Attribute("name").Value;
if (functionNode.Name == WidgetFunctionNodeName)
{
return(FunctionFacade.GetWidgetFunction(functionName));
}
return(FunctionFacade.GetFunction(functionName));
}
/// <summary>
/// Executes the function.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="functionContextContainer">The function context container</param>
/// <returns></returns>
public static object ExecuteFunction(string name, IDictionary <string, object> parameters, FunctionContextContainer functionContextContainer)
{
IFunction function;
if (!FunctionFacade.TryGetFunction(out function, name))
{
throw new InvalidOperationException("Failed to load function '{0}'".FormatWith(name));
}
functionContextContainer = functionContextContainer ?? new FunctionContextContainer();
return(FunctionFacade.Execute <object>(function, parameters, functionContextContainer));
}
/// <exclude />
public static FormTreeCompiler BuildWidgetForParameters(IEnumerable <ParameterProfile> parameterProfiles, Dictionary <string, object> bindings, string uniqueName, string panelLabel, IFormChannelIdentifier channelIdentifier)
{
XNamespace stdControlLibSpace = Namespaces.BindingFormsStdUiControls10;
var bindingsDeclaration = new XElement(Namespaces.BindingForms10 + "bindings");
var widgetPlaceholder = new XElement(stdControlLibSpace + "FieldGroup", new XAttribute("Label", panelLabel));
var bindingsValidationRules = new Dictionary <string, List <ClientValidationRule> >();
foreach (ParameterProfile parameterProfile in parameterProfiles.Where(f => f.WidgetFunction != null))
{
IWidgetFunction widgetFunction = parameterProfile.WidgetFunction;
Type bindingType = widgetFunction != null && parameterProfile.Type.IsLazyGenericType() ?
widgetFunction.ReturnType : parameterProfile.Type;
bindingsDeclaration.Add(
new XElement(Namespaces.BindingForms10 + "binding",
new XAttribute("optional", true),
new XAttribute("name", parameterProfile.Name),
new XAttribute("type", bindingType.AssemblyQualifiedName)));
var context = new FunctionContextContainer();
XElement uiMarkup = FunctionFacade.GetWidgetMarkup(widgetFunction, parameterProfile.Type, parameterProfile.WidgetFunctionParameters, parameterProfile.Label, parameterProfile.HelpDefinition, parameterProfile.Name, context);
widgetPlaceholder.Add(uiMarkup);
if (!bindings.ContainsKey(parameterProfile.Name))
{
bindings.Add(parameterProfile.Name, "");
}
if (parameterProfile.IsRequired)
{
bindingsValidationRules.Add(parameterProfile.Name, new List <ClientValidationRule> {
new NotNullClientValidationRule()
});
}
}
FormDefinition widgetFormDefinition = BuildFormDefinition(bindingsDeclaration, widgetPlaceholder, bindings);
var compiler = new FormTreeCompiler();
using (XmlReader reader = widgetFormDefinition.FormMarkup)
{
compiler.Compile(reader, channelIdentifier, widgetFormDefinition.Bindings, false, "WidgetParameterSetters" + uniqueName, bindingsValidationRules);
}
return(compiler);
}
protected override IEnumerable <IFunctionTreeBuilderLeafInfo> OnGetFunctionInfos(SearchToken searchToken)
{
var functions = FunctionFacade.GetFunctionsByProvider(_functionProviderName);
if (searchToken != null && !string.IsNullOrEmpty(searchToken.Keyword))
{
string keyword = searchToken.Keyword.ToLowerInvariant();
functions = functions.Where(f => f.Namespace.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) > 0 ||
f.Name.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) > 0);
}
return(functions.Select(f => new RazorFunctionTreeBuilderLeafInfo(f)));
}
private void prepareFunctionObject_codeActivity_ExecuteCode(object sender, EventArgs e)
{
DataTypeDescriptor dataTypeDescriptor = GetDataTypeDescriptor();
var function = DataFacade.BuildNew <IVisualFunction>();
function.Id = Guid.NewGuid();
function.Name = FunctionFacade.BuildUniqueFunctionName(dataTypeDescriptor.Namespace, string.Format("{0}Rendering", dataTypeDescriptor.Name));
function.Namespace = dataTypeDescriptor.Namespace;
function.TypeManagerName = dataTypeDescriptor.TypeManagerTypeName;
function.Description = "";
this.UpdateBinding("Function", function);
}
private void LoadParameterProfiles(ActionInformation action)
{
XElement functionNode = action.ConfigurationElement.FunctionNode;
string functionName = (string)functionNode.Attribute("name");
IFunction function = FunctionFacade.GetFunction(functionName);
Verify.IsNotNull(function, "Failed to get C1 function '{0}'", functionName);
List <string> predefinedParameterNames = functionNode.Elements().Select(el => (string)el.Attribute("name")).ToList();
action.ParameterProfiles = function.ParameterProfiles.Where(p => !predefinedParameterNames.Contains(p.Name)).ToArray();
}
private IMetaFunction GetMetaFunction(string metaFunctionName)
{
switch (_providerType)
{
case FunctionsProviderType:
return(FunctionFacade.GetFunction(metaFunctionName));
case WidgetFunctionsProviderType:
return(FunctionFacade.GetWidgetFunction(metaFunctionName));
default:
throw new NotImplementedException();
}
}
protected override IFunctionTreeBuilderLeafInfo OnIsEntityOwner(EntityToken entityToken)
{
if (entityToken is FileBasedFunctionEntityToken && entityToken.Source == _functionProviderName)
{
string functionFullName = entityToken.Id;
IFunction function = FunctionFacade.GetFunctionsByProvider(_functionProviderName)
.FirstOrDefault(func => func.Namespace + "." + func.Name == functionFullName);
return(function == null ? null : new RazorFunctionTreeBuilderLeafInfo(function));
}
return(null);
}
public IEnumerable <ElementAction> GetActions(EntityToken entityToken)
{
string fullName = FavoriteFunctionWrapper.GetFunctionNameFromEntityToken(entityToken);
if (!String.IsNullOrEmpty(fullName))
{
IFunction function;
if (FunctionFacade.TryGetFunction(out function, fullName))
{
yield return(createAction(fullName));
}
}
}
/// <exclude />
public static string[] GetParameterNames(XElement functionXElement)
{
if (functionXElement.Name != FunctionNodeName && functionXElement.Name != WidgetFunctionNodeName)
{
return(new string[0]);
}
string functionName = functionXElement.Attribute("name").Value;
IMetaFunction function = (functionXElement.Name == FunctionNodeName)
? (IMetaFunction)FunctionFacade.GetFunction(functionName)
: FunctionFacade.GetWidgetFunction(functionName);
return(function.ParameterProfiles.Select(parameter => parameter.Name).ToArray());
}
private string GetFunctionCode(string copyFromFunction)
{
IFunction function = FunctionFacade.GetFunction(copyFromFunction);
if (function is FunctionWrapper)
{
function = (function as FunctionWrapper).InnerFunction;
}
var razorFunction = (RazorBasedFunction)function;
string filePath = PathUtil.Resolve(razorFunction.VirtualPath);
return(C1File.ReadAllText(filePath));
}
public static void SetDefaultValues(IModelInstance instance)
{
var def = GetFormByName(instance.Name);
foreach (var field in instance.Fields)
{
if (!def.DefaultValues.TryGetValue(field.Name, out var defaultValueSetter))
{
continue;
}
var runtimeTree = FunctionFacade.BuildTree(defaultValueSetter);
field.Value = runtimeTree.GetValue();
}
}
private void initalizeStateCodeActivity_Initialize_ExecuteCode(object sender, EventArgs e)
{
List <NamedFunctionCall> namedFunctionCalls = new List <NamedFunctionCall>();
if (Payload != "")
{
IFunction function = FunctionFacade.GetFunction(Payload);
BaseRuntimeTreeNode baseRuntimeTreeNode = FunctionFacade.BuildTree(function, new Dictionary <string, object>());
NamedFunctionCall namedFunctionCall = new NamedFunctionCall("", (BaseFunctionRuntimeTreeNode)baseRuntimeTreeNode);
namedFunctionCalls.Add(namedFunctionCall);
string layoutLabel = string.Format(StringResourceSystemFacade.GetString("Composite.Plugins.AllFunctionsElementProvider", "FunctionTesterWorkflow.Layout.Label"), function.Name);
this.Bindings.Add("LayoutLabel", layoutLabel);
}
this.Bindings.Add("FunctionCalls", namedFunctionCalls);
this.Bindings.Add("Parameters", new List <ManagedParameterDefinition>());
this.Bindings.Add("PageId", PageManager.GetChildrenIDs(Guid.Empty).FirstOrDefault());
if (UserSettings.ActiveLocaleCultureInfo != null)
{
List <KeyValuePair <string, string> > activeCulturesDictionary = UserSettings.ActiveLocaleCultureInfos.Select(f => new KeyValuePair <string, string>(f.Name, DataLocalizationFacade.GetCultureTitle(f))).ToList();
this.Bindings.Add("ActiveCultureName", UserSettings.ActiveLocaleCultureInfo.Name);
this.Bindings.Add("ActiveCulturesList", activeCulturesDictionary);
}
this.Bindings.Add("PageDataScopeName", DataScopeIdentifier.AdministratedName);
this.Bindings.Add("PageDataScopeList", new Dictionary <string, string>
{
{ DataScopeIdentifier.AdministratedName, StringResourceSystemFacade.GetString("Composite.Plugins.AllFunctionsElementProvider", "FunctionTesterWorkflow.AdminitrativeScope.Label") },
{ DataScopeIdentifier.PublicName, StringResourceSystemFacade.GetString("Composite.Plugins.AllFunctionsElementProvider", "FunctionTesterWorkflow.PublicScope.Label") }
});
Guid stateId = Guid.NewGuid();
var state = new FunctionCallDesignerState {
WorkflowId = WorkflowInstanceId, ConsoleIdInternal = GetCurrentConsoleId()
};
SessionStateManager.DefaultProvider.AddState <IFunctionCallEditorState>(stateId, state, DateTime.Now.AddDays(7.0));
this.Bindings.Add("SessionStateProvider", SessionStateManager.DefaultProviderName);
this.Bindings.Add("SessionStateId", stateId);
}
public IEnumerable <ElementAction> Provide(EntityToken entityToken)
{
var functionName = entityToken.Id;
if (!functionName.Contains("."))
{
yield break;
}
IFunction function;
if (!FunctionFacade.TryGetFunction(out function, functionName))
{
yield break;
}
var message = (string)null;
var icon = (string)null;
using (var data = new DataConnection())
{
var route = data.Get <IFunctionRoute>().SingleOrDefault(r => r.Function == functionName);
if (route == null)
{
message = "Enable Function Route";
icon = "accept";
}
else
{
message = "Disable Function Route";
icon = "delete";
}
}
var actionToken = new ToggleFunctionRouteActionToken(functionName);
yield return(new ElementAction(new ActionHandle(actionToken))
{
VisualData = new ActionVisualizedData
{
Label = message,
ToolTip = message,
Icon = new ResourceHandle("Composite.Icons", icon),
ActionLocation = ActionLocation.OtherPrimaryActionLocation
}
});
}
private void LoadParameterProfiles()
{
string elementName = (string)_fieldXml.Attribute("name");
Verify.ArgumentNotNullOrEmpty(elementName, "Missing element name");
var allElements = FormBuilderConfiguration.GetFieldMap();
Verify.That(allElements.ContainsKey(elementName), "Undeclared form element 'elementName'");
var element = allElements[elementName];
string functionName = (string)element.FunctionNode.Attribute("name");
IFunction function = FunctionFacade.GetFunction(functionName);
Verify.IsNotNull(function, "Failed to get C1 function '{0}'", functionName);
List <string> predefinedParameterNames = element.FunctionNode.Elements().Select(el => (string)el.Attribute("name")).ToList();
_fieldConfiguration = element;
_parameterProfiles = function.ParameterProfiles.Where(p => !predefinedParameterNames.Contains(p.Name)).ToArray();
_standardParameters = new ParameterGroup {
ParameterProfiles = _parameterProfiles.Where(p =>
!_fieldConfiguration.DescriptionParameters.Contains(p.Name) &&
!_fieldConfiguration.ValidationParameters.Contains(p.Name) &&
!_fieldConfiguration.AdvancedParameters.Contains(p.Name)).ToArray()
};
_descriptionParameters = new ParameterGroup
{
ParameterProfiles = _parameterProfiles.Where(p => _fieldConfiguration.DescriptionParameters.Contains(p.Name)).ToArray()
};
_validationParameters = new ParameterGroup
{
ParameterProfiles = _parameterProfiles.Where(p => _fieldConfiguration.ValidationParameters.Contains(p.Name)).ToArray()
};
_advancedParameters = new ParameterGroup {
ParameterProfiles = _parameterProfiles.Where(p => _fieldConfiguration.AdvancedParameters.Contains(p.Name)).ToArray()
};
}
private void ProcessFunctionCall(XElement functionNode)
{
var functionName = functionNode.GetAttributeValue("name");
if (functionName == null)
{
return;
}
IFunction function;
try
{
function = FunctionFacade.GetFunction(functionName);
if (function == null)
{
return;
}
}
catch
{
return;
}
foreach (var paramElement in functionNode.Elements())
{
var parameterName = paramElement.GetAttributeValue("name");
if (parameterName == null)
{
continue;
}
var profile = function.ParameterProfiles.FirstOrDefault(p => p.Name == parameterName);
if (profile != null)
{
if (profile.Type == typeof(XhtmlDocument))
{
ProcessElement(paramElement);
}
// TODO: handle the other parameter types
}
}
}
private object GetValue(FunctionContextContainer functionContextContainer, out Type returnType)
{
string functionName = Name;
IFunction function;
if (!FunctionFacade.TryGetFunction(out function, functionName))
{
throw new InvalidOperationException("Invalid function name '{0}'".FormatWith(functionName));
}
returnType = function.ReturnType;
IDictionary <string, object> parameters = parseParameters(functionContextContainer);
VerifyParameterMatch(function, parameters);
return(ExecuteFunction(function, parameters, functionContextContainer));
}
internal void GetProviderAndFunction <FunctionType>(
FileBasedFunctionEntityToken entityToken,
out FileBasedFunctionProvider <FunctionType> provider,
out FileBasedFunction <FunctionType> function) where FunctionType : FileBasedFunction <FunctionType>
{
string functionProviderName = entityToken.FunctionProviderName;
provider = (FileBasedFunctionProvider <FunctionType>)FunctionProviderPluginFacade.GetFunctionProvider(functionProviderName);
IFunction func = FunctionFacade.GetFunction(entityToken.FunctionName);
Verify.IsNotNull(func, "Failed to get function '{0}'", entityToken.FunctionName);
if (func is FunctionWrapper)
{
func = (func as FunctionWrapper).InnerFunction;
}
function = (FileBasedFunction <FunctionType>)func;
}
public void Pack(PackageCreator pc)
{
IFunction function = null;
if (FunctionFacade.TryGetFunction(out function, this.Id))
{
var innerFunction = function.GetProperty <IFunction>("InnerFunction");
var innerFunctionTypeName = innerFunction.GetType().Name;
switch (innerFunctionTypeName)
{
case "MethodBasedFunction":
PackCSharpFunction(pc);
break;
case "LazyInitializedInlineFunction":
case "InlineFunction":
PackInlineFunction(pc);
break;
case "RazorBasedFunction":
PackRazorFunction(pc, innerFunction);
break;
case "UserControlBasedFunction":
PackUserControlFunction(pc, innerFunction);
break;
case "VisualFunction`1":
PackVisualFunction(pc);
break;
case "XsltXmlFunction":
PackXsltFunction(pc);
break;
}
}
else
{
throw new InvalidOperationException(string.Format("Function '{0}' does not exists", this.Name));
}
}
private void initializeCodeActivity_ExecuteCode(object sender, EventArgs e)
{
BaseFunctionFolderElementEntityToken token = (BaseFunctionFolderElementEntityToken)this.EntityToken;
string @namespace = token.FunctionNamespace ?? UserSettings.LastSpecifiedNamespace;
this.Bindings.Add(Binding_Name, string.Empty);
this.Bindings.Add(Binding_Namespace, @namespace);
var functionProvider = GetFunctionProvider <UserControlFunctionProvider>();
var copyOfOptions = new List <KeyValuePair <string, string> >();
copyOfOptions.Add(new KeyValuePair <string, string>(string.Empty, GetText("AddNewUserControlFunction.LabelCopyFromEmptyOption")));
foreach (string functionName in FunctionFacade.GetFunctionNamesByProvider(functionProvider.Name))
{
copyOfOptions.Add(new KeyValuePair <string, string>(functionName, functionName));
}
this.Bindings.Add(Binding_CopyFromFunctionName, string.Empty);
this.Bindings.Add(Binding_CopyFromOptions, copyOfOptions);
}