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