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; }