private void SetOutput(IFormFlowWebRenderingService formFlowWebRenderingService, string text)
 {
     Control output = new LiteralControl("<pre>" + HttpUtility.HtmlEncode(text) + "</pre>");
     formFlowWebRenderingService.SetNewPageOutput(output);
 }
        private void editCodeActivity_Preview_ExecuteCode(object sender, EventArgs e)
        {
            IInlineFunction functionInfo       = this.GetBinding <IInlineFunction>("Function");
            string          code               = this.GetBinding <string>("FunctionCode");
            List <string>   selectedAssemblies = this.GetBinding <List <string> >("SelectedAssemblies");

            StringInlineFunctionCreateMethodErrorHandler handler = new StringInlineFunctionCreateMethodErrorHandler();

            MethodInfo methodInfo = InlineFunctionHelper.Create(functionInfo, code, handler, selectedAssemblies);

            FlowControllerServicesContainer serviceContainer            = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
            IFormFlowWebRenderingService    formFlowWebRenderingService = serviceContainer.GetService <IFormFlowWebRenderingService>();

            if (handler.HasErrors)
            {
                StringBuilder sb = new StringBuilder();

                if (!string.IsNullOrWhiteSpace(handler.MissingContainerType))
                {
                    AddFormattedTextBlock(sb, handler.MissingContainerType);
                }

                if (!string.IsNullOrWhiteSpace(handler.NamespaceMismatch))
                {
                    AddFormattedTextBlock(sb, handler.NamespaceMismatch);
                }

                if (!string.IsNullOrWhiteSpace(handler.MissionMethod))
                {
                    AddFormattedTextBlock(sb, handler.MissionMethod);
                }

                if (handler.LoadingException != null)
                {
                    AddFormattedTextBlock(sb, handler.LoadingException.ToString());
                }

                foreach (Tuple <int, string, string> compileError in handler.CompileErrors)
                {
                    AddFormattedTextBlock(sb, "{0} : {1} : {2}".FormatWith(compileError.Item1, compileError.Item2, compileError.Item3));
                }

                formFlowWebRenderingService.SetNewPageOutput(new LiteralControl(sb.ToString()));

                return;
            }

            List <ManagedParameterDefinition> parameters = this.GetBinding <List <ManagedParameterDefinition> >("Parameters");

            List <object> parameterValues        = new List <object>();
            bool          parameterErrors        = false;
            StringBuilder parameterErrorMessages = new StringBuilder();

            foreach (ParameterInfo parameterInfo in methodInfo.GetParameters())
            {
                ManagedParameterDefinition parameter = parameters.FirstOrDefault(f => f.Name == parameterInfo.Name);
                if (parameter == null)
                {
                    string message = string.Format(GetText("CSharpInlineFunction.MissingParameterDefinition"), parameterInfo.Name);

                    parameterErrors = true;
                    AddFormattedTextBlock(parameterErrorMessages, message);
                }
                else if (parameter.Type != parameterInfo.ParameterType)
                {
                    string message = string.Format(GetText("CSharpInlineFunction.WrongParameterTestValueType"), parameterInfo.Name, parameterInfo.ParameterType, parameter.Type);

                    parameterErrors = true;
                    AddFormattedTextBlock(parameterErrorMessages, message);
                }
                else
                {
                    string previewValueFunctionMarkup = (string.IsNullOrEmpty(parameter.TestValueFunctionMarkup) ? parameter.DefaultValueFunctionMarkup : parameter.TestValueFunctionMarkup);

                    if (string.IsNullOrEmpty(previewValueFunctionMarkup))
                    {
                        string message = string.Format(GetText("CSharpInlineFunction.MissingParameterTestOrDefaultValue"), parameterInfo.Name, parameterInfo.ParameterType, parameter.Type);

                        parameterErrors = true;
                        AddFormattedTextBlock(parameterErrorMessages, message);
                    }
                    else
                    {
                        try
                        {
                            BaseRuntimeTreeNode treeNode = FunctionFacade.BuildTree(XElement.Parse(previewValueFunctionMarkup));
                            object value      = treeNode.GetValue();
                            object typedValue = ValueTypeConverter.Convert(value, parameter.Type);
                            parameterValues.Add(typedValue);
                        }
                        catch (Exception ex)
                        {
                            string message = string.Format("Error setting '{0}'. {1}", parameterInfo.Name, ex.Message);

                            parameterErrors = true;
                            AddFormattedTextBlock(parameterErrorMessages, message);
                        }
                    }
                }
            }

            if (parameterErrors)
            {
                formFlowWebRenderingService.SetNewPageOutput(new LiteralControl(parameterErrorMessages.ToString()));
                return;
            }

            CultureInfo oldCurrentCulture   = Thread.CurrentThread.CurrentCulture;
            CultureInfo oldCurrentUICulture = Thread.CurrentThread.CurrentUICulture;

            try
            {
                Guid pageId;
                if (this.GetBinding <object>("PageId") == null)
                {
                    pageId = Guid.Empty;
                }
                else
                {
                    pageId = this.GetBinding <Guid>("PageId");
                }
                string      dataScopeName = this.GetBinding <string>("PageDataScopeName");
                string      cultureName   = this.GetBinding <string>("ActiveCultureName");
                CultureInfo cultureInfo   = null;
                if (cultureName != null)
                {
                    cultureInfo = CultureInfo.CreateSpecificCulture(cultureName);
                }

                using (new DataScope(DataScopeIdentifier.Deserialize(dataScopeName), cultureInfo))
                {
                    Thread.CurrentThread.CurrentCulture = Thread.CurrentThread.CurrentUICulture = cultureInfo;

                    IPage page = DataFacade.GetData <IPage>(f => f.Id == pageId).FirstOrDefault();
                    if (page != null)
                    {
                        PageRenderer.CurrentPage = page;
                    }

                    object result = methodInfo.Invoke(null, parameterValues.ToArray());

                    string resultString;

                    try
                    {
                        resultString = PrettyPrinter.Print(result);
                    }
                    catch (Exception ex)
                    {
                        throw new TargetInvocationException(ex);
                    }

                    SetOutput(formFlowWebRenderingService, resultString);
                }
            }
            catch (TargetInvocationException ex)
            {
                SetOutput(formFlowWebRenderingService, ex.InnerException.ToString());
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture   = oldCurrentCulture;
                Thread.CurrentThread.CurrentUICulture = oldCurrentUICulture;
            }
        }
        private void SetOutput(IFormFlowWebRenderingService formFlowWebRenderingService, string text)
        {
            Control output = new LiteralControl("<pre>" + HttpUtility.HtmlEncode(text) + "</pre>");

            formFlowWebRenderingService.SetNewPageOutput(output);
        }
Example #4
0
        private void editCodeActivity_Preview_ExecuteCode(object sender, EventArgs e)
        {
            Guid pageId;

            if (this.GetBinding <object>("PageId") == null)
            {
                pageId = Guid.Empty;
            }
            else
            {
                pageId = this.GetBinding <Guid>("PageId");
            }

            string dataScopeName = this.GetBinding <string>("PageDataScopeName");
            string cultureName   = this.GetBinding <string>("ActiveCultureName");


            // Setting debug page
            IPage oldPage = PageRenderer.CurrentPage;
            IPage page    = DataFacade.GetData <IPage>(f => f.Id == pageId).FirstOrDefault();

            if (page != null)
            {
                PageRenderer.CurrentPage = page;
            }


            // Setting debug culture
            CultureInfo oldCurrentCulture   = Thread.CurrentThread.CurrentCulture;
            CultureInfo oldCurrentUICulture = Thread.CurrentThread.CurrentUICulture;
            CultureInfo cultureInfo         = null;

            if (cultureName != null)
            {
                cultureInfo = CultureInfo.CreateSpecificCulture(cultureName);
            }
            if (cultureInfo != null)
            {
                Thread.CurrentThread.CurrentCulture   = cultureInfo;
                Thread.CurrentThread.CurrentUICulture = cultureInfo;
            }

            List <NamedFunctionCall> namedFunctionCalls = GetBinding <List <NamedFunctionCall> >("FunctionCalls");

            StringBuilder output = new StringBuilder();

            foreach (NamedFunctionCall namedFunctionCall in namedFunctionCalls)
            {
                output.AppendLine(namedFunctionCall.FunctionCall.GetCompositeName() + " result:");

                object functionResult;
                try
                {
                    // Setting debug data scope
                    using (new DataScope(DataScopeIdentifier.Deserialize(dataScopeName), cultureInfo))
                    {
                        functionResult = namedFunctionCall.FunctionCall.GetValue();
                    }
                }
                catch (Exception ex)
                {
                    StringBuilder sb = new StringBuilder();
                    while (ex != null)
                    {
                        sb.AppendLine(ex.ToString());
                        ex = ex.InnerException;
                    }

                    functionResult = sb.ToString();
                }


                output.AppendLine(PrettyPrinter.Print(functionResult));

                output.AppendLine();
            }

            // Restore culture
            Thread.CurrentThread.CurrentCulture   = oldCurrentCulture;
            Thread.CurrentThread.CurrentUICulture = oldCurrentUICulture;

            // Page should not be restored

            FlowControllerServicesContainer serviceContainer            = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
            IFormFlowWebRenderingService    formFlowWebRenderingService = serviceContainer.GetService <IFormFlowWebRenderingService>();

            Control outputControl = new LiteralControl("<pre>" + HttpUtility.HtmlEncode(output) + "</pre>");

            formFlowWebRenderingService.SetNewPageOutput(outputControl);
        }