public NotificationMappingController(IWorkflowService workflowService, IStatusService statusService, INotificationMappingService notificationMappingService) { this.workflowService = workflowService; this.statusService = statusService; this.notificationMappingService = notificationMappingService; this.service = new Service(this.statusService, this.workflowService); }
public DocumentMappingController(IWorkflowService workflowService, IDocumentService documentService, IDocumentMappingService documentMappingService) { this.workflowService = workflowService; this.documentService = documentService; this.documentMappingService = documentMappingService; this.service = new Service(this.documentService, this.workflowService); }
public UserController( IOrchardServices services, IBlockModelService blockModelService, IAssayService assayService, IGeophysicsService geophysicsService, IProjectsService projectService, IParametersService parameterService, IUsersService userService, IPrivateDataService privateService, IWorkflowService workflowService ) { Services = services; UserService = userService; BlockModelService = blockModelService; AssayService = assayService; GeophysicsService = geophysicsService; ParameterService = parameterService; ProjectService = projectService; PrivateService = privateService; WorkflowService = workflowService; T = NullLocalizer.Instance; Logger = NullLogger.Instance; }
/// <summary> /// Initializes a new instance of the <see cref="SystemWorkflowManager" /> class. /// </summary> /// <param name="workflowService">Gateway into the workflow subsystem.</param> /// <param name="formServiceGateway">Gateway into the forms subsystem.</param> /// <param name="dataAccess">The data access.</param> public SystemWorkflowManager(IWorkflowService workflowService, IFormServiceGateway formServiceGateway, IDataAccess dataAccess) { this.workflowService = workflowService; this.formServiceGateway = formServiceGateway; this.dataAccess = dataAccess; this.productCache = new Dictionary<string, ProductVersionList>(); }
public WorkflowServiceDemo(String defaultRepository, String secondaryRepository, String userName, String password) : base(defaultRepository, secondaryRepository, userName, password) { ServiceFactory serviceFactory = ServiceFactory.Instance; workflowService = serviceFactory.GetRemoteService<IWorkflowService>(DemoServiceContext, "bpm"); }
public WorkflowMappingController(IWorkflowService workflowService, IRoleService roleService, IWorkflowMappingService workflowMappingService, IProcessService processService) { this.workflowService = workflowService; this.roleService = roleService; this.workflowMappingService = workflowMappingService; this.processService = processService; this.service = new Service(this.workflowService, roleService); }
public WorkFlowLevelController(IWorkFlowSetupService workFlowSetupService, IUserProfileService userProfileService, IUtilityService utilityService, IWorkflowService workFlowService) : base(userProfileService,utilityService) { _workFlowSetupService = workFlowSetupService; _workFlowService = workFlowService; }
public WorkflowController(IWorkflowService workflowService, IProcessService processService, ISubProcessService subProcessService, IClassificationService classificationService, IRoleService roleService) { this.workflowService = workflowService; this.processService = processService; this.subProcessService= subProcessService;; this.classificationService= classificationService; this.roleService = roleService; this.service = new Service(this.processService, this.subProcessService, this.classificationService, this.roleService); }
/// <summary> /// Initializes a new instance of the <see cref="OrderService"/> class. /// </summary> /// <param name="orderRepository">The order repository.</param> /// <param name="searchService">The search service.</param> /// <param name="workflowService">The workflow service.</param> /// <param name="paymentMethodRepository">The payment method repository.</param> /// <param name="storeRepository">The store repository.</param> public OrderService(IOrderRepository orderRepository, ISearchService searchService, IWorkflowService workflowService, IPaymentMethodRepository paymentMethodRepository, IStoreRepository storeRepository) : this() { _orderRepository = orderRepository; _searchService = searchService; _workflowService = workflowService; _paymentMethodRepository = paymentMethodRepository; _storeRepository = storeRepository; }
public WorkflowController(IWorkflowService workflowService, IDocumentMappingService documentMappingService, INotificationMappingService notificationMappingService, IWorkflowMappingService workflowMappingService, IStatusService statusService) { this.workflowService = workflowService; this.documentMappingService = documentMappingService; this.notificationMappingService = notificationMappingService; this.workflowMappingService = workflowMappingService; }
public OrganizationController(IOrganizationService organizationService, IWebSecurityService securityService, IEmailHelper emailHelper, IRegistrationService registrationService, IWorkflowInstanceService workflowInstanceService, IWorkflowService workflowService) { this.organizationService = organizationService; this.webSecurityService = securityService; this.emailHelper = emailHelper; this.registrationService = registrationService; this.workflowInstanceService = workflowInstanceService; this.workflowService = workflowService; }
/// <summary> /// Initializes a new instance of the <see cref="ApplicationManager"/> class. /// </summary> /// <param name="dataAccess">Provides access to the data layer.</param> /// <param name="workflowGateway">The gateway into the workflow subsystem.</param> /// <param name="entitlementProvider">The entitlement provider.</param> /// <param name="endpointCommunicator">A service endpoint communicator.</param> /// <param name="userManager">Retrieves user data.</param> /// <param name="organisationManager">Retrieves organization specific data.</param> /// <param name="securityService">Retrieves form security configurations.</param> public ApplicationManager(IDataAccess dataAccess, IWorkflowService workflowGateway, IApplicationEntitlementProvider entitlementProvider, IServiceEndpointCommunicator endpointCommunicator, UserManager userManager, OrganisationManager organisationManager, ISecurityService securityService) : base(dataAccess) { this.workflowService = workflowGateway; this.entitlementProvider = entitlementProvider; this.endpointCommunicator = endpointCommunicator; this.userManager = userManager; this.organisationManager = organisationManager; this.securityService = securityService; }
public WorkflowMappingController(IProcessService processService, ISubProcessService subProcessService, IClassificationService classificationService, IWorkflowService workflowService, IDocumentMappingService documentMappingService, IDocumentService documentService, INodeService nodeService) { this.processService = processService; this.subProcessService = subProcessService; this.classificationService = classificationService; this.workflowService = workflowService; this.documentMappingService = documentMappingService; this.documentService = documentService; this.nodeService = nodeService; this.service = new Service(documentService, processService, subProcessService, classificationService); }
public AccountController(IWebSecurityService webSecurityService, IPersonService personService, IAccountService accountService, IEmailHelper emailHelper, IWorkflowInstanceService workflowInstanceService, IWorkflowService workflowService) { this.webSecurityService = webSecurityService; this.personService = personService; this.accountService = accountService; this.emailHelper = emailHelper; this.workflowInstanceService = workflowInstanceService; this.workflowService = workflowService; Boolean.TryParse(ConfigurationManager.AppSettings["RequireSignUpVerification"], out requireVerification); }
public WorkFlowSetupService(IRepositoryAsync<WorkflowApplication> application, IRepositoryAsync<WorkflowLevel> level, IRepositoryAsync<WorkflowLevelExpression> levelParameters, IRepositoryAsync<Workflow> workflows, IRepositoryAsync<WorkflowActor> actors, IRepositoryAsync<WorkflowHistory> histories, IRepositoryAsync<WorkflowActorInLevel> actorsInLevels, IRepositoryAsync<WorkflowProcess> processes, IWorkflowService workFlowService, IUserProfileRepository userProfileRepository) : base(application, level, levelParameters, workflows, actors, histories, actorsInLevels, processes) { _workFlowService = workFlowService; _userProfileRepository = userProfileRepository; }
public TicketController( TicketDataContext context, IWorkflowService workflowService, IAuthService authService, IAccountManagerService accountManagerService ) { this.Context = context; this.WorkflowService = workflowService; this.AuthService = authService; this.AccountManagerService = accountManagerService; }
private void Construct(IAciEventManager eventManager, IBotMessenger botMessenger, ILocalizationManager localizationManager, IWorkflowService workflowService, IChatWindowFacade chatWindowFacade) { m_EventManager = eventManager; m_BotMessenger = botMessenger; m_LocalizationManager = localizationManager; m_WorkflowService = workflowService; m_ChatWindowFacade = chatWindowFacade; }
public static WorkflowActionEntity FetchWorkflowActionByUuid( IWorkflowService workflowService, Guid uuid) { return(workflowService .DbConnection .Query <WorkflowActionEntity>(QueryBuilder.FetchWorkflowActionByUuid(), new { Uuid = uuid }) .FirstOrDefault()); }
public NotifyUserState(IEnumerable <int> userIds, IEnumerable <int> NotificationFieldIds, int workflowId, string workflowName, int createdBy, int stateId, string message, byte notifyType, IWorkflowService workflowService) : base(stateId) { this.EntityIds = userIds; this.NotificationFieldIds = NotificationFieldIds; this.WorkflowId = workflowId; this.WorkflowName = workflowName; this.CreatedBy = createdBy; this.messageBody = message; this.notifyType = notifyType; this.workflowService = workflowService; }
public ActionProcessor(CronJobDb cronJob, JobService jobService, string cacheName) : base(cronJob, jobService, cacheName) { this.workflowService = IoC.Container.GetInstance <IWorkflowService>(); this.campaignService = IoC.Container.GetInstance <ICampaignService>(); this.tagService = IoC.Container.GetInstance <ITagService>(); this.leadScoreService = IoC.Container.GetInstance <ILeadScoreService>(); this.contactService = IoC.Container.GetInstance <IContactService>(); this.messageService = IoC.Container.GetInstance <IMessageService>(); this.communicationService = IoC.Container.GetInstance <ICommunicationService>(); this.accountService = IoC.Container.GetInstance <IAccountService>(); }
public static WorkflowActionEntity[] FetchActiveActionsByWorkflowGuid( IWorkflowService workflowService, Guid workflowUuid) { return(workflowService .DbConnection .Query <WorkflowActionEntity>(QueryBuilder.FetchActiveActionsByWorkflowUuid(), new { WorkflowUuid = workflowUuid }) .ToArray()); }
public NewController( IBaseControllerServiceFacade baseServiceFacade, IWorkflowService workflowService, ISecurityService securityService, IStageUserService stageUserService, IBPTaskService taskService): base(baseServiceFacade) { _workflowService = workflowService; _securityService = securityService; _stageUserService = stageUserService; _taskService = taskService; }
private void Construct(IAciEventManager eventBroker , IWorkflowService workflowService , ISceneItemRegistry registry , IAdaptivityService adaptivityService) { m_EventBroker = eventBroker; m_ItemRegistry = registry; m_WorkflowService = workflowService; m_AdaptivityService = adaptivityService; RegisterForEvents(); }
public BadgeService(IAciEventManager eventManager , IUserManager userManager , IWorkflowService workflowService , ITimeProvider timeProvider , ITimeTrackingRepository timeRepo) { m_EventManager = eventManager; m_UserManager = userManager; m_WorkflowService = workflowService; m_TimeProvider = timeProvider; m_TimeRepo = timeRepo; }
public async Task <IActionResult> Delete(string id, [FromServices] IWorkflowService _service) { try { await _service.Delete(id); return(NoContent()); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <IActionResult> Put([FromBody] Workflow value, [FromServices] IWorkflowService _service) { try { await _service.Update(value); return(NoContent()); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
void LoadLeaveData() { IWorkflowService service = ServiceContainer.GetService <IWorkflowService>(); WorkflowResult result = service.GetWorkflowDataEntity(this.m_InstanceId); this.OnWorkflowResultChaned(result); this.m_Leave = result.DataEntity as Leave; this.tbGuid.Text = this.m_Leave.ID; this.tbName.Text = this.m_Leave.Name; this.nudDays.Value = this.m_Leave.Days; this.tbCause.Text = this.m_Leave.Cause; }
private void Construct(IAciEventManager eventManager , IWorkflowService workflowService , IAdaptivityService adaptivityService , ITimeProvider timeProvider , Factory timelineFactory) { m_EventManager = eventManager; m_WorkflowService = workflowService; m_AdaptivityService = adaptivityService; m_TimeProvider = timeProvider; m_TimelineItemFactory = timelineFactory; RegisterForEvents(); }
public TicketVariableIncomeController( TicketDataContext context, IWorkflowService workflowService, IAccountManagerService accountManagerService, IMapper mapper, TicketListQueryService <TicketVariableIncome, TicketVariableIncomeModel> ticketQueryPaginatedService ) { this.context = context; this.workflowService = workflowService; this.accountManagerService = accountManagerService; this.mapper = mapper; this.ticketQueryPaginatedService = ticketQueryPaginatedService; }
public LgaService(IUnitOfWorkAsync unitOfWork, ILgaRepository repository, IUserProfileService userProfileService, IUserProfileRepository userProfileRepository, IUtilityService utilityService, IApprovalService approvalService, IWorkflowService workflowService, IWorkFlowSetupService workFlowSetupService) { _unitOfWork = unitOfWork; _repository = repository; _userProfileService = userProfileService; _userProfileRepository = userProfileRepository; _utilityService = utilityService; _approvalService = approvalService; _workflowService = workflowService; _workFlowSetupService = workFlowSetupService; Mapper.CreateMap<UserProfile, UserProfileItem>(); }
public void FindWorkflowById_Service_Success() { // Arrange workflowService = new WorkflowService(mockRepository.Object, mockLogger.Object, mockCache.Object, mockTelemetry.Object); mockRepository.Setup(x => x.FindById <Workflow>(It.IsAny <int>())).Returns(new Workflow()).Verifiable(); // Act var response = workflowService.FindWorkflowById(It.IsAny <int>()); // Assert Assert.IsNotNull(response); Assert.IsNotNull(response.Result); Assert.IsInstanceOfType(response, typeof(GenericServiceResponse <WorkflowDto>)); mockRepository.Verify(x => x.FindById <Workflow>(It.IsAny <int>()), Times.Once); }
public UpdateTicketService( IContextRepository <ITicketContext> repository, IMapper mapper, INotificationService notificationService, IWorkflowService workflowService, IUpdateTicketResultFactory factory, IValidator <UpdateTicketDto> validator) { _repository = repository; _mapper = mapper; _notificationService = notificationService; _workflowService = workflowService; _factory = factory; _validator = validator; }
public WorkflowsController(ICircleCIConfigurationService circleCIConfiguration, IProjectRepositoryService projectRepository, IBranchService branch, IAccountService account, ITokenService token, ICircleCIProjectService circleCIProject, IGHContentService gHContent, ISprintService sprint, IPermissionService permission, IWorkflowService workflow, IRepositoryService repository, IGHBranchService gHBranch, IErrorHandlerService errorHandler, IJwtAuthService jwtAuth) : base(errorHandler, jwtAuth) { _circleCIConfiguration = circleCIConfiguration; _projectRepository = projectRepository; _branch = branch; _account = account; _token = token; _circleCIProject = circleCIProject; _gHContent = gHContent; _sprint = sprint; _permission = permission; _workflow = workflow; _repository = repository; _gHBranch = gHBranch; }
public void GetAllWorkflows_Service_Fail() { // Arrange workflowService = new WorkflowService(mockRepository.Object, mockLogger.Object, mockCache.Object, mockTelemetry.Object); mockRepository.Setup(x => x.All <Workflow>()).Throws(new Exception()).Verifiable(); // Act var response = workflowService.GetAllWorkflows(); // Assert Assert.IsNotNull(response); Assert.IsNull(response.Result); Assert.IsTrue(response.Notifications.HasErrors()); Assert.IsInstanceOfType(response, typeof(GenericServiceResponse <IEnumerable <WorkflowDto> >)); mockRepository.Verify(x => x.All <Workflow>(), Times.Once); }
public void DeleteWorkflowById_Service_Fail() { // Arrange workflowService = new WorkflowService(mockRepository.Object, mockLogger.Object, mockCache.Object, mockTelemetry.Object); mockRepository.Setup(x => x.Delete <Workflow>(It.IsAny <int>())).Returns(false).Verifiable(); // Act var response = workflowService.DeleteWorkflow(It.IsAny <int>()); // Assert Assert.IsNotNull(response); Assert.IsFalse(response.Result); Assert.IsTrue(response.Notifications.HasErrors()); Assert.IsInstanceOfType(response, typeof(GenericServiceResponse <bool>)); mockRepository.Verify(x => x.Delete <Workflow>(It.IsAny <int>()), Times.Once); }
public CliService( IWorkflowService workflowService, IGitHubService gitHubService, IActionPrinter printer, Func <int, IProgressBar> progressBarFactory, IStreamer streamer) { _workflowService = workflowService; _gitHubService = gitHubService; _printer = printer; _progressBarFactory = progressBarFactory ?? (_ => null); _streamer = streamer; _gitHubService.RepositoryChecked += ProgressBarProcessed; _gitHubService.RepositoryCheckedStarted += ProgressBarPrepare; _gitHubService.RepositoryCheckedFinished += ProgressBarDispose; }
public AutomationWorkflow(Workflow workflow, IWorkflowService workflowService, ITagService tagService, ICampaignService campaignService, IContactService contactService, ILeadScoreService leadScoreService, IPublishSubscribeService pubSubService, ICommunicationService communicationService) { this.workflow = workflow; this.AccountId = workflow.AccountID; this.WorkflowId = workflow.WorkflowID; this.workflowService = workflowService; this.tagService = tagService; this.campaignService = campaignService; this.contactService = contactService; this.leadScoreService = leadScoreService; this.pubSubService = pubSubService; this.communicationService = communicationService; this.configure(); }
public ErrorRecordsController( IEntityMapper mapper, IRepository <ErrorRecord> errorRecordRepo, IErrorRecordDataService errorDataService, IRepository <ErrorChangeRecord> changeRepo, IErrorHistoryDataService errorChangeDataService, IWorkflowService workflowService, IUserDataService userDataService) { _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper)); _errorRecordRepo = errorRecordRepo ?? throw new ArgumentNullException(nameof(errorRecordRepo)); _errorDataService = errorDataService ?? throw new ArgumentNullException(nameof(errorDataService)); _errorChangeRepo = changeRepo ?? throw new ArgumentNullException(nameof(changeRepo)); _errorChangeDataService = errorChangeDataService ?? throw new ArgumentNullException(nameof(errorChangeDataService)); _workflowService = workflowService ?? throw new ArgumentNullException(nameof(workflowService)); _userDataService = userDataService; }
public BusinessProcessController( IBaseControllerServiceFacade baseServiceFacade, IWorkflowService workflowService, ITaskService taskService, IWorkflowServiceResolver serviceProvider, IWorkflowCacheService cashService, IValidationService validationService, IWorkflowContextService contextService) : base(baseServiceFacade) { _workflowService = workflowService; _taskService = taskService; _serviceProvider = serviceProvider; _cashService = cashService; _validationService = validationService; _contextService = contextService; }
private void Construct(IConfigProvider configProvider, INetworkPublisher publisher, IWorkflowService workflowService, SceneItem.Factory sceneItemFactory, ISceneItemRegistry itemRegistry) { m_ConfigProvider = configProvider; m_INetworkPublisher = publisher; m_WorkflowService = workflowService; m_SceneItemFactory = sceneItemFactory; m_ItemRegistry = itemRegistry; m_ConfigProvider?.RegisterClient(this); //write default values to config if no config values were loaded if (workflowDirectory.IsNullOrEmpty()) { m_ConfigProvider?.ClientDirty(this); } }
public FuncTask <WorkflowResult> CreateWorkflow(object wfAddIn, IWorkflowDataEntity wfData) { FuncTask <WorkflowResult> task = new FuncTask <WorkflowResult>(); WorkflowResult wfResult = this.GetFlowID(wfAddIn); if (wfResult.FlowID == Guid.Empty) { task.Complete(wfResult); } else { IWorkflowService service = ServiceContainer.GetService <IWorkflowService>(task); service.CreateWorkflow(wfResult.FlowID, wfData, ContextHelper.Account.LoginID); } return(task); }
public void UpdateWorkflow_Service_Success() { // Arrange workflowService = new WorkflowService(mockRepository.Object, mockLogger.Object, mockCache.Object, mockTelemetry.Object); mockRepository.Setup(x => x.Update(It.IsAny <Workflow>())).Returns(true).Verifiable(); // Act var workflow = new WorkflowDto(); var response = workflowService.UpdateWorkflow(workflow); // Assert Assert.IsNotNull(response); Assert.IsTrue(response.Result); Assert.IsFalse(response.Notifications.HasErrors()); Assert.IsInstanceOfType(response, typeof(GenericServiceResponse <bool>)); mockRepository.Verify(x => x.Update(It.IsAny <Workflow>()), Times.Once); }
public TransactionController(IWorkflowService workflowService, IProcessService processService, ISubProcessService subProcessService, IClassificationService classificationService, INodeService nodeService, IDocumentMappingService documentMappingService, IWorkflowMappingService workflowMappingService, INotificationMappingService notificationMappingService ) { this.workflowService = workflowService; this.processService = processService; this.subProcessService= subProcessService;; this.classificationService= classificationService; this.documentMappingService = documentMappingService; this.notificationMappingService = notificationMappingService; this.workflowMappingService = workflowMappingService; this.nodeService = nodeService; this.service = new Service(this.processService, this.subProcessService, this.classificationService); }
public AutomationEngine(ICachingService cachingService, IIndexingService indexingService, IAdvancedSearchService advancedSearchService, IContactService contactService, IWorkflowService workflowService, IAccountService accountService, ITagService tagService, ICampaignService campaignService, ILeadScoreService leadScoreService, IPublishSubscribeService pubSubService, IOpportunitiesService opportunityService, ICommunicationService communicationService) { this.cachingService = cachingService; this.indexingService = indexingService; this.advancedSearchService = advancedSearchService; this.contactService = contactService; this.workflowService = workflowService; this.accountService = accountService; this.tagService = tagService; this.campaignService = campaignService; this.leadScoreService = leadScoreService; this.pubSubService = pubSubService; this.communicationService = communicationService; this.opportunityService = opportunityService; }
private void Construct(IBadgeService badgeService, IAciEventManager eventManager, IBot bot, IWorkflowService workflowService, ITimeTrackingRepository timeTracker, IAdaptivityService adaptivityService, FeedbackActivityFactory activityFactory, IConfigProvider configProvider) { m_BadgeService = badgeService; m_EventManager = eventManager; m_Factory = activityFactory; m_Bot = bot; m_TimeTracker = timeTracker; m_WorkflowService = workflowService; m_AdaptivityService = adaptivityService; m_ConfigProvider = configProvider; }
public WaitingPeriodState(int stateId, TimerType timerType, int?delayPeriod, DateInterval?dateInterval, RunOn?runOn, TimeSpan?runAt, RunType?runType, DateTime?runOnDate, DateTime?startDate, DateTime?endDate, IEnumerable <DayOfWeek> runOnDays, int workflowId, IWorkflowService workflowService, IPublishSubscribeService pubSubService) : base(stateId) { this.timerType = timerType; this.delayPeriod = delayPeriod; this.dateInterval = dateInterval; this.runOn = runOn; this.runAt = runAt; this.runType = runType; this.runOnDate = runOnDate; this.startDate = startDate; this.endDate = endDate; this.runOnDays = runOnDays; this.workflowId = workflowId; this.pubSubService = pubSubService; this.workflowService = workflowService; }
public DocumentController(IDocumentService documentService, IProcessService processService, IWorkflowService workflowService, IEmplService emplService, IAccountService accountService, ISystemService systemService, IWorkflowTrackerService workflowTrackerService, IReviewDocLogService reviewDocLogService, IDocumentReaderService documentReaderService, ICommentService commentService, IEmailService emailService, IHistoryUserService historyUserService, ISearchService searchService) { _DocumentService = documentService; _ProcessService = processService; _WorkflowService = workflowService; _EmplService = emplService; _AccountService = accountService; _SystemService = systemService; _WorkflowTrackerService = workflowTrackerService; _ReviewDocLogService = reviewDocLogService; _DocumentReaderService = documentReaderService; _CommentService = commentService; _EmailService = emailService; _HistoryUserService = historyUserService; _SearchService = searchService; }
void LoadFlowList() { this.btnStart.IsEnabled = false; FuncTask <IList <WFDefine> > task = new FuncTask <IList <WFDefine> >(); IWorkflowService wfService = ServiceContainer.GetService <IWorkflowService>(task); wfService.GetWFDefineList(SLContext.Account.LoginID, this.tbKey.Text.Trim()); task.Completed += (s, e) => { if (task.Error != null) { MessageBox.Show("请求数据时发生错误:" + task.Error.Message, "错误", MessageBoxButton.OK); } else { this.vList = task.TResult; this.dataPager.RecordCount = this.vList.Count; } }; }
public WorkflowActionJob( IWorkflowService workflowService, ICampaignService campaignService, ITagService tagService, ILeadScoreService leadScoreService, IContactService contactService, IMessageService messageService, ICommunicationService communicationService, IAccountService accountService, JobServiceConfiguration jobConfig) { _workflowService = workflowService; _campaignService = campaignService; _tagService = tagService; _leadScoreService = leadScoreService; _contactService = contactService; _messageService = messageService; _communicationService = communicationService; _accountService = accountService; _jobConfig = jobConfig; }
protected void Page_Load(object sender, EventArgs e) { i18n = new i18nHelper(); this.Title = i18n.GetMessage("m261") + " @ " + i18n.GetMessage("m9"); this.forwardSend.Text = i18n.GetMessage("m78"); currentUser = WebUtility.GetCurrentKBUser(); subjectid = currentUser.SubjectId; documentService = factory.GetDocumentService(); categoryService = factory.GetCategoryService(); ratingService = factory.GetRatingService(); auditTrailService = factory.GetAuditTrailService(); wfService = factory.GetWorkflowService(); hitService = factory.GetHitService(); documentClassService = factory.GetDocumentClassService(); subscribeService = WebUtility.Repository.GetSubscribeService(); docId = WebUtility.GetIntegerParameter("documentId"); folderId = WebUtility.GetIntegerParameter("folderId", -1); ver = WebUtility.GetIntegerParameter("ver", 0); latestVersionNumber = buildVersionInfo(); currentUserOutputConfig = WebUtility.GetUserOutputConfig(currentUser.SubjectId); attachMode = currentUserOutputConfig.AttachMode; showUsedTags = ConfigurationManager.AppSettings["ShowUsedTags"] != null ? ConfigurationManager.AppSettings["ShowUsedTags"] : "false"; tagsAutoComplete = ConfigurationManager.AppSettings["TagsAutoComplete"] != null ? ConfigurationManager.AppSettings["TagsAutoComplete"] : "false"; tagsSuggestListLen = ConfigurationManager.AppSettings["TagsSuggestListLen"] != null ? ConfigurationManager.AppSettings["TagsSuggestListLen"] : "10"; subscriptionConfirm = Convert.ToBoolean(ConfigurationManager.AppSettings["SubscriptionConfirm"] != null ? ConfigurationManager.AppSettings["SubscriptionConfirm"].ToString() : "true"); autoSubscription = Convert.ToBoolean(ConfigurationManager.AppSettings["AutoSubscription"] != null ? ConfigurationManager.AppSettings["AutoSubscription"].ToString() : "true"); allowSendToNoPrivilegeUser = Convert.ToBoolean(ConfigurationManager.AppSettings["AllowSendToNoPrivilegeUser"] != null ? ConfigurationManager.AppSettings["AllowSendToNoPrivilegeUser"].ToString() : "true"); TagMaxLength = ConfigurationManager.AppSettings["TagMaxLength"] != null ? ConfigurationManager.AppSettings["TagMaxLength"] : "30"; IsSafari = (Request.Browser.Browser.ToLower().Equals("applemac-safari") && !Request.UserAgent.ToLower().Contains("chrome")); userHadSubscribeResource = subscribeService.UserHadSubscribedResource(currentUser.SubjectId, (int)currentUser.SubjectType, docId, (int)SubscribeRecord.ResourceType.Document); mailService = WebUtility.Repository.GetMailService(); kbuserService = WebUtility.Repository.GetKBUserService(); folderService = WebUtility.Repository.GetFolderService(); forwardService = WebUtility.Repository.GetForwardService(); if (ver == 0) { doc = documentService.GetDocument(currentUser, docId); ver = latestVersionNumber; } else { doc = documentService.GetDocument(currentUser, docId, ver); } readVersion.Text = ver.ToString(); latestVersion.Text = latestVersionNumber.ToString(); if (ver != latestVersionNumber) { Panel1.Visible = false; } if (folderId == -1) { FolderInfo f = documentService.GetParentFolders(currentUser, docId)[0]; folderId = f.FolderId; } buildCategoriesList(); buildDocumentView(); #region For teamKube Xml Render if (IsACLiteSubjectProvider) { renderSpecXml = RenderSpecificXML(currentUser, doc.DocumentId, ver); } #endregion if(!doc.DocumentClass.ClassName.Trim().ToLower().Equals("filesystem")) { buildFileList(); } buildRatingSummary(); buildAuditTrailInfo(); createHitInfo(); buildRelatedTagList(20); buildRelatedDocumentList(); checkWorkflowInvolved(); isDiffDocClass = IsDiffDocumentClass(); strDiffDocClass = String.Format(i18n.GetMessage("m801"), doc.DocumentClass.ClassName, i18n.GetMessage("m802"), i18n.GetMessage("m803")); isBuiltinDocumentClass = (doc.DocumentClass.IsBuiltIn == true) ? "true" : "false"; }
public ApprovalService(IWorkflowService workFlowService, IUserProfileRepository personalInformationRepository) { _workFlowService = workFlowService; _personalInformationRepository = personalInformationRepository; }
public Service(IWorkflowService workflowService, IRoleService roleService) { this.workflowService = workflowService; this.roleService = roleService; }
public Service(IDocumentService documentService, IWorkflowService workflowService) { this.documentService = documentService; this.workflowService = workflowService; }
public WorkflowEngine(IWorkflowService workflowService, IConfiguration configuration) { _workflowService = workflowService; _configuration = configuration; Actions = new List<ClientAction>(); }
public Service(IStatusService statusService, IWorkflowService workflowService) { this.statusService = statusService; this.workflowService = workflowService; }
/// <summary> /// Sets up the dependencies. /// </summary> private static void SetupDependencies() { IConfigurationSource config = ConfigurationSourceFactory.Create(); Logger.SetLogWriter(new LogWriterFactory(config).Create()); ExceptionPolicy.SetExceptionManager(new ExceptionPolicyFactory(config).CreateManager()); JsonConvert.DefaultSettings = () => new JsonSerializerSettings { Formatting = Formatting.None, Converters = new JsonConverter[] { new JsonKnownTypeConverter() } }; try { var container = new UnityContainer().LoadConfiguration(); container.AddNewExtension<SecurityDependencyContainer>(); container.AddNewExtension<WorflowDependencyContainer>(); var configuration = container.Resolve<EventHandlerConfiguration>(); dataAccess = container.Resolve<IDataAccess>(); formServiceGateway = container.Resolve<IFormServiceGateway>(); workbenchServiceGateway = container.Resolve<IWorkbenchServiceGateway>(); var securityServiceGateway = container.Resolve<ISecurityService>(); entitlementProvider = container.Resolve<IApplicationEntitlementProvider>(); workflowService = container.Resolve<IWorkflowService>(); evaluatorFactory = new TruthConditionEvaluatorFactory(); session = securityServiceGateway.CreateSession(configuration.EventHandlerServiceUser, configuration.EventHandlerServicePassword); SystemSettings settings = workbenchServiceGateway.GetSystemSettings(session.Token); container.RegisterInstance(settings); events = dataAccess.GetNewEvents(); container.RegisterInstance(workbenchServiceGateway.GetRoleList(session.Token)); container.RegisterInstance<Func<UserSearchCriteria, UserList>>(usc => workbenchServiceGateway.GetUserList(session.Token, usc)); container.RegisterInstance(workbenchServiceGateway.GetServiceEndpointList(session.Token, true)); responseHandlers = container.ResolveAll<IEventActionResponseHandler>(); } catch (Exception e) { bool rethrow = ExceptionPolicy.HandleException(e, "Default"); if (rethrow) { throw; } Console.WriteLine(ExceptionMessages.Generic); Environment.Exit(1); } }
public WorkflowController(IWorkflowService workflowService) { this.workflowService = workflowService; }
public WorkflowController(IWorkflowService workflowService, IEmailHelper emailHelper) { this.workflowService = workflowService; this.emailHelper = emailHelper; }