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);
 }
Beispiel #3
0
 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;
 
 }
Beispiel #8
0
 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;
		}
Beispiel #10
0
 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;
 }
Beispiel #17
0
 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;
 }
Beispiel #18
0
 public static WorkflowActionEntity FetchWorkflowActionByUuid(
     IWorkflowService workflowService,
     Guid uuid)
 {
     return(workflowService
            .DbConnection
            .Query <WorkflowActionEntity>(QueryBuilder.FetchWorkflowActionByUuid(), new
     {
         Uuid = uuid
     })
            .FirstOrDefault());
 }
Beispiel #19
0
 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;
 }
Beispiel #20
0
 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>();
 }
Beispiel #21
0
 public static WorkflowActionEntity[] FetchActiveActionsByWorkflowGuid(
     IWorkflowService workflowService,
     Guid workflowUuid)
 {
     return(workflowService
            .DbConnection
            .Query <WorkflowActionEntity>(QueryBuilder.FetchActiveActionsByWorkflowUuid(), new
     {
         WorkflowUuid = workflowUuid
     })
            .ToArray());
 }
Beispiel #22
0
 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();
        }
Beispiel #24
0
 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;
 }
Beispiel #25
0
        public async Task <IActionResult> Delete(string id, [FromServices] IWorkflowService _service)
        {
            try
            {
                await _service.Delete(id);

                return(NoContent());
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Beispiel #26
0
        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));
            }
        }
Beispiel #27
0
        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;
        }
Beispiel #28
0
 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;
 }
Beispiel #30
0
 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>();
 }
Beispiel #31
0
        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);
        }
Beispiel #32
0
 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;
 }
Beispiel #34
0
        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);
        }
Beispiel #35
0
        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);
        }
Beispiel #36
0
 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;
 }
Beispiel #40
0
        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);
            }
        }
Beispiel #41
0
        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);
        }
Beispiel #42
0
        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);
 }
Beispiel #44
0
 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;
 }
Beispiel #45
0
 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;
 }
Beispiel #47
0
 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;
 }
Beispiel #48
0
        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;
 }
Beispiel #50
0
    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";
    }
Beispiel #51
0
 public ApprovalService(IWorkflowService workFlowService,
     IUserProfileRepository personalInformationRepository)
 {
     _workFlowService = workFlowService;
     _personalInformationRepository = personalInformationRepository;
 }
Beispiel #52
0
 public Service(IWorkflowService workflowService, IRoleService roleService)
 {
     this.workflowService = workflowService;
     this.roleService = roleService;
 }
Beispiel #53
0
 public Service(IDocumentService documentService, IWorkflowService workflowService)
 {
     this.documentService = documentService;
     this.workflowService = workflowService;
 }
Beispiel #54
0
 public WorkflowEngine(IWorkflowService workflowService, IConfiguration configuration)
 {
     _workflowService = workflowService;
     _configuration = configuration;
     Actions = new List<ClientAction>();
 }
Beispiel #55
0
 public Service(IStatusService statusService, IWorkflowService workflowService)
 {
     this.statusService = statusService;
     this.workflowService = workflowService;
 }
Beispiel #56
0
        /// <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;
 }