public ErrorHandlingMiddleware(RequestDelegate next, ILogger <ErrorHandlingMiddleware> logger)
{
Affirm.ArgumentNotNull(logger, "logger");
_next = next;
_logger = logger;
}
public IStateMachine Start(IStateMachineDefinition def, ISMParameters parameters, string key)
{
Affirm.ArgumentNotNull(key, "key");
var sm = _sMFactory.Get(key);
return(Start(def, parameters, sm));
}
private ITransition GetNextTransition(IStateMachine sm, ISMParameters parameters)
{
Affirm.ArgumentNotNull(sm, "sm");
var possibleTransitions = sm.Definition.GetTransitions(sm.CurrentState);
if (possibleTransitions == null)
{
throw new InvalidOperationException("{0}: no transitions found {1}".FormIt(sm));
}
var triggers = possibleTransitions.Select(_ => new { trigger = _.Trigger, tran = _ }).ToList();
var theOne = triggers.Where(_ => _.trigger.Invoke(_.tran, parameters)).ToList();
if (!theOne.Any())
{
throw new NoTrueTriggerException(sm.SmId, "{0}: no true trigger result found for state {1}".FormIt(sm, sm.CurrentStateId));
}
if (theOne.Count() > 1)
{
throw new TooManyTriggersException(theOne.Select(_ => _.trigger).ToList(), sm.SmId, "{0}: too many triggers are true {1}".FormIt(sm, sm.CurrentStateId));
}
return(theOne.First().tran);
}
public void SetDefinition(IStateMachineDefinition definition)
{
Affirm.ArgumentNotNull(definition, "definition");
definition.Validate();
Definition = definition;
}
/// <summary>
/// Executes action on instance of <see cref="ISMBaseElement"/>
/// </summary>
public static T Setup <T>(this T t, Action <T> action) where T : IRoot
{
Affirm.ArgumentNotNull(action, "action");
action(t);
return(t);
}
public MSSQLSourceSchema(IUnitOfWorkFactory uowf, IExtractConfiguration globalConfiguration)
{
Affirm.ArgumentNotNull(uowf, "uowf");
_uowFactory = uowf;
_globalConfiguration = globalConfiguration;
WasInit = false;
}
public void ExitState(IState state, ISMParameters parameters)
{
Affirm.ArgumentNotNull(state, "state");
if (state.ExitActions != null)
{
InvokeActionList(state, parameters, state.ExitActions);
}
}
public ObjectMetaDataProvider(IUnitOfWorkFactory uowf, ILog log, IMetaDataInitializer initializer)
{
Affirm.ArgumentNotNull(uowf, "uowf");
Affirm.ArgumentNotNull(log, "log");
_log = log;
_uowFactory = uowf;
_initializer = initializer;
}
public TableToExtract(string tableName, ExtractStrategy extractStrategy, SqlBuildStrategy sqlBuildStrategy)
{
Affirm.NotNullOrEmpty(tableName, "tableName");
Affirm.ArgumentNotNull(extractStrategy, "extractStrategy");
Affirm.ArgumentNotNull(sqlBuildStrategy, "sqlBuildStrategy");
TableName = tableName;
ExtractStrategy = extractStrategy;
SqlBuildStrategy = sqlBuildStrategy;
}
public static IList <ITransition> GetTransitions(this IStateMachineDefinition def, IState state)
{
Affirm.ArgumentNotNull(state, "state");
if (def.Transitions == null)
{
return(null);
}
return(GetTransitions(def, state.id));
}
private void InvokeActionList(IState state, ISMParameters parameters, IEnumerable <IActionHolder> source)
{
Affirm.ArgumentNotNull(state, "state");
if (source != null)
{
foreach (var act in GetOrdered(source))
{
act.Invoke(parameters);
}
}
}
public DependencyBuilder(IUnitOfWorkFactory unitOfWorkFactory, ISourceSchema schema, ILog log, IExtractConfiguration configuration)
{
Affirm.ArgumentNotNull(unitOfWorkFactory, "unitOfWorkFactory");
Affirm.ArgumentNotNull(schema, "schema");
Affirm.ArgumentNotNull(log, "log");
Affirm.ArgumentNotNull(configuration, "configuration");
_unitOfWorkFactory = unitOfWorkFactory;
_schema = schema;
_log = log;
_configuration = configuration;
}
public MSSQLSourceSchema(IUnitOfWorkFactory uowf, IExtractConfiguration globalConfiguration, ILog log, IObjectMetaDataProvider objectMetaDataProvider)
{
Affirm.ArgumentNotNull(uowf, "uowf");
Affirm.ArgumentNotNull(log, "log");
Affirm.ArgumentNotNull(objectMetaDataProvider, "objectMetaDataProvider");
_log = log;
_uowFactory = uowf;
_globalConfiguration = globalConfiguration;
_objectMetaDataProvider = objectMetaDataProvider;
WasInit = false;
}
public SMService(IStateProcessor stateProcessor, IPersistenceService persistenceService, ISMFactory sMFactory, IServiceProvider serviceProvider)
{
Affirm.ArgumentNotNull(stateProcessor, "stateProcessor");
Affirm.ArgumentNotNull(persistenceService, "persistenceService");
Affirm.ArgumentNotNull(sMFactory, "sMFactory");
Affirm.ArgumentNotNull(serviceProvider, "serviceProvider");
_stateProcessor = stateProcessor;
_persistenceService = persistenceService;
_sMFactory = sMFactory;
_serviceProvider = serviceProvider;
}
public PackageProcessorController(ISourceSchema schema, ILog log, ISqlBuilder sqlBuilder, IDependencyBuilder dependencyBuilder)
{
Affirm.ArgumentNotNull(schema, "schema");
Affirm.ArgumentNotNull(log, "log");
Affirm.ArgumentNotNull(sqlBuilder, "sqlBuilder");
Affirm.ArgumentNotNull(dependencyBuilder, "dependencyBuilder");
_schema = schema;
_sqlBuilder = sqlBuilder;
_log = log;
_dependencyBuilder = dependencyBuilder;
}
private IStateMachine MoveToState(IStateMachine sm, IState state, ISMParameters parameters)
{
Affirm.ArgumentNotNull(sm, "sm");
Affirm.ArgumentNotNull(state, "state");
Log.Debug("{0} is going to be moved to state {1}".FormIt(sm, state.id));
_stateProcessor.ProcessState(state, parameters);
sm.SetCurrentState(state);
return(sm);
}
IStateMachine Start(IStateMachineDefinition def, ISMParameters paramters, IStateMachine sm)
{
Affirm.ArgumentNotNull(def, "definition");
Affirm.ArgumentNotNull(sm, "machine");
def.Validate();
Log.Debug("SM with {0} is going to be started".FormIt(sm.GetType()));
sm.SmId = Guid.NewGuid();
_persistenceService.BuildUpDefinition(sm, def);
var initialState = sm.Definition.GetInitialState();
if (initialState == null)
{
throw new InvalidOperationException("{0}: can not find intitial state".FormIt(sm));
}
return(MoveToState(sm, initialState, paramters));
}
public IStateMachine Start(IStateMachineDefinition def, ISMParameters parameters, Type smType)
{
Affirm.ArgumentNotNull(smType, "smType");
var sm = _serviceProvider.GetService(smType) as IStateMachine;
if (sm == null)
{
throw new ArgumentNullException("Given type {0} is not assingable from IStateMachine or can not be resolved".FormIt(smType));
}
try
{
Start(def, parameters, sm);
}
catch
{
sm?.Dispose();
throw;
}
return(sm);
}
public IStateMachine Push(IStateMachine sm, ISMParameters parameters)
{
Affirm.ArgumentNotNull(sm, "sm");
Log.Debug("{0} going to be pushed".FormIt(sm));
if (sm.Finished)
{
throw new InvalidOperationException("{0} is finished already! can not push!".FormIt(sm));
}
_stateProcessor.ExitState(sm.CurrentState, parameters);
var nextState = GetNextTransition(sm, parameters).TargetStateId;
var state = sm.Definition.GetStateById(nextState);
if (state == null)
{
throw new InvalidOperationException("{0}: State {1} not found!".FormIt(sm, nextState));
}
return(MoveToState(sm, state, parameters));
}
public static void CheckState(this IStateMachineDefinition def, IState state)
{
Affirm.ArgumentNotNull(state, "state");
def.CheckState(state.id);
}
public virtual void BuildUpDefinition(IStateMachine sm, IStateMachineDefinition def)
{
Affirm.ArgumentNotNull(sm, "sm");
Affirm.ArgumentNotNull(def, "def");
def.Validate();
sm.CurrentState = def.GetStateById(sm.CurrentStateId);
var childContainer = _serviceProvider.CreateScope();
//childContainer.RegisterInstance(typeof(IStateMachine), sm);
//childContainer.RegisterInstance(sm.GetType(), sm);
sm.Container = childContainer;
var actionFabric = sm.Container.ServiceProvider.GetRequiredService <IActionFabric>();
var triggerFabric = sm.Container.ServiceProvider.GetRequiredService <ITriggerFabric>();
Action <IEnumerable <IActionHolder> > buildUpActions = (s) =>
{
foreach (var act in s)
{
act.NestedAction = actionFabric.Get(act.Code);
if (act.NestedAction == null)
{
throw new StateMachineException(sm.SmId, $"Can not resolve {act.Code} from ation fabric");
}
act.NestedAction.StateMachine = sm;
}
};
foreach (var state in def.States)
{
state.StateMachine = sm;
if (state.EnterActions != null)
{
buildUpActions(state.EnterActions);
}
if (state.ExitActions != null)
{
buildUpActions(state.ExitActions);
}
}
foreach (var tran in def.Transitions)
{
tran.StateMachine = sm;
if (tran.Trigger != null &&
!string.IsNullOrEmpty(tran.Trigger.Code))
{
var trigger = triggerFabric.Get(tran.Trigger.Code);
if (trigger == null)
{
throw new StateMachineException(sm.SmId, $"Can not resolve {tran.Trigger.Code} from trigger fabric");
}
trigger.StateMachine = sm;
tran.Trigger.NestedAction = trigger;
}
}
sm.SetDefinition(def);
}
public BasePersistenceService(IServiceProvider serviceProvider)
{
Affirm.ArgumentNotNull(serviceProvider, nameof(serviceProvider));
_serviceProvider = serviceProvider;
}
