public Engine(
IProductFactory productFactory,
IActivityFactory activityFactory,
IGoalFactory goalFactory,
IDailyNutriCalc dailyNutriCalc,
IRestingEnergyCalculator restingEnergyCalculator,
IJsonSerializer jsonSerializer,
IDataRepository dataRepository,
ISuggestedDailyNutrientsIntakeCalc suggestedDailyNutrientsIntakeCalc)
{
Guard.WhenArgument(productFactory, "Product factory can not be null").IsNull().Throw();
Guard.WhenArgument(activityFactory, "Activity factory can not be null").IsNull().Throw();
Guard.WhenArgument(goalFactory, "Goal factory can not be null").IsNull().Throw();
Guard.WhenArgument(dailyNutriCalc, "DailyNutriCalc can not be null").IsNull().Throw();
Guard.WhenArgument(restingEnergyCalculator, "RestingEnergyCalculator can not be null").IsNull().Throw();
this.productFactory = productFactory;
this.activityFactory = activityFactory;
this.goalFactory = goalFactory;
this.dailyNutriCalc = dailyNutriCalc;
this.restingEnergyCalculator = restingEnergyCalculator;
this.jsonSerializer = jsonSerializer;
this.dataRepository = dataRepository;
this.suggestedDailyNutrientsIntakeCalc = suggestedDailyNutrientsIntakeCalc;
// JSON deserialization for current date.
LoadProgress();
}
public static void RegisterActivity(ActivityTemplateDTO activityTemplate, IActivityFactory activityFactory)
{
if (!_activityRegistrations.TryAdd(new ActivityRegistrationKey(activityTemplate), activityFactory))
{
throw new Exception("Unable to add ActivityRegistration to Dictionary");
}
}
public Bot(
IActivityFactory activityFactory,
ITurnContextPoweredObjectsFactory turnContextPoweredObjectsFactory)
{
_activityFactory = activityFactory;
_turnContextPoweredObjectsFactory = turnContextPoweredObjectsFactory;
}
/// <summary>
///
/// </summary>
/// <param name="activityService"></param>
/// <param name="logger"></param>
/// <param name="activityFactory"></param>
/// <param name="activityUploadService"></param>
public ActivityController(IActivityService activityService, ILogger logger, IActivityFactory activityFactory, IActivityUploadService activityUploadService)
{
_activityService = activityService;
_activityUploadService = activityUploadService;
_ILogger = logger;
_activityFactory = activityFactory;
}
private void Initiate(IActivityFactory activityFactory, IBaseMessage message, string processName)
{
var previousTrackingContext = message.GetTrackingContext();
// an outbound message without an ongoing process --i.e. that has no process affiliation-- denotes a
// publish/subscribe, or messaging-only process and the whole process needs to be tracked; that means the
// initiating messaging step, whose MessagingStepActivityId is still conveyed by the ambient
// previousTrackingContext, as well as the currently ongoing messaging step, which completes the process.
var isMessagingProcess = message.Direction().IsOutbound() &&
!previousTrackingContext.HasProcessAffiliation() &&
!previousTrackingContext.MessagingStepActivityId.IsNullOrEmpty();
if (_logger.IsDebugEnabled)
{
_logger.Debug($"Initiating tracking of a messaging {(isMessagingProcess ? "process" : "step")}.");
}
_process = isMessagingProcess
? activityFactory.CreateProcess(message, processName)
: previousTrackingContext.HasProcessAffiliation()
? activityFactory.FindProcess(previousTrackingContext)
: null;
_previousMessagingStep = isMessagingProcess
? activityFactory.FindMessagingStep(previousTrackingContext)
: null;
_messagingStep = activityFactory.CreateMessagingStep(message);
}
private static Activities GetActivities(IList <IBaseElement> baseElements)
{
Activities activities = new Activities();
activities.Activity = new Activity[baseElements.Count];
int counter = 0;
foreach (IBaseElement baseElement in baseElements)
{
Type type = baseElement.GetType();
XpdlActivityFactoryAttribute factoryAttribute = type.GetCustomAttribute <XpdlActivityFactoryAttribute>();
if (factoryAttribute != null)
{
IActivityFactory factory = factoryAttribute.Factory;
Activity activity = factory.CreateActivity(baseElement);
activities.Activity[counter] = activity;
counter++;
}
else
{
activities.Activity[counter] = new Activity()
{
Name = type.Name
};
}
}
return(activities);
}
public WorkflowExecutor(Execution <TContext> execution, TContext context, INodesResolver <TContext> nodes, IActivityFactory factory, IActivityExecutor activityExecutor)
{
m_Context = context;
m_Factory = factory;
m_Execution = execution;
m_Nodes = nodes;
m_ActivityExecutor = activityExecutor;
}
/// <summary>
/// Created an activity factory for the specified activity type
/// </summary>
/// <typeparam name="TActivity"></typeparam>
/// <typeparam name="TArguments"></typeparam>
/// <typeparam name="TLog"></typeparam>
/// <param name="activityFactory"></param>
/// <returns></returns>
public static IActivityFactory <TActivity, TArguments, TLog> CreateActivityFactory <TActivity, TArguments, TLog>(
this IActivityFactory activityFactory)
where TActivity : class, IExecuteActivity <TArguments>, ICompensateActivity <TLog>
where TArguments : class
where TLog : class
{
return(new GenericActivityFactory <TActivity, TArguments, TLog>(activityFactory));
}
public UseCaseFactory(IActivityFactory activityFactory)
{
this.collection.Add(typeof(IUseCase <AddProductGoodsRequest, AddProductGoodsResponse>),
new AddProductGoodsUseCase(activityFactory.Create <IValidationActivity <AddProductGoodsRequest> >(),
activityFactory.Create <IAddProductActivity>(),
activityFactory.Create <IGetProductActivity>(),
activityFactory.Create <IAddArrivedGoodsActivity>(),
activityFactory.Create <IGetArrivedGoodsActivity>()));
this.collection.Add(typeof(IUseCase <EditProductGoodsRequest, EditProductGoodsResponse>),
new EditProductGoodsUseCase(activityFactory.Create <IValidationActivity <EditProductGoodsRequest> >(),
activityFactory.Create <IEditProductActivity>(),
activityFactory.Create <IGetProductActivity>(),
activityFactory.Create <IEditArrivedGoodsActivity>(),
activityFactory.Create <IGetArrivedGoodsActivity>()));
this.collection.Add(typeof(IUseCase <GetArrivedGoodsRequest, GetArrivedGoodsResponse>),
new GetArrivedGoodsUseCase(activityFactory.Create <IGetArrivedGoodsActivity>()));
this.collection.Add(typeof(IUseCase <GetProductRequest, GetProductResponse>),
new GetProductUseCase(activityFactory.Create <IGetProductActivity>()));
this.collection.Add(typeof(IUseCase <GetProductByDateRequest, GetProductByDateResponse>),
new GetProductByDateUseCase(activityFactory.Create <IValidationActivity <GetProductByDateRequest> >(), activityFactory.Create <IGetProductsByDateActivity>()));
this.collection.Add(typeof(IUseCase <GetCategoryRequest, GetCategoryResponse>),
new GetCategoryUseCase(activityFactory.Create <IGetCategoryActivity>()));
this.collection.Add(typeof(IUseCase <GetClassRequest, GetClassResponse>),
new GetClassUseCase(activityFactory.Create <IGetClassActivity>()));
this.collection.Add(typeof(IUseCase <GetDepartmentRequest, GetDepartmentResponse>),
new GetDepartmentUseCase(activityFactory.Create <IGetDepartmentActivity>()));
this.collection.Add(typeof(IUseCase <GetProviderRequest, GetProviderResponse>),
new GetProviderUseCase(activityFactory.Create <IGetProviderActivity>()));
this.collection.Add(typeof(IUseCase <GetReportDetailedRequest, GetReportDetailedResponse>),
new GetReportDetailedUseCase(activityFactory.Create <IValidationActivity <GetReportDetailedRequest> >(), activityFactory.Create <IGetReportDetailedActivity>()));
this.collection.Add(typeof(IUseCase <GetReportSimpleRequest, GetReportSimpleResponse>),
new GetReportSimpleUseCase(activityFactory.Create <IValidationActivity <GetReportSimpleRequest> >(), activityFactory.Create <IGetReportSimpleActivity>()));
this.collection.Add(typeof(IUseCase <AddSaleRequest, AddSaleResponse>),
new AddSaleUseCase(activityFactory.Create <IValidationActivity <AddSaleRequest> >(),
activityFactory.Create <IAddSaleActivity>(),
activityFactory.Create <IGetSaleActivity>(),
activityFactory.Create <IEditProductActivity>(),
activityFactory.Create <IGetProductActivity>()));
this.collection.Add(typeof(IUseCase <GetSaleRequest, GetSaleResponse>),
new GetSaleUseCase(activityFactory.Create <IGetSaleActivity>()));
this.collection.Add(typeof(IUseCase <GetSaleByClassRequest, GetSaleByClassResponse>),
new GetSaleByClassUseCase(activityFactory.Create <IValidationActivity <GetSaleByClassRequest> >(), activityFactory.Create <IGetSalesByClassActivity>()));
this.collection.Add(typeof(IUseCase <GetTareChangeRequest, GetTareChangeResponse>),
new GetTareChangeUseCase(activityFactory.Create <IGetTareChangeActivity>()));
this.collection.Add(typeof(IUseCase <GetUserRequest, GetUserResponse>),
new GetUserUseCase(activityFactory.Create <IValidationActivity <GetUserRequest> >(), activityFactory.Create <IGetUserActivity>()));
this.collection.Add(typeof(IUseCase <GetSellerRequest, GetSellerResponse>),
new GetSellerUseCase(activityFactory.Create <IGetSellerActivity>()));
}
public ActivityResult Execute(
Guid activityExecutionId,
IActivityFactory factory,
TContext context,
IActivityInputProvider inputProvider,
out object activityOutput,
Action <object> beforeExecute)
{
IActivity <TInput, TOutput, TFailOutput> activity = null;
try
{
activity = m_ActivityCreation(factory);
object actout = null;
TInput activityInput = null;
try
{
if (inputProvider != null)
{
activityInput = inputProvider.GetInput <TInput>();
}
if (activityInput == null)
{
activityInput = m_GetActivityInput(context);
}
beforeExecute(activity.IsInputSerializable ? activityInput : null);
}
catch (Exception e)
{
beforeExecute("Failed to get activity input: " + e);
throw;
}
var result = activity.Execute(
activityExecutionId,
activityInput,
output =>
{
actout = output;
m_ProcessOutput(context, output);
},
output =>
{
actout = output;
m_ProcessFailOutput(context, output);
});
activityOutput = actout;
return(result);
}
finally
{
if (activity != null)
{
factory.Release(activity);
}
}
}
public Workflow(string name, IWorkflowPersister <TContext> persister, IActivityFactory activityFactory = null, IActivityExecutor activityExecutor = null)
{
m_ActivityExecutor = activityExecutor ?? this;
m_ActivityFactory = activityFactory ?? this;
m_Persister = persister;
Name = name;
m_Start = new GraphNode <TContext, EmptyActivity, object, object>("start", context => null, (context, o) => { });
m_End = new GraphNode <TContext, EndActivity, object, object>("end", context => null, (context, o) => { });
registerNode(m_End);
}
public ActivityResult Complete(
Guid activityExecutionId,
IActivityFactory factory,
TContext context,
IActivityOutputProvider outputProvider,
out object activityOutput)
{
activityOutput = null;
return(ActivityResult.Succeeded);
}
public ActivityResult Resume <TClosure>(
Guid activityExecutionId,
IActivityFactory factory,
TContext context,
TClosure closure,
out object activityOutput)
{
activityOutput = null;
return(ActivityResult.Succeeded);
}
public ResumeAfterWorkflowExecutor(
Execution <TContext> execution,
TContext context,
INodesResolver <TContext> nodes,
IActivityFactory factory,
IExecutionObserver observer,
IActivityOutputProvider outputProvider)
: base(execution, context, nodes, factory, observer)
{
m_OutputProvider = outputProvider;
}
internal EngineBuilder()
{
this.productFactory = new Mock <IProductFactory>().Object;
this.activityFactory = new Mock <IActivityFactory>().Object;
this.goalFactory = new Mock <IGoalFactory>().Object;
this.dailyNutriCalc = new Mock <IDailyNutriCalc>().Object;
this.restingEnergyCalculator = new Mock <IRestingEnergyCalculator>().Object;
this.jsonSerializer = new Mock <IJsonSerializer>().Object;
this.dataRepository = new Mock <IDataRepository>().Object;
this.suggestedDailyNutrientsIntakeCalc = new Mock <ISuggestedDailyNutrientsIntakeCalc>().Object;
}
public ActivityResult Execute(
Guid activityExecutionId,
IActivityFactory factory,
TContext context,
IActivityInputProvider inputProvider,
out object activityOutput,
Action <object> beforeExecute)
{
beforeExecute(null);
activityOutput = null;
return(ActivityResult.Succeeded);
}
public Workflow(
string name,
IWorkflowPersister <TContext> persister,
IActivityFactory activityFactory = null,
IExecutionObserver executionObserver = null)
: this(
persister,
activityFactory,
executionObserver)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
}
protected WorkflowExecutorBase(
Execution <TContext> execution,
TContext context,
INodesResolver <TContext> nodes,
IActivityFactory factory,
IExecutionObserver observer)
{
m_ExecutionObserver = observer ?? new NullExecutionObserver();
m_Context = context;
Factory = factory;
m_Execution = execution;
m_Nodes = nodes;
}
public XpdlActivityFactoryAttribute(Type factoryType)
{
if (!typeof(IActivityFactory).IsAssignableFrom(factoryType))
{
throw new ArgumentException(string.Format("{0} must implement IActivityFactory interface", factoryType.Name));
}
if (factoryType.IsAbstract)
{
throw new ArgumentException(string.Format("{0} can not be abstract", factoryType.Name));
}
ActivityFactoryType = factoryType;
Factory = Activator.CreateInstance(factoryType) as IActivityFactory;
}
protected WorkflowExecutorBase(
Execution execution,
TContext context,
Workflow <TContext> workflow,
IActivityFactory factory,
IExecutionObserver observer)
{
m_ExecutionObserver = observer ?? new NullExecutionObserver();
m_Context = context;
Factory = factory;
m_Execution = execution;
_workflow = workflow;
_workflowTypeName = _workflow.GetType().Name;
}
public WorkflowExecutor(
Execution execution,
TContext context,
Workflow <TContext> workflow,
IActivityFactory factory,
IExecutionObserver observer)
: base(
execution,
context,
workflow,
factory,
observer)
{
}
private CalorieCounterEngine()
{
this.products = new Dictionary <string, IProduct>(StringComparer.InvariantCultureIgnoreCase);
this.dailyProgressDirectory = Directory.CreateDirectory(EngineConstants.DailyProgressDirectoryName);
this.productsDirectory = Directory.CreateDirectory(EngineConstants.ProductsDirectoryName);
// TODO: Set proper can execute conditions.
// TODO: JSON deserialization for current date.
this.LoadProgress();
this.createProductCommand = new RelayCommand(this.CreateProduct, arg => true);
this.productFactory = new ProductFactory();
this.activityFactory = new ActivityFactory();
//TODO: Deserialize and load all products from the local directory into the list.
}
public ActivityResult Complete(
Guid activityExecutionId,
IActivityFactory factory,
TContext context,
IActivityOutputProvider outputProvider,
out object activityOutput)
{
var output = outputProvider.GetOuput <TOutput>();
m_ProcessOutput(context, output);
activityOutput = output;
return(ActivityResult.Succeeded);
}
public WorkflowExecutor(
Execution <TContext> execution,
TContext context,
INodesResolver <TContext> nodes,
IActivityFactory factory,
IExecutionObserver observer)
: base(
execution,
context,
nodes,
factory,
observer)
{
}
public ActivityTestHarness(BusTestHarness testHarness, IActivityFactory <TActivity, TArguments, TLog> activityFactory,
Action <IExecuteActivityConfigurator <TActivity, TArguments> > configureExecute,
Action <ICompensateActivityConfigurator <TActivity, TLog> > configureCompensate)
{
_configureExecute = configureExecute;
_configureCompensate = configureCompensate;
_activityFactory = activityFactory;
Name = GetActivityName();
ExecuteQueueName = BuildQueueName("execute");
CompensateQueueName = BuildQueueName("compensate");
testHarness.OnConfigureBus += ConfigureBus;
}
public WorkflowEngineFactory(
IActivityFactory activityFactory,
IEventHandlerFactory eventHandlerFactory,
IWorkflowDomainStore workflowDomainStore,
IWorkflowStoreFactory workflowStoreFactory,
IWorkflowMessageTransportFactoryProvider workflowMessageTransportFactoryProvider,
IWorkflowRuntimeConfigurationFactory workflowRuntimeConfigurationFactory)
{
_activityFactory = activityFactory;
_eventHandlerFactory = eventHandlerFactory;
_workflowDomainStore = workflowDomainStore;
_workflowStoreFactory = workflowStoreFactory;
_workflowRuntimeConfigurationFactory = workflowRuntimeConfigurationFactory;
_workflowMessageTransportFactoryProvider = workflowMessageTransportFactoryProvider;
}
public Workflow(
IWorkflowPersister <TContext> persister,
IActivityFactory activityFactory = null,
IExecutionObserver executionObserver = null)
{
m_ExecutionObserver = executionObserver;
m_ActivityFactory = activityFactory ?? this;
m_Persister = persister;
m_Start = new GraphNode <TContext>("start");
m_End = new GraphNode <TContext>("end");
m_Fail = new GraphNode <TContext>("fail");
RegisterNode(m_Start);
RegisterNode(m_End);
RegisterNode(m_Fail);
}
public ActivityResolver(IActivityFactory activictyFactory, IEnumerable <IActivityRegistration> activityRegistrations)
{
_activictyFactory = activictyFactory;
_activityRegistrations = activityRegistrations;
var registrations = activityRegistrations as ActivityRegistration[] ?? activityRegistrations.ToArray();
var activityNamesForActivityResolver = registrations.Where(a => a.ActivityType != null && a.ActivityMethod == null)
.ToDictionary(
a => !string.IsNullOrEmpty(a.ActivityName) ? a.ActivityName : a.ActivityType.Name,
a => a.ActivityType
);
_registeredActivityNames = activityNamesForActivityResolver;
}
public ResumeFromWorkflowExecutor(
Execution <TContext> execution,
TContext context,
INodesResolver <TContext> nodes,
IActivityFactory factory,
IExecutionObserver observer,
object input)
: base(
execution,
context,
nodes,
factory,
observer)
{
m_Input = input;
}
public ResumeFromWorkflowExecutor(
Execution execution,
TContext context,
Workflow <TContext> workflow,
IActivityFactory factory,
IExecutionObserver observer,
object input)
: base(
execution,
context,
workflow,
factory,
observer)
{
m_Input = input;
}
