internal static TypeProvider CreateTypeProvider(Activity rootActivity)
{
TypeProvider provider = new TypeProvider(null);
Type type = rootActivity.GetType();
provider.SetLocalAssembly(type.Assembly);
provider.AddAssembly(type.Assembly);
foreach (AssemblyName name in type.Assembly.GetReferencedAssemblies())
{
Assembly assembly = null;
try
{
assembly = Assembly.Load(name);
if (assembly != null)
{
provider.AddAssembly(assembly);
}
}
catch
{
}
if ((assembly == null) && (name.CodeBase != null))
{
provider.AddAssemblyReference(name.CodeBase);
}
}
return(provider);
}
internal static TypeProvider CreateTypeProvider(Activity rootActivity)
{
TypeProvider typeProvider = new TypeProvider(null);
Type companionType = rootActivity.GetType();
typeProvider.SetLocalAssembly(companionType.Assembly);
typeProvider.AddAssembly(companionType.Assembly);
foreach (AssemblyName assemblyName in companionType.Assembly.GetReferencedAssemblies())
{
Assembly referencedAssembly = null;
try
{
referencedAssembly = Assembly.Load(assemblyName);
if (referencedAssembly != null)
{
typeProvider.AddAssembly(referencedAssembly);
}
}
catch
{
}
if (referencedAssembly == null && assemblyName.CodeBase != null)
{
typeProvider.AddAssemblyReference(assemblyName.CodeBase);
}
}
return(typeProvider);
}
private void LoadWorkflow()
{
var dialogs = new List <Dialog>();
var serviceMethods = new List <ServiceMethod>();
var subworkflows = new List <DataAccess.Domain.Workflow>();
foreach (WorkflowDialog workflowDialog in Workflow.Dialogs)
{
Dialog dialog = MetaManagerServices.GetDialogService().GetDialogWithViewTree(workflowDialog.Dialog.Id);
dialogs.Add(dialog);
}
foreach (WorkflowServiceMethod workflowServiceMethod in Workflow.ServiceMethods)
{
ServiceMethod serviceMethod = MetaManagerServices.GetApplicationService().GetServiceMethodMapsById(workflowServiceMethod.ServiceMethod.Id);
serviceMethods.Add(serviceMethod);
}
foreach (WorkflowSubworkflow workflowSubworkflow in Workflow.Subworkflows)
{
DataAccess.Domain.Workflow subworkflow = MetaManagerServices.GetDialogService().GetWorkflowById(workflowSubworkflow.SubWorkflow.Id);
subworkflows.Add(subworkflow);
}
IList <Type> activityTypes = new List <Type>();
activityTypes = WorkflowTypeFactory.CreateActivities(Workflow, this.BackendApplication, dialogs, serviceMethods, subworkflows);
if ((activityTypes.Count > 0) && (!string.IsNullOrEmpty(Workflow.WorkflowXoml)))
{
Workflow.WorkflowXoml = ReplaceAssemblyReferences(Workflow.WorkflowXoml, activityTypes[0].Assembly.GetName().Name);
}
workflowControl.LoadWorkflow(Workflow.WorkflowXoml, Workflow.RuleSetXml);
workflowControl.RootActivity.Description = Workflow.Description;
TypeProvider typeProvider = workflowControl.GetService(typeof(ITypeProvider)) as TypeProvider;
if (activityTypes.Count > 0)
{
foreach (Type activityType in activityTypes)
{
workflowControl.ToolBox.AddToolBoxItem(new SelfHostToolboxItem(activityType));
}
typeProvider.AddAssembly(activityTypes[0].Assembly);
}
sessionType = RuleContextFactory.LoadUserSessionType(Workflow.Module.Application);
typeProvider.AddAssembly(sessionType.Assembly);
requestType = WorkflowTypeFactory.CreateRequestType(Workflow);
typeProvider.AddAssembly(requestType.Assembly);
GenerateMembers();
tbxName.Text = Workflow.Name;
}
private void addWorkflowBtn_Click(object sender, EventArgs e)
{
FindWorkflowForm form = new FindWorkflowForm();
form.BackendApplication = BackendApplication;
form.FrontendApplication = FrontendApplication;
if (form.ShowDialog() == DialogResult.OK)
{
DataAccess.Domain.Workflow workflow = dialogService.GetWorkflowById(form.SelectedWorkflow.Id);
foreach (WorkflowSubworkflow subworkflow in Workflow.Subworkflows)
{
if (subworkflow.SubWorkflow.Id == workflow.Id)
{
MessageBox.Show("The selected Workflow is already present in the current Workflow.", "MetaManager");
return;
}
}
WorkflowSubworkflow workflowSubworkflow = new WorkflowSubworkflow();
workflowSubworkflow.SubWorkflow = workflow;
workflowSubworkflow.Workflow = Workflow;
Workflow.Subworkflows.Add(workflowSubworkflow);
Type activityType = WorkflowTypeFactory.CreateActivities(Workflow, this.BackendApplication, new Dialog[0], new ServiceMethod[0], new DataAccess.Domain.Workflow[] { workflow }).Last();
TypeProvider typeProvider = workflowControl.GetService(typeof(ITypeProvider)) as TypeProvider;
typeProvider.AddAssembly(activityType.Assembly);
workflowControl.ToolBox.AddToolBoxItem(new SelfHostToolboxItem(activityType));
}
}
private void addServiceMethodBtn_Click(object sender, EventArgs e)
{
FindServiceMethodForm form = new FindServiceMethodForm();
form.FrontendApplication = FrontendApplication;
form.BackendApplication = BackendApplication;
if (form.ShowDialog() == DialogResult.OK)
{
ServiceMethod serviceMethod = MetaManagerServices.GetApplicationService().GetServiceMethodMapsById(form.ServiceMethod.Id);
foreach (WorkflowServiceMethod wfServiceMethod in Workflow.ServiceMethods)
{
if (wfServiceMethod.ServiceMethod.Id == serviceMethod.Id)
{
MessageBox.Show("The selected Service Method is already present in the Workflow.", "MetaManager");
return;
}
}
WorkflowServiceMethod workflowServiceMethod = new WorkflowServiceMethod();
workflowServiceMethod.ServiceMethod = serviceMethod;
workflowServiceMethod.Workflow = Workflow;
Workflow.ServiceMethods.Add(workflowServiceMethod);
Type activityType = WorkflowTypeFactory.CreateActivities(Workflow, this.BackendApplication, new Dialog[0], new ServiceMethod[] { serviceMethod }, new DataAccess.Domain.Workflow[0]).Last();
TypeProvider typeProvider = workflowControl.GetService(typeof(ITypeProvider)) as TypeProvider;
typeProvider.AddAssembly(activityType.Assembly);
workflowControl.ToolBox.AddToolBoxItem(new SelfHostToolboxItem(activityType));
}
}
/// <summary>
/// Display the specified workflow type.
/// </summary>
/// <param name="root">Type of the workflow.</param>
public void DisplayType(Type root)
{
if (!typeof(Activity).IsAssignableFrom(root))
{
throw new ArgumentException("WorkflowViewPanel only supports displaying Activity objects.", "root");
}
this.surface = new DesignSurface();
this.host = this.surface.GetService(typeof(IDesignerHost)) as IDesignerHost;
TypeProvider provider = new TypeProvider(this.surface);
provider.AddAssembly(typeof(string).Assembly);
IServiceContainer container = this.surface.GetService(typeof(IServiceContainer)) as IServiceContainer;
container.AddService(typeof(ITypeProvider), provider);
if (this.host == null)
{
throw new ApplicationException("Cannot work with a null host.");
}
Queue <Activity> toProcess = new Queue <Activity>();
try
{
toProcess.Enqueue((Activity)root.InvokeMember(string.Empty, System.Reflection.BindingFlags.CreateInstance, null, null, null, CultureInfo.InvariantCulture));
}
catch (Exception exc)
{
MessageBox.Show("Could not load workflow type: " + exc.ToString());
this.surface = null;
this.host = null;
return;
}
// Do a non-recursive walk of the activity
// tree to display all activities.
while (toProcess.Count > 0)
{
Activity activity = toProcess.Dequeue();
host.Container.Add(activity, activity.QualifiedName);
if (activity is CompositeActivity)
{
foreach (Activity child in ((CompositeActivity)activity).Activities)
{
toProcess.Enqueue(child);
}
}
}
this.surface.BeginLoad(new WorkflowLoader());
workflowView = new MouseDisabledWorkflowView(host as IServiceProvider);
workflowView.Dock = DockStyle.Fill;
this.Controls.Add(workflowView);
}
internal static void AddTypeProviderAssembliesFromRegistry(TypeProvider typeProvider, IServiceProvider serviceProvider)
{
if (typeProvider == null)
{
throw new ArgumentNullException("typeProvider");
}
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
RegistryKey key = Registry.CurrentUser.OpenSubKey(TypeProviderRegistryKeyPath);
if (key != null)
{
ITypeProviderCreator service = serviceProvider.GetService(typeof(ITypeProviderCreator)) as ITypeProviderCreator;
foreach (string str in (string[])key.GetValue(TypeProviderAssemblyRegValueName))
{
try
{
if (service != null)
{
bool flag = true;
Assembly transientAssembly = service.GetTransientAssembly(AssemblyName.GetAssemblyName(str));
if (transientAssembly == null)
{
continue;
}
System.Type[] types = transientAssembly.GetTypes();
int index = 0;
while (index < types.Length)
{
System.Type type = types[index];
if (typeProvider.GetType(type.AssemblyQualifiedName) != null)
{
flag = false;
}
break;
}
if (flag)
{
typeProvider.AddAssembly(transientAssembly);
}
continue;
}
typeProvider.AddAssemblyReference(str);
}
catch
{
}
}
key.Close();
}
}
/// <summary>
/// Deserialize a workflow from markup (xaml)
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
private static Activity DeserializeFromMarkup(String fileName)
{
Activity workflow = null;
try
{
//add a TypeProvider to resolve SharedWorkflow references
ServiceContainer container = new ServiceContainer();
TypeProvider provider = new TypeProvider(container);
//provider.AddAssemblyReference("SharedWorkflows.dll");
provider.AddAssembly(
typeof(SharedWorkflows.MarkupOnlyBaseWorkflow).Assembly);
container.AddService(typeof(ITypeProvider), provider);
//add the ServiceContainer with the TypeProvider to
//a serialization manager
DesignerSerializationManager dsm
= new DesignerSerializationManager(container);
using (dsm.CreateSession())
{
using (XmlReader xmlReader = XmlReader.Create(fileName))
{
//deserialize the workflow from the XmlReader
WorkflowMarkupSerializer markupSerializer
= new WorkflowMarkupSerializer();
workflow = markupSerializer.Deserialize(dsm, xmlReader)
as Activity;
if (dsm.Errors.Count > 0)
{
foreach (WorkflowMarkupSerializationException error
in dsm.Errors)
{
Console.WriteLine(
"Deserialization error: {0}", error);
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine("Exception during deserialization: {0}",
e.Message);
}
return(workflow);
}
public RuleConditionDialog(Activity activity, CodeExpression expression)
{
if (activity == null)
{
throw (new ArgumentNullException("activity"));
}
InitializeComponent();
ITypeProvider typeProvider;
serviceProvider = activity.Site;
if (serviceProvider != null)
{
IUIService uisvc = serviceProvider.GetService(typeof(IUIService)) as IUIService;
if (uisvc != null)
{
this.Font = (Font)uisvc.Styles["DialogFont"];
}
typeProvider = (ITypeProvider)serviceProvider.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ITypeProvider).FullName);
throw new InvalidOperationException(message);
}
WorkflowDesignerLoader loader = serviceProvider.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader;
if (loader != null)
{
loader.Flush();
}
}
else
{
// no service provider, so make a TypeProvider that has all loaded Assemblies
TypeProvider newProvider = new TypeProvider(null);
foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
{
newProvider.AddAssembly(a);
}
typeProvider = newProvider;
}
RuleValidation validation = new RuleValidation(activity, typeProvider, false);
this.ruleParser = new Parser(validation);
InitializeDialog(expression);
}
public RuleConditionDialog(Activity activity, CodeExpression expression)
{
ITypeProvider provider;
this.ruleExpressionCondition = new RuleExpressionCondition();
if (activity == null)
{
throw new ArgumentNullException("activity");
}
this.InitializeComponent();
this.serviceProvider = activity.Site;
if (this.serviceProvider != null)
{
IUIService service = this.serviceProvider.GetService(typeof(IUIService)) as IUIService;
if (service != null)
{
this.Font = (Font)service.Styles["DialogFont"];
}
provider = (ITypeProvider)this.serviceProvider.GetService(typeof(ITypeProvider));
if (provider == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.MissingService, new object[] { typeof(ITypeProvider).FullName }));
}
WorkflowDesignerLoader loader = this.serviceProvider.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader;
if (loader != null)
{
loader.Flush();
}
}
else
{
TypeProvider provider2 = new TypeProvider(null);
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
provider2.AddAssembly(assembly);
}
provider = provider2;
}
RuleValidation validation = new RuleValidation(activity, provider, false);
this.ruleParser = new Parser(validation);
this.InitializeDialog(expression);
}
public RuleSetDialog(Activity activity, RuleSet ruleSet)
{
if (activity == null)
{
throw (new ArgumentNullException("activity"));
}
InitializeDialog(ruleSet);
ITypeProvider typeProvider;
this.serviceProvider = activity.Site;
if (this.serviceProvider != null)
{
typeProvider = (ITypeProvider)this.serviceProvider.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ITypeProvider).FullName);
throw new InvalidOperationException(message);
}
WorkflowDesignerLoader loader = this.serviceProvider.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader;
if (loader != null)
{
loader.Flush();
}
}
else
{
// no service provider, so make a TypeProvider that has all loaded Assemblies
TypeProvider newProvider = new TypeProvider(null);
foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
{
newProvider.AddAssembly(a);
}
typeProvider = newProvider;
}
RuleValidation validation = new RuleValidation(activity, typeProvider, false);
this.ruleParser = new Parser(validation);
}
private void modifyMapBtn_Click(object sender, EventArgs e)
{
PropertyMapForm2 form = new PropertyMapForm2();
form.FrontendApplication = this.FrontendApplication;
form.BackendApplication = this.BackendApplication;
form.AllowAddProperty = true;
form.IsEditable = this.IsEditable;
form.HideSyncronizeButton = true;
form.UseProvidedMapObject = true;
form.Owner = this;
IList <IMappableProperty> sourceProperties = new List <IMappableProperty>();
IList <IMappableProperty> targetProperties = new List <IMappableProperty>();
form.PropertyMap = Workflow.RequestMap;
form.SourceProperties = sourceProperties;
form.TargetProperties = targetProperties;
form.DeletedMappedProperties = deletedMappedPropertiesInRequestMap;
form.AddedMappedProperties = addedMappedPropertiesInRequestMap;
if (form.ShowDialog() == DialogResult.OK)
{
try
{
Workflow.RequestMap = form.PropertyMap;
TypeProvider typeProvider = workflowControl.GetService(typeof(ITypeProvider)) as TypeProvider;
typeProvider.RemoveAssembly(requestType.Assembly);
requestType = WorkflowTypeFactory.CreateRequestType(Workflow);
typeProvider.AddAssembly(requestType.Assembly);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
public static byte[] GetWorkflowDefinitionGraphic(Guid tenantId, int workflowType)
{
WorkflowDefinition definition = WorkflowLogic.GetWorkflowDefinition(tenantId, workflowType);
ServiceContainer serviceContainer = new ServiceContainer();
DesignerSerializationManager serializationManager = new DesignerSerializationManager(serviceContainer);
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
TypeProvider typeProvider = new TypeProvider((IServiceProvider)serializationManager);
typeProvider.AddAssembly(System.Reflection.Assembly.Load("Crab.Workflow"));
serviceContainer.AddService(typeof(ITypeProvider), typeProvider);
Activity rootActivity = null;
using (serializationManager.CreateSession())
{
TextReader reader1 = new StringReader(definition.Xoml);
using (XmlReader reader = XmlReader.Create(reader1))
{
rootActivity = (Activity)serializer.Deserialize((IDesignerSerializationManager)serializationManager, reader);
}
}
return(Viewer.GetWorkflowImageBinary(rootActivity, null));
}
private void addDialogBtn_Click(object sender, EventArgs e)
{
SelectDialog form = new SelectDialog();
form.FrontendApplication = FrontendApplication;
form.BackendApplication = BackendApplication;
if (form.ShowDialog() == DialogResult.OK)
{
//if (Workflow.Module.Id != form.SelectedDialog.Module.Id)
//{
// MessageBox.Show("You can only add Dialogs from the same Module as the Workflow.", "MetaManager");
// return;
//}
foreach (WorkflowDialog wfDialog in Workflow.Dialogs)
{
if (wfDialog.Dialog.Id == form.SelectedDialog.Id)
{
MessageBox.Show("The selected Dialog is already present in the Workflow.", "MetaManager");
return;
}
}
Cdc.MetaManager.DataAccess.Domain.Dialog dialog = MetaManagerServices.GetDialogService().GetDialogWithViewTree(form.SelectedDialog.Id);
WorkflowDialog workflowDialog = new WorkflowDialog();
workflowDialog.Dialog = dialog;
workflowDialog.Workflow = Workflow;
Workflow.Dialogs.Add(workflowDialog);
Type activityType = WorkflowTypeFactory.CreateActivities(Workflow, this.BackendApplication, new Dialog[] { dialog }, new ServiceMethod[0], new DataAccess.Domain.Workflow[0]).Last();
TypeProvider typeProvider = workflowControl.GetService(typeof(ITypeProvider)) as TypeProvider;
typeProvider.AddAssembly(activityType.Assembly);
workflowControl.ToolBox.AddToolBoxItem(new SelfHostToolboxItem(activityType));
}
}
public RuleSetDialog(Activity activity, System.Workflow.Activities.Rules.RuleSet ruleSet)
{
ITypeProvider service;
this.sortOrder = new bool[4];
if (activity == null)
{
throw new ArgumentNullException("activity");
}
this.InitializeDialog(ruleSet);
this.serviceProvider = activity.Site;
if (this.serviceProvider != null)
{
service = (ITypeProvider)this.serviceProvider.GetService(typeof(ITypeProvider));
if (service == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.MissingService, new object[] { typeof(ITypeProvider).FullName }));
}
WorkflowDesignerLoader loader = this.serviceProvider.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader;
if (loader != null)
{
loader.Flush();
}
}
else
{
TypeProvider provider2 = new TypeProvider(null);
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
provider2.AddAssembly(assembly);
}
service = provider2;
}
RuleValidation validation = new RuleValidation(activity, service, false);
this.ruleParser = new Parser(validation);
}
