public Engine(IWorkItemRepository repository, IActivityRunner activityRunner,
IStateMachineProvider stateMachineProvider)
{
if (repository == null) throw new ArgumentNullException("repository");
if (activityRunner == null) throw new ArgumentNullException("activityRunner");
if (stateMachineProvider == null) throw new ArgumentNullException("stateMachineProvider");
_repository = repository;
_activityRunner = activityRunner;
_stateMachineProvider = stateMachineProvider;
_stateQueue = new ActionBlock<int>(id => UpdateState(id),
new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = 1
});
_workerQueue = new ActionBlock<int>(id => RunActivity(id),
new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = int.MaxValue
});
_stateQueue.Completion.ContinueWith(t => { _workerQueue.Complete(); }, TaskContinuationOptions.OnlyOnFaulted);
_workerQueue.Completion.ContinueWith(t => { ((IDataflowBlock) _stateQueue).Fault(t.Exception); },
TaskContinuationOptions.OnlyOnFaulted);
}
public WorkItemDtoDataService(
IWorkItemRepository workItemRepository,
IAdapterResolver adapterResolver)
{
_workItemRepository = workItemRepository;
_adapterResolver = adapterResolver;
}
/// <summary>
/// 构造
/// </summary>
/// <param name="workItemResitory">工作记录仓储</param>
/// <param name="departmentResitory">部门仓储</param>
/// <param name="userResitory">用户仓储</param>
/// <param name="roleResitory">角色仓储</param>
public HomeController(IWorkItemRepository workItemResitory, IDepartmentRepository departmentResitory, IUserRepository userResitory, IRoleRepository roleResitory)
{
_workItemResitory = workItemResitory;
_userResitory = userResitory;
_departmentResitory = departmentResitory;
_roleResitory = roleResitory;
}
public ExceptionStateMachine(IWorkItemRepository repository, IDataStore dataStore,
IWorkflowPathNavigator navigator)
{
_repository = repository;
_dataStore = dataStore;
_navigator = navigator;
}
private IWorkItemRepository SetupFakeRepository()
{
repository = Substitute.For <IWorkItemRepository>();
workItem = Substitute.For <IWorkItem>();
//workItem.Fields.Returns(Substitute.For<IFieldCollectionWrapper>());
var estWorkField = Substitute.For <IFieldWrapper>();
workItem.Fields["EstimatedWork"] = estWorkField;
workItem.Id.Returns(1);
double fieldValue = 0.0D;
var f = workItem.Fields;
var x = workItem.Fields["Estimated Work"];
workItem.Fields["Estimated Work"].Value = fieldValue;
workItem.When(w => w[Arg.Any <string>()] = Arg.Any <Double>())
.Do(c => {
workItem.Fields[(string)c[0]].Value = (double)c[1];
});
workItem.GetField("Estimated Dev Work", 0.0D).Returns(1.0D);
workItem.GetField("Estimated Test Work", 0.0D).Returns(2.0D);
workItem.TypeName.Returns("Task");
workItem.IsValid().Returns(true);
repository.GetWorkItem(1).Returns(workItem);
return(repository);
}
public SequenceStateMachineTests()
{
_repository = Substitute.For<IWorkItemRepository>();
_workItemBuilder = Substitute.For<IWorkItemBuilder>();
_engine = Substitute.For<IEngine>();
_stateMachine = new SequenceStateMachine(_repository, _workItemBuilder);
}
protected WorkList(IWorkItemRepository repository, string name)
{
Repository = repository;
Name = name ?? string.Empty;
Visibility = WorkItemVisibility.Todo;
AreaOfInterest = null;
CurrentIndex = repository.GetCurrentIndex();
foreach (IWorkItem item in Repository.GetItems())
{
_items.Add(item);
if (!_rowMap.ContainsKey(item.Proxy))
{
_rowMap.Add(item.Proxy, item);
}
else
{
// todo daro: warn
}
}
// initializes the state repository if no states for
// the work items are read yet
Repository.UpdateVolatileState(_items);
// todo daro: EnvelopeBuilder as parameter > do not iterate again over items
// look old work item implementation
Extent = GetExtentFromItems(_items);
}
public CommentValidator(IWorkItemRepository workItemRepository)
{
RuleFor(x => x.Body).NotEmpty().Length(1, 200);
RuleFor(x => x.WorkItemId).NotEmpty()
.Must(workItemId => workItemRepository.GetById(workItemId).Result != null)
.WithMessage("Foreign key constraint failure");
}
public WorkItemLinkCollectionWrapper(WorkItemLinkCollection workItemLinkCollection, IRuntimeContext context)
{
this.logger = context.Logger;
this.workItemLinkCollection = workItemLinkCollection;
this.store = context.WorkItemRepository;
this.context = context;
}
public ActivityRunnerTests()
{
_dataStore = Substitute.For<IDataStore>();
_repository = Substitute.For<IWorkItemRepository>();
_workflowPathNavigator = Substitute.For<IWorkflowPathNavigator>();
_activityRunner = new ActivityRunner(_workflowPathNavigator, _dataStore, _repository);
}
internal static ScriptEngine MakeEngine(string scriptLanguage, IWorkItemRepository workItemRepository, ILogEvents logger, bool debug)
{
logger.BuildingScriptEngine(scriptLanguage);
Type t = GetScriptEngineType(scriptLanguage);
var ctor = t.GetConstructor(new Type[] { typeof(IWorkItemRepository), typeof(ILogEvents), typeof(bool) });
ScriptEngine engine = ctor.Invoke(new object[] { workItemRepository, logger, debug }) as ScriptEngine;
return engine;
}
public RetryStateMachineTests()
{
_repository = Substitute.For<IWorkItemRepository>();
_workItemBuilder = Substitute.For<IWorkItemBuilder>();
_workflowPathNavigator = Substitute.For<IWorkflowPathNavigator>();
_stateMachine = new RetryStateMachine(_repository, _workItemBuilder, _workflowPathNavigator);
_engine = Substitute.For<IEngine>();
}
public HomeController(ILogger <HomeController> logger, IUserRepository userRepository, IDepartmentRepository departmentRepository, IWorkItemRepository workItemRepository, IRoleRepository roleRepository)
{
_logger = logger;
_userRepository = userRepository;
_departmentRepository = departmentRepository;
_workItemRepository = workItemRepository;
_roleRepository = roleRepository;
}
public WorkItemApiService(IWorkItemRepository repository, IUsersService userService, INotificationService notificationService, IRealtimeNotificationService realtimeNotificationService,
ISettingsValueProvider settingsProvider)
: base(repository, settingsProvider)
{
_userService = userService;
_notificationService = notificationService;
_realtimeNotificationService = realtimeNotificationService;
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor"/> class.
/// </summary>
public EventProcessor(IWorkItemRepository workItemStore, IRuntimeContext runtime)
{
this.logger = runtime.Logger;
this.store = workItemStore;
this.settings = runtime.Settings;
this.engine = runtime.GetEngine(workItemStore);
}
public WorkItemService(IWorkItemRepository repository, IENodebRepository eNodebRepository,
IBtsRepository btsRepository, ITownRepository townRepository)
{
_repository = repository;
_eNodebRepository = eNodebRepository;
_btsRepository = btsRepository;
_townRepository = townRepository;
}
public WebFarmJobCoordinator(IWorkItemRepository workItemRepository)
{
if (workItemRepository == null)
{
throw new ArgumentNullException("workItemRepository");
}
_workItemRepository = workItemRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor"/> class.
/// </summary>
public EventProcessor(IWorkItemRepository workItemStore, IRuntimeContext runtime)
{
this.logger = runtime.Logger;
this.store = workItemStore;
this.settings = runtime.Settings;
this.engine = runtime.GetEngine(workItemStore);
}
public SequenceStateMachine(IWorkItemRepository repository, IWorkItemBuilder workItemBuilder)
{
if (repository == null) throw new ArgumentNullException("repository");
if (workItemBuilder == null) throw new ArgumentNullException("workItemBuilder");
_repository = repository;
_workItemBuilder = workItemBuilder;
}
private async Task LoadCurrentReleaseNotesAsync()
{
IWorkItemRepository workItemRepository = _provider.GetRequiredService <IWorkItemRepository>();
IList <WorkItem> workItems = await workItemRepository.GetLatestReleaseWorkItemsAsync();
DisplayWorkItems(workItems);
}
public WorkItemService(IWorkItemRepository workItemRepository, IMapper mapper, IBus bus, IFileUploader fileUploader, IWorkItemFileRepository workItemFileRepository)
{
_workItemRepository = workItemRepository;
_mapper = mapper;
_bus = bus;
_fileUploader = fileUploader;
_workItemFileRepository = workItemFileRepository;
}
public WebFarmJobCoordinator(IWorkItemRepository workItemRepository)
{
if (workItemRepository == null)
{
throw new ArgumentNullException("workItemRepository");
}
_workItemRepository = workItemRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor"/> class.
/// </summary>
public EventProcessor(IRuntimeContext runtime)
{
this.logger = runtime.Logger;
this.settings = runtime.Settings;
this.limiter = runtime.RateLimiter;
this.store = runtime.GetWorkItemRepository();
this.engine = runtime.GetEngine();
}
internal static ScriptEngine MakeEngine(string scriptLanguage, IWorkItemRepository workItemRepository, ILogEvents logger, bool debug)
{
logger.BuildingScriptEngine(scriptLanguage);
Type t = GetScriptEngineType(scriptLanguage);
var ctor = t.GetConstructor(new Type[] { typeof(IWorkItemRepository), typeof(ILogEvents), typeof(bool) });
ScriptEngine engine = ctor.Invoke(new object[] { workItemRepository, logger, debug }) as ScriptEngine;
return(engine);
}
public WorkItemService(IWorkItemRepository repository, IENodebRepository eNodebRepository,
IBtsRepository btsRepository, ITownRepository townRepository, ICellRepository cellRepository)
{
_repository = repository;
_eNodebRepository = eNodebRepository;
_btsRepository = btsRepository;
_townRepository = townRepository;
_cellRepository = cellRepository;
}
public ReleaseService(
IBuildChangeRepository buildChangeRepository,
IWorkItemRepository workItemRepository,
IWorkItemReleaseFactory releaseFactory)
{
_buildChangeRepository = buildChangeRepository;
_workItemRepository = workItemRepository;
_releaseFactory = releaseFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor"/> class.
/// </summary>
public EventProcessor(IRuntimeContext runtime)
{
this.logger = runtime.Logger;
this.settings = runtime.Settings;
this.limiter = runtime.RateLimiter;
this.store = runtime.WorkItemRepository;
this.engine = runtime.GetEngine();
}
public CommentValidatorTests()
{
_workItemRepository = Substitute.For <IWorkItemRepository>();
_workItemRepository.GetById(1).Returns(new WorkItem());
_workItemRepository.GetById(0).Returns <WorkItem>(value => null);
_validator = new CommentValidator(_workItemRepository);
}
public ForkStateMachineTests()
{
_repository = Substitute.For<IWorkItemRepository>();
_workItemBuilder = Substitute.For<IWorkItemBuilder>();
_workflowPathNavigator = Substitute.For<IWorkflowPathNavigator>();
_dataStore = Substitute.For<IDataStore>();
_stateMachine = new ForkStateMachine(_repository, _workItemBuilder, _workflowPathNavigator, _dataStore);
_engine = Substitute.For<IEngine>();
}
public WorkItemsController(WorkItemService workItemService,
IWorkItemRepository workItemRepository,
IIterationRepository iterationRepository,
IMapper mapper)
{
_mapper = mapper;
_workItemService = workItemService;
_workItemRepository = workItemRepository;
_iterationRepository = iterationRepository;
}
private async Task LoadSelectedReleaseNotesAsync()
{
IWorkItemRepository workItemRepository = _provider.GetRequiredService <IWorkItemRepository>();
ReleaseTag releaseTag = lstStartRelease.SelectedItem as ReleaseTag;
IList <WorkItem> workItems = await workItemRepository.GetReleaseWorkItemsAsync(releaseTag);
DisplayWorkItems(workItems);
}
public UnitOfWork(TaskDbContext context,
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IWorkItemRepository workItemRepository)
{
_context = context;
this.UserManager = userManager;
this.SignInManager = signInManager;
this.WorkItemRepository = workItemRepository;
}
public RetryStateMachine(IWorkItemRepository repository, IWorkItemBuilder workItemBuilder,
IWorkflowPathNavigator navigator)
{
if (repository == null) throw new ArgumentNullException("repository");
if (workItemBuilder == null) throw new ArgumentNullException("workItemBuilder");
_repository = repository;
_workItemBuilder = workItemBuilder;
_navigator = navigator;
}
private async Task LoadSelectedRangeReleaseNotesAsync()
{
IWorkItemRepository workItemRepository = _provider.GetRequiredService <IWorkItemRepository>();
ReleaseTag @base = lstStartRelease.SelectedItem as ReleaseTag;
ReleaseTag head = lstEndRelease.SelectedItem as ReleaseTag;
IList <WorkItem> workItems = await workItemRepository.GetReleaseWorkItemsInRangeAsync(@base, head);
DisplayWorkItems(workItems);
}
public StateMachineProvider(
IWorkItemRepository repository,
IWorkItemBuilder workItemBuilder,
IWorkflowPathNavigator workflowPathNavigator,
IDataStore dataStore)
{
_repository = repository;
_workItemBuilder = workItemBuilder;
_workflowPathNavigator = workflowPathNavigator;
_dataStore = dataStore;
}
public WorkItemController(ILogger <ScheduleController> logger, IWorkItemService workItemService, IPatrolRepository patrolRepository, ISystemClock clock,
IPatrolService patrolService, IUserRepository userRepository, IWorkItemRepository workItemRepository)
{
_logger = logger;
_patrolRepository = patrolRepository;
_clock = clock;
_patrolService = patrolService;
_userRepository = userRepository;
_workItemService = workItemService;
_workItemRepository = workItemRepository;
}
public ActivityRunner(IWorkflowPathNavigator workflowPathNavigator, IDataStore dataStore,
IWorkItemRepository repository)
{
if (workflowPathNavigator == null) throw new ArgumentNullException("workflowPathNavigator");
if (dataStore == null) throw new ArgumentNullException("dataStore");
if (repository == null) throw new ArgumentNullException("repository");
_workflowPathNavigator = workflowPathNavigator;
_dataStore = dataStore;
_repository = repository;
}
private async Task LoadReleasesAsync()
{
IWorkItemRepository workItemRepository = _provider.GetRequiredService <IWorkItemRepository>();
_releaseTags = await workItemRepository.GetReleaseTagsAsync();
lstStartRelease.DataSource = null;
lstStartRelease.DisplayMember = "Name";
lstStartRelease.DataSource = _releaseTags.OrderByDescending(r => r.Release).ToList();
lstStartRelease.SelectedIndex = -1;
}
public WorkItemService(ILogger <WorkItemService> logger, IPatrolRepository patrolRepository,
IGroupRepository groupRepository, IShiftRepository shiftRepository, ISystemClock clock, IEmailService emailService,
IUserRepository userRepository, IWorkItemRepository workItemRepository, IMapper mapper)
{
_logger = logger;
_patrolRepository = patrolRepository;
_groupRepository = groupRepository;
_shiftRepository = shiftRepository;
_clock = clock;
_emailService = emailService;
_userRepository = userRepository;
_workItemRepository = workItemRepository;
_mapper = mapper;
}
public ForkStateMachine(IWorkItemRepository repository, IWorkItemBuilder workItemBuilder,
IWorkflowPathNavigator workflowPathNavigator,
IDataStore dataStore)
{
if (repository == null) throw new ArgumentNullException("repository");
if (workflowPathNavigator == null) throw new ArgumentNullException("workflowPathNavigator");
if (workItemBuilder == null) throw new ArgumentNullException("workItemBuilder");
if (dataStore == null) throw new ArgumentNullException("dataStore");
_repository = repository;
_workflowPathNavigator = workflowPathNavigator;
_workItemBuilder = workItemBuilder;
_dataStore = dataStore;
}
public WorkItemService(IWorkItemRepository repository, IENodebRepository eNodebRepository,
IBtsRepository btsRepository, ITownRepository townRepository, IAlarmWorkItemRepository alarmWorkItemRepository,
ICheckingProjectRepository checkingProjectRepository, ICheckingBasicRepository checkingBasicRepository,
ICheckingDetailsRepository checkingDetailsRepository, ISpecialAlarmWorkItemRepository specialWorkItemRepository,
ICheckingProjectProvinceRepository checkingProjectPovinceRepository)
{
_repository = repository;
_eNodebRepository = eNodebRepository;
_btsRepository = btsRepository;
_townRepository = townRepository;
_alarmWorkItemRepository = alarmWorkItemRepository;
_checkingProjectRepository = checkingProjectRepository;
_checkingBasicRepository = checkingBasicRepository;
_checkingDetailsRepository = checkingDetailsRepository;
_specialWorkItemRepository = specialWorkItemRepository;
_checkingProjectProvinceRepository = checkingProjectPovinceRepository;
}
public void ShouldReturnTwoItems_WhenGetItems_IsAskedForTwoItems()
{
IWorkItemRepository repository = MockRepository.GenerateStub <IWorkItemRepository>();
List <WorkItem> actual = new List <WorkItem> {
new WorkItem("", "", DateTime.Now),
new WorkItem("", "", DateTime.Now),
new WorkItem("", "", DateTime.Now),
};
repository.Stub(r => r.Entities).Return(actual.AsQueryable());
WorkItemServiceImpl service = new WorkItemServiceImpl(repository);
int limit = 2;
IEnumerable <WorkItem> expected = service.GetItems(limit);
Assert.AreEqual(expected.Count(), limit);
}
public ScriptEngine GetEngine(IWorkItemRepository workItemStore)
{
Func <IWorkItemRepository, ScriptEngine> builder = (store) =>
{
var newEngine = ScriptEngine.MakeEngine(this.Settings.ScriptLanguage, workItemStore, this.Logger, this.Settings.Debug);
foreach (var rule in this.Settings.Rules)
{
newEngine.Load(rule.Name, rule.Script);
}
newEngine.LoadCompleted();
return(newEngine);
};
ScriptEngine engine = this.scriptEngines.GetOrAdd(workItemStore, builder);
return(engine);
}
public UnitOfWork(
IAchievementRepository achievement,
ICommentRepository comment,
INotificationRepository notification,
IProjectRepository project,
ISprintRepository sprint,
IUserRepository user,
IWorkItemRepository workItem,
FantasyScrumBoardDbContext dbContext)
{
Achievement = achievement;
Comment = comment;
Notification = notification;
Project = project;
Sprint = sprint;
User = user;
WorkItem = workItem;
_dbContext = dbContext;
}
private void RunScript(Assembly assembly, string scriptName, IWorkItem self, IWorkItemRepository store)
{
var classForScript = assembly.GetType(this.Namespace + "." + this.ClassPrefix + scriptName);
if (classForScript == null)
{
this.Logger.FailureLoadingScript(scriptName);
return;
}
var interfaceForScript = classForScript.GetInterface(typeof(IDotNetScript).Name);
if (interfaceForScript == null)
{
this.Logger.FailureLoadingScript(scriptName);
return;
}
ConstructorInfo constructor = classForScript.GetConstructor(Type.EmptyTypes);
if (constructor == null || !constructor.IsPublic)
{
this.Logger.FailureLoadingScript(scriptName);
return;
}
// we specified that we wanted a constructor that doesn't take parameters, so don't pass parameters
IDotNetScript scriptObject = constructor.Invoke(null) as IDotNetScript;
if (scriptObject == null)
{
this.Logger.FailureLoadingScript(scriptName);
return;
}
System.Diagnostics.Debug.WriteLine("*** about to execute {0}", scriptName, null);
this.Logger.ScriptLogger.RuleName = scriptName;
// Lets run our script and display its results
object result = scriptObject.RunScript(self, store, this.Logger.ScriptLogger);
this.Logger.ResultsFromScriptRun(scriptName, result);
}
private IWorkItemRepository SetupFakeRepository_Short()
{
this.repository = Substitute.For<IWorkItemRepository>();
this.workItem = Substitute.For<IWorkItem>();
this.workItem.Id.Returns(1);
this.workItem.TypeName.Returns("Task");
this.workItem["Estimated Dev Work"].Returns(1.0D);
this.workItem["Estimated Test Work"].Returns(2.0D);
this.workItem["Finish Date"].Returns(new DateTime(2010, 1, 1));
this.workItem.IsValid().Returns(true);
// triggers save
this.workItem.IsDirty.Returns(true);
this.repository.GetWorkItem(1).Returns(this.workItem);
this.repository.LoadedWorkItems.Returns(new ReadOnlyCollection<IWorkItem>(new List<IWorkItem>() { this.workItem }));
this.repository.CreatedWorkItems.Returns(new ReadOnlyCollection<IWorkItem>(new List<IWorkItem>()));
return this.repository;
}
public async Task <IWorkList> CreateWorkListAsync([NotNull] IWorkListContext context)
{
Assert.ArgumentNotNull(context, nameof(context));
Map map = MapView.Active.Map;
if (!await TryPrepareSchemaCoreAsync())
{
return(await Task.FromResult(default(IWorkList)));
}
BasicFeatureLayer[] featureLayers = await Task.WhenAll(GetLayers(map).Select(EnsureStatusFieldCoreAsync));
// create new name if worklist do not have one (stored in XML)
UniqueName = GetWorklistId() ?? GetWorkListName(context);
IRepository stateRepository = CreateStateRepositoryCore(context.GetPath(UniqueName), UniqueName);
IWorkItemRepository repository = CreateItemRepositoryCore(featureLayers, stateRepository);
return(CreateWorkListCore(repository, UniqueName));
}
public override void Run(string scriptName, IWorkItem workItem, IWorkItemRepository store)
{
string script = this.scripts[scriptName];
var config = RunspaceConfiguration.Create();
using (var runspace = RunspaceFactory.CreateRunspace(config))
{
runspace.Open();
runspace.SessionStateProxy.SetVariable("self", workItem);
runspace.SessionStateProxy.SetVariable("store", store);
runspace.SessionStateProxy.SetVariable("logger", this.Logger.ScriptLogger);
Pipeline pipeline = runspace.CreatePipeline();
pipeline.Commands.AddScript(script);
// execute
var results = pipeline.Invoke();
this.Logger.ResultsFromScriptRun(scriptName, results);
}
}
public WorkItemWrapper(WorkItem workItem, IWorkItemRepository store, ILogEvents logger)
: base(store, logger)
{
this.workItem = workItem;
}
public ActivityStateMachine(IWorkItemRepository repository)
{
_repository = repository;
}
public ScriptEngine(IWorkItemRepository store, ILogEvents logger, bool debug)
{
this.Logger = logger;
this.Store = store;
this.Debug = debug;
}
public void Init()
{
_workStepRepository = new MemoryWorkStepRepository();
_workItemRepository = new MemoryWorkItemRepository();
_wipLimit = new WipLimitChecker(_workStepRepository,_workItemRepository);
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkItemImplementationBase"/> class.
/// </summary>
public WorkItemImplementationBase(IWorkItemRepository store, ILogEvents logger)
{
this.Store = store;
this.Logger = logger;
}
public WorkflowRepository(IWorkItemRepository workItemRepsitory, IWorkStepRepository workStepRepository)
{
_workItemRepsitory = workItemRepsitory;
_workStepRepository = workStepRepository;
}
public WorkItemLinkMock(string relationship, int id, IWorkItemRepository store)
{
this.relationship = relationship;
this.id = id;
this.store = store;
}
static ProcessService()
{
_repository = RepositoryFactory.GetRepository<IProcessRepository, Guid, Process>();
_workItemRepository = RepositoryFactory.GetRepository<IWorkItemRepository, long, WorkItem>();
}
public JobUnitOfWork(IWorkItemRepository repository, long workItemId)
{
_workItemId = workItemId;
_repository = repository;
}
/// <summary> /// Runs the script specified by <paramref name="scriptName" />. /// </summary> /// <param name="scriptName">Name of the script.</param> /// <param name="workItem">The work item that must be processed by the script.</param> public abstract void Run(string scriptName, IWorkItem workItem, IWorkItemRepository store);
public static void LoadAndRun(this ScriptEngine engine, string scriptName, string script, IWorkItem workItem, IWorkItemRepository store)
{
engine.Load(scriptName, script);
engine.LoadCompleted();
engine.Run(scriptName, workItem, store);
}
public Historian(IWorkItemRepository repository)
{
this.repository = repository;
}
