/// <summary>
/// 注入流程引擎服务
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IProcessEngineBuilder AddProcessEngineService(this IProcessEngineBuilder builder)
{
builder.AddBookmarkRuleProvider();
builder.Services.AddTransient <IActivitiEngineAgendaFactory>(sp => new DefaultActivitiEngineAgendaFactory());
builder.Services.AddSingleton <IBpmnParseFactory, DefaultBpmnParseFactory>();
builder.AddProcessValidator();
builder.Services.AddTransient <IRepositoryService>(sp => sp.GetRequiredService <IProcessEngine>().RepositoryService);
builder.Services.AddTransient <IRuntimeService>(sp => sp.GetRequiredService <IProcessEngine>().RuntimeService);
builder.Services.AddTransient <IManagementService>(sp => sp.GetRequiredService <IProcessEngine>().ManagementService);
builder.Services.AddTransient <IHistoryService>(sp => sp.GetRequiredService <IProcessEngine>().HistoryService);
builder.Services.AddTransient <ITaskService>(sp => sp.GetRequiredService <IProcessEngine>().TaskService);
builder.Services.AddTransient <IDynamicBpmnService>(sp => sp.GetRequiredService <IProcessEngine>().DynamicBpmnService);
builder.Services.AddTransient <IProcessEngine>(sp =>
{
return(sp.GetService <ProcessEngineFactory>().DefaultProcessEngine);
});
builder.Services.AddBpmModelServiceProvider();
return(builder);
}
private static IProcessEngineBuilder AddSmartSqlMapper(this IProcessEngineBuilder builder)
{
builder.Services.AddSingleton <ISmartSqlMapper>(sp =>
{
var codebase = AppDomain.CurrentDomain.BaseDirectory;
IDataSource dataSource = sp.GetService <IDataSource>();
var dbSessionStore = new DbConnectionSessionStore(sp.GetService <ILoggerFactory>(), dataSource.DbProviderFactory);
SmartSqlOptions options = new SmartSqlOptions
{
ConfigPath = Path.Combine(codebase, DEFAULT_MYBATIS_MAPPING_FILE),
DbSessionStore = dbSessionStore
};
SmartSqlMapper ssm = new SmartSqlMapper(options);
options.SmartSqlContext.Settings.IsWatchConfigFile = true;
options.SmartSqlContext.Database.WriteDataSource.ConnectionString = dataSource.ConnectionString;
foreach (var ds in options.SmartSqlContext.Database.ReadDataSources)
{
ds.ConnectionString = dataSource.ConnectionString;
}
return(ssm);
});
return(builder);
}
/// <summary>
/// 注入数据源
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IProcessEngineBuilder AddDataSource(this IProcessEngineBuilder builder)
{
builder.AddSmartSqlDataSource()
.AddSmartSqlMapper();
return(builder);
}
/// <summary>
/// 注入异步Timer执行器
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IProcessEngineBuilder AddAsyncExecutor(this IProcessEngineBuilder builder)
{
builder.Services.AddTransient <IAsyncExecutor>(sp =>
{
IConfigurationSection dajw = sp.GetService <IConfiguration>().GetSection("defaultAsyncJobAcquireWaitTimeInMillis");
IConfigurationSection dtjw = sp.GetService <IConfiguration>().GetSection("defaultTimerJobAcquireWaitTimeInMillis");
if (int.TryParse(dajw?.Value, out int iDajw) == false)
{
iDajw = 10000;
}
if (int.TryParse(dtjw?.Value, out int iDtjw) == false)
{
iDtjw = 10000;
}
return(new DefaultAsyncJobExecutor()
{
DefaultAsyncJobAcquireWaitTimeInMillis = iDajw,
DefaultTimerJobAcquireWaitTimeInMillis = iDtjw,
});
});
return(builder);
}
/// <summary>
/// 注入会签人员提供类
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IProcessEngineBuilder AddBookmarkRuleProvider(this IProcessEngineBuilder builder)
{
IGetBookmarkRuleProvider getBookmarkRuleProvider = new GetBookmarkRuleProvider();
builder.Services.AddSingleton(getBookmarkRuleProvider);
return(builder);
}
/// <summary>
/// 注入流程模型验证
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
private static IProcessEngineBuilder AddProcessValidator(this IProcessEngineBuilder builder)
{
IProcessValidator processValidator = new ProcessValidatorFactory().CreateProcessValidator();
builder.Services.AddSingleton(processValidator);
return(builder);
}
/// <summary>
/// 注入流程引擎工厂
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IProcessEngineBuilder AddProcessEngineFactory(this IProcessEngineBuilder builder)
{
builder.Services.AddSingleton <ProcessEngineFactory>(sp =>
{
return(ProcessEngineFactory.Instance);
});
return(builder);
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
/// <param name="configuration"></param>
/// <param name="setupAction"></param>
/// <returns></returns>
public static IProcessEngineBuilder Configure(this IProcessEngineBuilder builder, IConfiguration configuration, Action<DataSourceOption> setupAction)
{
builder.Services.Configure<ProcessEngineOption>(configuration);
builder.Services.Configure<DataSourceOption>(setupAction);
builder.Services.AddSingleton<ExternalConnectorProvider>(sp =>
{
return new ExternalConnectorProvider
{
Configuration = configuration
};
});
return builder;
}
/// <summary>
/// 注入流程引擎配置
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IProcessEngineBuilder AddProcessEngineConfiguration(this IProcessEngineBuilder builder)
{
builder.Services.AddSingleton <ProcessEngineConfiguration>(sp =>
{
return(new StandaloneProcessEngineConfiguration(
new HistoryServiceImpl(),
new TaskServiceImpl(),
new DynamicBpmnServiceImpl(),
new RepositoryServiceImpl(),
new RuntimeServiceImpl(),
new ManagementServiceImpl(),
//sp.GetService<IAsyncExecutor>(),
null,
sp.GetService <IConfiguration>()
));
});
return(builder);
}
/// <summary>
/// 注入DatabaseReader
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IProcessEngineBuilder AddDataBaseReader(this IProcessEngineBuilder builder)
{
builder.Services.AddTransient <IDatabaseReader>(sp =>
{
var ds = sp.GetService <IDataSource>();
DatabaseReader reader = new DatabaseReader(ds.Connection as DbConnection);
switch (reader.DatabaseSchema.Provider)
{
case "MySql.Data.MySqlClient":
reader.Owner = ds.Connection.Database;
break;
}
return(reader);
});
return(builder);
}
public static IProcessEngineBuilder AddHibernateStores(this IProcessEngineBuilder builder,
Action <Configuration> configureAction = null)
{
var services = builder.Services;
//builder.ConfigureServices(services =>
//{
AddHibernate(services, configureAction);
//});
services.AddScoped <IUnitOfWork, UnitOfWork>();
//Add Stores.
services.AddTransient <IDeploymentStore, DeploymentStore>();
services.AddTransient <IEventSubscriptionStore, EventSubscriptionStore>();
services.AddTransient <IScheduledJobStore, ScheduledJobStore>();
services.AddTransient <ITaskStore, TaskStore>();
services.AddTransient <IInstanceStore, InstanceStore>();
services.AddTransient <IIdentityStore, IdentityStore>();
return(builder);
}
/// <summary>
/// 注入SmartSql数据源
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
private static IProcessEngineBuilder AddSmartSqlDataSource(this IProcessEngineBuilder builder)
{
Action <IDataSource> updateSmartSqlDbSession = (dataSource) =>
{
ISmartSqlMapper ssm = serviceProvider.GetService <ISmartSqlMapper>();
ssm.SmartSqlOptions.DbSessionStore = new DbConnectionSessionStore(serviceProvider.GetService <ILoggerFactory>(), dataSource.DbProviderFactory);
ssm.SmartSqlOptions.SmartSqlContext.Database.WriteDataSource.ConnectionString = dataSource.ConnectionString;
foreach (var ds in ssm.SmartSqlOptions.SmartSqlContext.Database.ReadDataSources)
{
ds.ConnectionString = dataSource.ConnectionString;
}
};
builder.Services.AddSingleton <IDataSource>(sp =>
{
serviceProvider = sp;
return(new Data.DataSource(sp.GetService <IOptionsMonitor <DataSourceOption> >(), updateSmartSqlDbSession));
});
return(builder);
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
/// <param name="configuration"></param>
/// <param name="setupAction"></param>
/// <returns></returns>
public static IProcessEngineBuilder AddProcessEngine(this IProcessEngineBuilder builder, IConfiguration configuration, Action <DataSourceOption> setupAction)
{
ConfigUtil.Configuration = configuration;
TypeRegistry.RegisterType(typeof(TimerUtil));
builder.Services.AddSpringCoreTypeRepository();
builder.Services.AddSpringCoreService(builder.Services.BuildServiceProvider().GetService <ILoggerFactory>());
builder.Services.AddSingleton <MemoryCacheProvider>();
builder.Services.AddHttpClient <HttpClient>()
.ConfigureHttpMessageHandlerBuilder(cb =>
{
HttpClientHandler handler = new HttpClientHandler();
handler.MaxRequestContentBufferSize = int.MaxValue;
handler.ClientCertificateOptions = ClientCertificateOption.Automatic;
handler.UseDefaultCredentials = true;
handler.ServerCertificateCustomValidationCallback += (s, arg1, arg2, arg3) => true;
cb.PrimaryHandler = handler;
cb.Build();
});
DbSqlSessionVersion.InitVersion(configuration);
builder.Configure(configuration, setupAction);
builder.Services.AddSingleton <IIdGenerator>(sp => new GuidGenerator());
builder.Services.AddUserSession <DefaultUserSession>();
builder.Services.AddWorkflowAccessTokenProvider <DefaultAccessTokenProvider>();
builder.Services.AddTransient <IHttpClientProxy>(sp =>
{
try
{
HttpClient client = sp.GetService <IHttpClientFactory>().CreateClient();
var url = sp.GetService <ExternalConnectorProvider>().WorkflowUrl;
if (!string.IsNullOrWhiteSpace(url))
{
client.BaseAddress = new Uri(url);
}
return(new DefaultHttpClientProxy(client,
sp.GetService <IAccessTokenProvider>(),
sp.GetService <IHttpContextAccessor>()));
}
catch (Exception ex)
{
throw ex;
}
});
builder.Services.AddSingleton <IUserServiceProxy, DefaultUserServiceProxy>();
builder.Services.AddTransient <IServiceWebApiHttpProxy, ServiceWebApiHttpProxy>();
builder.AddDataSource()
.AddDataBaseReader()
.AddAsyncExecutor()
.AddProcessEngineConfiguration()
.AddProcessEngineFactory()
.AddProcessEngineService();
return(builder);
}
