private static void OnFinish(FlowToken flowToken, Dictionary <string, object> bindings, FlowControllerServicesContainer serviceContainer)
{
WorkflowFlowToken workflowFlowToken = (WorkflowFlowToken)flowToken;
using (TaskContainer taskContainer = TaskManagerFacade.RuntTasks(flowToken, new WorkflowTaskManagerEvent(flowToken, workflowFlowToken.WorkflowInstanceId)
{
EventName = "Finish"
}))
{
TaskManagerFlowControllerService taskManagerFlowControllerService = new TaskManagerFlowControllerService(taskContainer);
serviceContainer.AddService(taskManagerFlowControllerService);
WorkflowFacade.FireFinishEvent(workflowFlowToken.WorkflowInstanceId, bindings);
WorkflowFacade.SetFlowControllerServicesContainer(workflowFlowToken.WorkflowInstanceId, serviceContainer);
WorkflowFacade.RunWorkflow(workflowFlowToken.WorkflowInstanceId);
taskContainer.SetOnIdleTaskManagerEvent(new WorkflowTaskManagerEvent(flowToken, workflowFlowToken.WorkflowInstanceId));
}
IFormFlowRenderingService formServices = serviceContainer.GetService <IFormFlowRenderingService>();
if (!formServices.HasFieldMessages)
{
serviceContainer.GetService <IFormFlowRenderingService>().RerenderView();
}
}
/// <exclude />
public void UpdateTasksWithFlowToken(FlowToken flowToken)
{
foreach (Task task in _tasks)
{
task.FlowToken = flowToken.Serialize();
}
}
private static void OnCancel(FlowToken flowToken, Dictionary <string, object> bindings, FlowControllerServicesContainer serviceContainer)
{
WorkflowFlowToken workflowFlowToken = (WorkflowFlowToken)flowToken;
if (WorkflowFacade.WorkflowExists(workflowFlowToken.WorkflowInstanceId))
{
using (TaskManagerFacade.RuntTasks(flowToken, new WorkflowTaskManagerEvent(flowToken, workflowFlowToken.WorkflowInstanceId)
{
EventName = "Cancel"
}))
{
WorkflowFacade.FireCancelEvent(workflowFlowToken.WorkflowInstanceId, bindings);
WorkflowFacade.SetFlowControllerServicesContainer(workflowFlowToken.WorkflowInstanceId, serviceContainer);
WorkflowFacade.RunWorkflow(workflowFlowToken.WorkflowInstanceId);
}
}
else
{
Log.LogVerbose(LogTitle, "Cancel event suppressed because the workflow was terminated ({0})", workflowFlowToken.WorkflowInstanceId);
}
if (serviceContainer != null)
{
serviceContainer.GetService <IFormFlowRenderingService>().RerenderView();
}
}
/// <exclude />
public static Control GetFlowUi(FlowHandle flowHandle, string elementProviderName, string consoleId, out string uiContainerName)
{
uiContainerName = null;
try
{
Control webControl = null;
string viewId = ViewTransitionHelper.MakeViewId(flowHandle.Serialize());
FlowControllerServicesContainer flowServicesContainer = new FlowControllerServicesContainer();
flowServicesContainer.AddService(new ActionExecutionService(elementProviderName, consoleId));
flowServicesContainer.AddService(new ManagementConsoleMessageService(consoleId, viewId));
flowServicesContainer.AddService(new ElementDataExchangeService(elementProviderName));
FlowToken flowToken = flowHandle.FlowToken;
IFlowUiDefinition flowUiDefinition = FlowControllerFacade.GetCurrentUiDefinition(flowToken, flowServicesContainer);
var formFlowUiDefinition = flowUiDefinition as FormFlowUiDefinition;
if (formFlowUiDefinition != null)
{
uiContainerName = formFlowUiDefinition.UiContainerType.ContainerName;
IUiControl uiForm = FormFlowUiDefinitionRenderer.Render(consoleId, elementProviderName, flowToken, formFlowUiDefinition, WebManagementChannel.Identifier, false, flowServicesContainer);
IWebUiControl webForm = (IWebUiControl)uiForm;
webControl = webForm.BuildWebControl();
if (string.IsNullOrEmpty(webControl.ID))
{
webControl.ID = "FlowUI";
}
if (RuntimeInformation.TestAutomationEnabled)
{
var testAutomationLocatorInformation = formFlowUiDefinition.MarkupProvider as ITestAutomationLocatorInformation;
if (testAutomationLocatorInformation != null)
{
var htmlform = webControl.Controls.OfType <HtmlForm>().FirstOrDefault();
if (htmlform != null)
{
htmlform.Attributes.Add("data-qa", testAutomationLocatorInformation.TestAutomationLocator);
}
}
}
}
return(webControl);
}
catch (Exception ex)
{
ErrorServices.DocumentAdministrativeError(ex);
ErrorServices.RedirectUserToErrorPage(uiContainerName, ex);
}
return(new LiteralControl("ERROR"));
}
public TaskContainer RuntTasks(FlowToken flowToken, TaskManagerEvent taskManagerEvent)
{
string serializedFlowToken = flowToken.Serialize();
List <Task> tasks;
lock (_lock)
{
tasks = _tasks.Where(f => f.FlowToken == serializedFlowToken).ToList();
}
return(new TaskContainer(tasks, taskManagerEvent));
}
private static void OnPreview(FlowToken flowToken, Dictionary <string, object> bindings, FlowControllerServicesContainer serviceContainer)
{
WorkflowFlowToken workflowFlowToken = (WorkflowFlowToken)flowToken;
using (TaskContainer taskContainer = TaskManagerFacade.RuntTasks(flowToken, new WorkflowTaskManagerEvent(flowToken, workflowFlowToken.WorkflowInstanceId)
{
EventName = "Preview"
}))
{
WorkflowFacade.FirePreviewEvent(workflowFlowToken.WorkflowInstanceId, bindings);
WorkflowFacade.SetFlowControllerServicesContainer(workflowFlowToken.WorkflowInstanceId, serviceContainer);
WorkflowFacade.RunWorkflow(workflowFlowToken.WorkflowInstanceId);
taskContainer.SetOnIdleTaskManagerEvent(new WorkflowTaskManagerEvent(flowToken, workflowFlowToken.WorkflowInstanceId));
}
}
public void CompleteTasks(FlowToken flowToken)
{
string serializedFlowToken = flowToken.Serialize();
lock (_lock)
{
List <Task> tasks = _tasks.Where(f => f.FlowToken == serializedFlowToken).ToList();
foreach (Task task in tasks)
{
task.TaskManager.OnCompleted(task.Id, null);
_tasks.Remove(task);
DataFacade.Delete <ITaskItem>(f => f.TaskId == task.Id);
}
}
}
public void Execute(EntityToken entityToken, ActionToken actionToken, TaskManagerEvent taskManagerEvent)
{
var flowServicesContainer = new FlowControllerServicesContainer(
new ManagementConsoleMessageService(this.ConsoleId),
new ElementDataExchangeService(this.ElementProviderName),
this
);
FlowToken flowToken = ActionExecutorFacade.Execute(entityToken, actionToken, flowServicesContainer, taskManagerEvent);
IFlowUiDefinition uiDefinition = FlowControllerFacade.GetCurrentUiDefinition(flowToken, flowServicesContainer);
if (uiDefinition is FlowUiDefinitionBase flowUiDefinition)
{
string serializedEntityToken = EntityTokenSerializer.Serialize(entityToken, true);
ViewTransitionHelper.HandleNew(this.ConsoleId, this.ElementProviderName, serializedEntityToken, flowToken, flowUiDefinition);
}
}
public static void ExecuteElementAction(ElementHandle elementHandle, ActionHandle actionHandle, string consoleId)
{
var flowServicesContainer = new FlowControllerServicesContainer(
new ManagementConsoleMessageService(consoleId),
new ElementDataExchangeService(elementHandle.ProviderName),
new ActionExecutionService(elementHandle.ProviderName, consoleId),
new ElementInformationService(elementHandle)
);
FlowToken flowToken = ActionExecutorFacade.Execute(elementHandle.EntityToken, actionHandle.ActionToken, flowServicesContainer);
IFlowUiDefinition uiDefinition = FlowControllerFacade.GetCurrentUiDefinition(flowToken, flowServicesContainer);
if (uiDefinition is FlowUiDefinitionBase flowUiDefinition)
{
string serializedEntityToken = EntityTokenSerializer.Serialize(elementHandle.EntityToken, true);
ViewTransitionHelper.HandleNew(consoleId, elementHandle.ProviderName, serializedEntityToken, flowToken, flowUiDefinition);
}
}
private static void OnCustomEvent(int customEventNumber, FlowToken flowToken, Dictionary <string, object> bindings, FlowControllerServicesContainer serviceContainer)
{
if (customEventNumber < 1 || customEventNumber > 5)
{
throw new ArgumentException("Number must be between 1 and 5", nameof(customEventNumber));
}
WorkflowFlowToken workflowFlowToken = (WorkflowFlowToken)flowToken;
using (TaskContainer taskContainer = TaskManagerFacade.RuntTasks(flowToken, new WorkflowTaskManagerEvent(flowToken, workflowFlowToken.WorkflowInstanceId)
{
EventName = "CustomEvent0" + customEventNumber
}))
{
WorkflowFacade.FireCustomEvent(customEventNumber, workflowFlowToken.WorkflowInstanceId, bindings);
WorkflowFacade.SetFlowControllerServicesContainer(workflowFlowToken.WorkflowInstanceId, serviceContainer);
WorkflowFacade.RunWorkflow(workflowFlowToken.WorkflowInstanceId);
taskContainer.SetOnIdleTaskManagerEvent(new WorkflowTaskManagerEvent(flowToken, workflowFlowToken.WorkflowInstanceId));
}
}
public void Execute(EntityToken entityToken, ActionToken actionToken, TaskManagerEvent taskManagerEvent)
{
FlowControllerServicesContainer flowServicesContainer = new FlowControllerServicesContainer();
flowServicesContainer.AddService(new ManagementConsoleMessageService(this.ConsoleId));
flowServicesContainer.AddService(new ElementDataExchangeService(this.ElementProviderName));
flowServicesContainer.AddService(this);
FlowToken flowToken = ActionExecutorFacade.Execute(entityToken, actionToken, flowServicesContainer, taskManagerEvent);
IFlowUiDefinition uiDefinition = FlowControllerFacade.GetCurrentUiDefinition(flowToken, flowServicesContainer);
ActionResult result = new ActionResult();
if (typeof(FlowUiDefinitionBase).IsAssignableFrom(uiDefinition.GetType()))
{
string serializedEntityToken = EntityTokenSerializer.Serialize(entityToken, true);
ViewTransitionHelper.HandleNew(this.ConsoleId, this.ElementProviderName, serializedEntityToken, flowToken, (FlowUiDefinitionBase)uiDefinition);
}
}
private static void OnSaveAndPublish(FlowToken flowToken, Dictionary <string, object> bindings, FlowControllerServicesContainer serviceContainer)
{
WorkflowFlowToken workflowFlowToken = (WorkflowFlowToken)flowToken;
using (TaskContainer taskContainer = TaskManagerFacade.RuntTasks(flowToken, new WorkflowTaskManagerEvent(flowToken, workflowFlowToken.WorkflowInstanceId)
{
EventName = "Save"
}))
{
TaskManagerFlowControllerService taskManagerFlowControllerService = new TaskManagerFlowControllerService(taskContainer);
serviceContainer.AddService(taskManagerFlowControllerService);
WorkflowFacade.FireSaveAndPublishEvent(workflowFlowToken.WorkflowInstanceId, bindings);
WorkflowFacade.SetFlowControllerServicesContainer(workflowFlowToken.WorkflowInstanceId, serviceContainer);
WorkflowFacade.RunWorkflow(workflowFlowToken.WorkflowInstanceId);
taskContainer.SetOnIdleTaskManagerEvent(new WorkflowTaskManagerEvent(flowToken, workflowFlowToken.WorkflowInstanceId));
serviceContainer.RemoveService(taskManagerFlowControllerService);
}
}
public static IFlowController GetFlowController(FlowToken flowToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
Verify.ArgumentNotNull(flowToken, "flowToken");
Type flowTokenType = flowToken.GetType();
return(_flowControllerCache.GetOrAdd(flowTokenType, type =>
{
object[] attributes = type.GetCustomAttributes(typeof(FlowControllerAttribute), true);
Verify.That(attributes.Length > 0, "Missing '{0}' attribute on the flow token '{1}'", typeof(FlowControllerAttribute), type);
FlowControllerAttribute attribute = (FlowControllerAttribute)attributes[0];
Verify.IsNotNull(attribute.FlowControllerType, "Flow controller type can not be null on the action token '{0}'", type);
Verify.That(typeof(IFlowController).IsAssignableFrom(attribute.FlowControllerType), "Flow controller '{0}' should implement the interface '{1}'", attribute.FlowControllerType, typeof(IFlowController));
var flowController = (IFlowController)Activator.CreateInstance(attribute.FlowControllerType);
flowController.ServicesContainer = flowControllerServicesContainer;
return flowController;
}));
}
public static IFlowController GetFlowController(FlowToken flowToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
Verify.ArgumentNotNull(flowToken, "flowToken");
Type flowTokenType = flowToken.GetType();
return _flowControllerCache.GetOrAdd(flowTokenType, type =>
{
object[] attributes = type.GetCustomAttributes(typeof(FlowControllerAttribute), true);
Verify.That(attributes.Length > 0, "Missing '{0}' attribute on the flow token '{1}'", typeof(FlowControllerAttribute), type);
FlowControllerAttribute attribute = (FlowControllerAttribute) attributes[0];
Verify.IsNotNull(attribute.FlowControllerType, "Flow controller type can not be null on the action token '{0}'", type);
Verify.That(typeof(IFlowController).IsAssignableFrom(attribute.FlowControllerType), "Flow controller '{0}' should implement the interface '{1}'", attribute.FlowControllerType, typeof(IFlowController));
var flowController = (IFlowController) Activator.CreateInstance(attribute.FlowControllerType);
flowController.ServicesContainer = flowControllerServicesContainer;
return flowController;
});
}
private static void OnCustomEvent05(FlowToken flowToken, Dictionary <string, object> bindings, FlowControllerServicesContainer serviceContainer)
{
OnCustomEvent(5, flowToken, bindings, serviceContainer);
}
/// <exclude />
public FlowTaskManagerEvent(FlowToken flowToken)
{
this.FlowToken = flowToken;
}
public IFlowUiDefinition GetCurrentUiDefinition(FlowToken flowToken)
{
WorkflowFlowToken workflowFlowToken = (WorkflowFlowToken)flowToken;
if (!WorkflowFacade.WorkflowExists(workflowFlowToken.WorkflowInstanceId))
{
Log.LogVerbose(LogTitle, "The workflow with Id = {0} does not exists", workflowFlowToken.WorkflowInstanceId);
return(null);
}
using (GlobalInitializerFacade.CoreNotLockedScope)
{
Semaphore semaphore = WorkflowFacade.WaitForIdleStatus(workflowFlowToken.WorkflowInstanceId);
if (semaphore != null)
{
Log.LogVerbose(LogTitle, "The workflow with Id = {0} is running, waiting until its done.", workflowFlowToken.WorkflowInstanceId);
semaphore.WaitOne(TimeSpan.FromSeconds(10), true);
Log.LogVerbose(LogTitle, "Done waiting on the workflow with Id = {0}.", workflowFlowToken.WorkflowInstanceId);
}
}
FormData formFunction = WorkflowFacade.GetFormData(workflowFlowToken.WorkflowInstanceId);
if (formFunction == null)
{
return(null);
}
FormFlowUiDefinition formFlowUiDefinition;
if (formFunction.FormDefinition != null)
{
formFlowUiDefinition = new FormFlowUiDefinition(
ToXmlReader(formFunction.FormDefinition),
formFunction.ContainerType,
formFunction.ContainerLabel,
formFunction.Bindings,
formFunction.BindingsValidationRules
);
}
else if (formFunction.FormMarkupProvider != null)
{
formFlowUiDefinition = new FormFlowUiDefinition(
formFunction.FormMarkupProvider,
formFunction.ContainerType,
formFunction.ContainerLabel,
formFunction.Bindings,
formFunction.BindingsValidationRules
);
}
else
{
throw new NotImplementedException();
}
var markup = GetCustomToolbarMarkup(formFunction);
if (markup != null)
{
formFlowUiDefinition.SetCustomToolbarMarkupProvider(markup);
}
AddEventHandles(formFlowUiDefinition, workflowFlowToken.WorkflowInstanceId);
return(formFlowUiDefinition);
}
private static void BaseEventHandler(string consoleId,
string elementProviderName,
FlowToken flowToken,
FormFlowUiDefinition formFlowUiCommand,
FlowControllerServicesContainer servicesContainer,
Dictionary <IFormEventIdentifier, FormFlowEventHandler> eventHandlers,
IFormEventIdentifier localScopeEventIdentifier,
FlowControllerServicesContainer formServicesContainer)
{
FormTreeCompiler activeFormTreeCompiler = CurrentFormTreeCompiler;
Dictionary <string, object> activeInnerFormBindings = CurrentInnerFormBindings;
FormFlowEventHandler handler = eventHandlers[localScopeEventIdentifier];
Dictionary <string, Exception> bindingErrors = activeFormTreeCompiler.SaveAndValidateControlProperties();
FormTreeCompiler activeCustomToolbarFormTreeCompiler = CurrentCustomToolbarFormTreeCompiler;
if (activeCustomToolbarFormTreeCompiler != null)
{
var toolbarBindingErrors = activeCustomToolbarFormTreeCompiler.SaveAndValidateControlProperties();
foreach (var pair in toolbarBindingErrors)
{
bindingErrors.Add(pair.Key, pair.Value);
}
}
formServicesContainer.AddService(new BindingValidationService(bindingErrors));
handler.Invoke(flowToken, activeInnerFormBindings, formServicesContainer);
if (formServicesContainer.GetService <IManagementConsoleMessageService>().CloseCurrentViewRequested)
{
ViewTransitionHelper.HandleCloseCurrentView(formFlowUiCommand.UiContainerType);
return;
}
var formFlowService = formServicesContainer.GetService <IFormFlowRenderingService>();
bool replacePageOutput = (formServicesContainer.GetService <IFormFlowWebRenderingService>().NewPageOutput != null);
bool rerenderView = formFlowService.RerenderViewRequested;
if (formFlowService.BindingPathedMessages != null)
{
ShowFieldMessages(CurrentControlTreeRoot, formFlowService.BindingPathedMessages, CurrentControlContainer,
servicesContainer);
}
List <bool> boolCounterList = new List <bool> {
replacePageOutput, rerenderView
};
if (boolCounterList.Count(f => f) > 1)
{
StringBuilder sb = new StringBuilder("Flow returned conflicting directives for post handling:\n");
if (replacePageOutput)
{
sb.AppendLine(" - Replace page output with new web control.");
}
if (rerenderView)
{
sb.AppendLine(" - Rerender view.");
}
throw new InvalidOperationException(sb.ToString());
}
if (rerenderView)
{
Log.LogVerbose("FormFlowRendering", "Re-render requested");
IFlowUiDefinition newFlowUiDefinition = FlowControllerFacade.GetCurrentUiDefinition(flowToken,
servicesContainer);
if (!(newFlowUiDefinition is FlowUiDefinitionBase))
{
throw new NotImplementedException("Unable to handle transitions to ui definition of type " +
newFlowUiDefinition.GetType());
}
ViewTransitionHelper.HandleRerender(consoleId, elementProviderName, flowToken, formFlowUiCommand,
(FlowUiDefinitionBase)newFlowUiDefinition, servicesContainer);
}
if (replacePageOutput)
{
Log.LogVerbose("FormFlowRendering", "Replace pageoutput requested");
IFormFlowWebRenderingService webRenderingService =
formServicesContainer.GetService <IFormFlowWebRenderingService>();
Control newPageOutput = webRenderingService.NewPageOutput;
foreach (Control control in GetNestedControls(newPageOutput).Where(f => f is ScriptManager).ToList())
{
control.Parent.Controls.Remove(control);
}
Page currentPage = HttpContext.Current.Handler as Page;
HtmlHead newHeadControl = GetNestedControls(newPageOutput).FirstOrDefault(f => f is HtmlHead) as HtmlHead;
HtmlHead oldHeadControl = currentPage.Header;
ControlCollection headContainer = null;
bool headersHasToBeSwitched = newHeadControl != null && oldHeadControl != null;
if (headersHasToBeSwitched)
{
headContainer = newHeadControl.Parent.Controls;
headContainer.Remove(newHeadControl);
}
currentPage.Controls.Clear();
if (string.IsNullOrEmpty(webRenderingService.NewPageMimeType))
{
currentPage.Response.ContentType = "text/html";
}
else
{
currentPage.Response.ContentType = webRenderingService.NewPageMimeType;
}
currentPage.Controls.Add(newPageOutput);
if (headersHasToBeSwitched)
{
oldHeadControl.Controls.Clear();
oldHeadControl.InnerHtml = "";
oldHeadControl.InnerText = "";
if (newHeadControl.ID != null)
{
oldHeadControl.ID = newHeadControl.ID;
}
oldHeadControl.Title = newHeadControl.Title;
headContainer.AddAt(0, oldHeadControl);
foreach (Control c in newHeadControl.Controls.Cast <Control>().ToList())
{
oldHeadControl.Controls.Add(c);
}
}
}
}
public static IUiControl Render(
string consoleId,
string elementProviderName,
FlowToken flowToken,
FormFlowUiDefinition formFlowUiCommand,
IFormChannelIdentifier channel,
bool debugMode,
FlowControllerServicesContainer servicesContainer)
{
FlowControllerServicesContainer formServicesContainer = new FlowControllerServicesContainer(servicesContainer);
formServicesContainer.AddService(new FormFlowRenderingService());
formServicesContainer.AddService(new FormFlowWebRenderingService());
IFormMarkupProvider formMarkupProvider = formFlowUiCommand.MarkupProvider;
IFormMarkupProvider customToolbarItemsMarkupProvider = formFlowUiCommand.CustomToolbarItemsMarkupProvider;
Dictionary <string, object> innerFormBindings = formFlowUiCommand.BindingsProvider.GetBindings();
Dictionary <IFormEventIdentifier, FormFlowEventHandler> eventHandlers = formFlowUiCommand.EventHandlers;
Dictionary <string, List <ClientValidationRule> > bindingsValidationRules = formFlowUiCommand.BindingsValidationRules;
FormTreeCompiler formCompiler = new FormTreeCompiler();
IUiContainer renderingContainer = GetRenderingContainer(channel, formFlowUiCommand.UiContainerType);
// Setting state related objects so the delegate below can access them "fresh"
CurrentFormTreeCompiler = formCompiler;
CurrentInnerFormBindings = innerFormBindings;
CurrentControlContainer = (IWebUiContainer)renderingContainer;
Dictionary <string, object> containerEventHandlerStubs = new Dictionary <string, object>();
foreach (IFormEventIdentifier eventIdentifier in eventHandlers.Keys)
{
IFormEventIdentifier localScopeEventIdentifier = eventIdentifier; // See: Local variable usage with anonymous methods within loop control structures
EventHandler handlerStub = delegate(object sender, EventArgs e)
{
try
{
BaseEventHandler(consoleId, elementProviderName, flowToken, formFlowUiCommand, servicesContainer, eventHandlers, localScopeEventIdentifier, formServicesContainer);
}
catch (Exception ex)
{
formServicesContainer.GetService <IManagementConsoleMessageService>().ShowLogEntry(typeof(FormFlowUiDefinitionRenderer), ex);
throw;
}
};
containerEventHandlerStubs.Add(eventIdentifier.BindingName, handlerStub);
if (innerFormBindings.ContainsKey(eventIdentifier.BindingName))
{
innerFormBindings.Remove(eventIdentifier.BindingName);
}
innerFormBindings.Add(eventIdentifier.BindingName, handlerStub);
}
XDocument document;
using (XmlReader formMarkupReader = formMarkupProvider.GetReader())
{
document = XDocument.Load(formMarkupReader);
formMarkupReader.Close();
}
formCompiler.Compile(document, channel, innerFormBindings, debugMode, "", bindingsValidationRules);
IUiControl innerForm = formCompiler.UiControl;
IUiControl customToolbarItems = null;
if (customToolbarItemsMarkupProvider != null)
{
var toolbarCompiler = new FormTreeCompiler();
CurrentCustomToolbarFormTreeCompiler = toolbarCompiler;
using (XmlReader formMarkupReader = customToolbarItemsMarkupProvider.GetReader())
{
toolbarCompiler.Compile(formMarkupReader, channel, innerFormBindings, debugMode, bindingsValidationRules);
}
customToolbarItems = toolbarCompiler.UiControl;
}
CurrentControlTreeRoot = (IWebUiControl)innerForm;
string label = formCompiler.Label;
if (label.IsNullOrEmpty())
{
label = formFlowUiCommand.ContainerLabel ?? "";
}
string labelField = GetFormLabelField(document);
ResourceHandle containerIcon = formCompiler.Icon;
return(renderingContainer.Render(formCompiler.UiControl, customToolbarItems, channel, containerEventHandlerStubs, label, labelField, formCompiler.Tooltip, containerIcon));
}
/// <exclude />
public SaveWorklowTaskManagerEvent(FlowToken flowToken, Guid workflowInstanceId, bool succeeded)
: base(flowToken, workflowInstanceId)
{
this.Succeeded = succeeded;
}
internal static void HandleRerender(string consoleId, string elementProviderName, FlowToken flowToken, FlowUiDefinitionBase oldUiDefinition, FlowUiDefinitionBase newUiDefinition, FlowControllerServicesContainer servicesContainer)
{
if (newUiDefinition.UiContainerType.ActionResultResponseType != oldUiDefinition.UiContainerType.ActionResultResponseType)
{
var messageService = servicesContainer.GetService <IManagementConsoleMessageService>();
messageService.CloseCurrentView();
HandleNew(consoleId, elementProviderName, string.Empty, flowToken, newUiDefinition);
}
else
{
// Force update in same container
HttpContext.Current.Response.Redirect(HttpContext.Current.Request.Url.PathAndQuery, false);
}
}
internal static void CompleteTasks(FlowToken flowToken)
{
Implementation.CompleteTasks(flowToken);
}
/// <exclude />
public static TaskContainer RuntTasks(FlowToken flowToken, TaskManagerEvent taskManagerEvent)
{
return(Implementation.RuntTasks(flowToken, taskManagerEvent));
}
public void CancelFlow(FlowToken flowToken)
{
WorkflowFlowToken workflowFlowToken = (WorkflowFlowToken)flowToken;
OnCancel(flowToken, null, null);
}
public void CancelFlow(FlowToken flowToken)
{
OnCancel(flowToken, null, null);
}
internal static void HandleNew(string consoleId, string elementProviderName, string serializedEntityToken, FlowToken flowToken, FlowUiDefinitionBase uiDefinition)
{
ActionResultResponseType actionViewType = uiDefinition.UiContainerType.ActionResultResponseType;
if (actionViewType != ActionResultResponseType.None)
{
FlowHandle flowHandle = new FlowHandle(flowToken);
string serializedFlowHandle = flowHandle.Serialize();
string viewId = MakeViewId(serializedFlowHandle);
ViewType viewType;
switch (actionViewType)
{
case ActionResultResponseType.OpenDocument:
viewType = ViewType.Main;
break;
case ActionResultResponseType.OpenModalDialog:
viewType = ViewType.ModalDialog;
break;
default:
throw new Exception("unknown action response type");
}
string url = string.Format("{0}?consoleId={1}&flowHandle={2}&elementProvider={3}",
UrlUtils.ResolveAdminUrl("content/flow/FlowUi.aspx"),
consoleId,
HttpUtility.UrlEncode(serializedFlowHandle),
HttpUtility.UrlEncode(elementProviderName));
OpenViewMessageQueueItem openView = new OpenViewMessageQueueItem
{
ViewType = viewType,
EntityToken = serializedEntityToken,
FlowHandle = flowHandle.Serialize(),
Url = url,
ViewId = viewId
};
if (uiDefinition is VisualFlowUiDefinitionBase)
{
VisualFlowUiDefinitionBase visualUiDefinition = (VisualFlowUiDefinitionBase)uiDefinition;
if (string.IsNullOrEmpty(visualUiDefinition.ContainerLabel) == false)
{
openView.Label = visualUiDefinition.ContainerLabel;
}
}
ConsoleMessageQueueFacade.Enqueue(openView, consoleId);
}
}
/// <exclude />
public WorkflowTaskManagerEvent(FlowToken flowToken, Guid workflowInstanceId)
: base(flowToken)
{
this.WorkflowInstanceId = workflowInstanceId;
this.EventName = "";
}
