public virtual void setUp()
{
runtimeService = engineRule.RuntimeService;
identityService = engineRule.IdentityService;
managementService = engineRule.ManagementService;
processEngineConfiguration = engineRule.ProcessEngineConfiguration;
}
public MainViewModel(ILogService logService, IManagementService managementService)
{
_logService = logService;
_managementService = managementService;
Initialize();
}
public virtual void setUp()
{
authRule.CreateUserAndGroup("userId", "groupId");
runtimeService = engineRule.RuntimeService;
managementService = engineRule.ManagementService;
historyService = engineRule.HistoryService;
}
public PurchaseCtrl(IPurchaseService purchaseService, IManagementService managementService)
{
_purchaseService = purchaseService;
_managementService = managementService;
InitializeComponent();
this.Dock = DockStyle.Fill;
SetCurrentRequestCategory(RequestCategoriesEnum.材料需求);
//this.gridControl1.DataSource = _purchaseService.GetAllPurchaseViewModels();
//RefreshData();
colApplicationNumber.Visible = false;
colAuditDepart.Visible = false;
RenderCommonHelper.SetColNotEditable(colPurchaseNumber);
RenderCommonHelper.SetColNotEditable(colApplicationNumber);
RenderCommonHelper.SetColNotEditable(colPONumber);
RenderCommonHelper.SetColNotEditable(colSupplierName);
RenderCommonHelper.SetColNotEditable(colPriority);
RenderCommonHelper.SetColNotEditable(colPurchaseType);
RenderCommonHelper.SetColNotEditable(colTotalPrice);
RenderCommonHelper.SetColNotEditable(colCompletePercentage);
RenderCommonHelper.SetColNotEditable(colDeliveryDate);
RenderCommonHelper.SetColNotEditable(colCreateDate);
RenderCommonHelper.SetColNotEditable(colUpdateDate);
colCompletePercentage.DisplayFormat.FormatType = FormatType.Numeric;
colCompletePercentage.DisplayFormat.FormatString = "P";
//_positionRepItem = new RepositoryItemLookUpEdit();
_refreshHelper = new RefreshHelper(gridView1, nameof(parentModel.PurchaseNumber).ToString());
}
public virtual void setUp()
{
authRule.CreateUserAndGroup("userId", "groupId");
runtimeService = engineRule.RuntimeService;
managementService = engineRule.ManagementService;
invocationsPerBatchJob = engineRule.ProcessEngineConfiguration.InvocationsPerBatchJob;
}
public RequestHeadersCtrl(IRequestService requestService, IManagementService managementService)
{
_requestService = requestService;
_managementService = managementService;
InitializeComponent();
this.Dock = DockStyle.Fill;
gridView1.OptionsSelection.MultiSelect = true;
gridView1.OptionsSelection.MultiSelectMode = GridMultiSelectMode.CheckBoxRowSelect;
colCreateDate.Visible = false;
colRequestCategory.Visible = false;
RenderCommonHelper.SetColNotEditable(colRequestHeaderNumber);
RenderCommonHelper.SetColNotEditable(colRequestCategory);
RenderCommonHelper.SetColNotEditable(colPONumber);
//RenderCommonHelper.SetColNotEditable(colContractId);
//RenderCommonHelper.SetColNotEditable(colContractAddress);
RenderCommonHelper.SetColNotEditable(colTotal);
RenderCommonHelper.SetColNotEditable(colStatus);
RenderCommonHelper.SetColNotEditable(colLockStatus);
RenderCommonHelper.SetColNotEditable(colCreateDate);
RenderCommonHelper.SetColNotEditable(colUpdateDate);
colCompletePercentage.DisplayFormat.FormatType = FormatType.Numeric; colCompletePercentage.DisplayFormat.FormatString = "P";
_refreshHelper = new RefreshHelper(gridView1, nameof(parentModel.RequestHeaderNumber).ToString());
}
public HomeController(INetApiService netApiService,
IMenuService menuService, IManagementService managementService)
{
NetApiService = netApiService;
MenuService = menuService;
ManagementService = managementService;
}
/// <summary>
/// Определение списка доступных последовательных портов на удаленном терминале
/// </summary>
/// <param name="managementService">Интерфейс службы управления терминалом</param>
public static void Enumerate(IManagementService managementService)
{
lock (_syncObject)
{
_serialPorts = managementService.SerialPorts;
}
}
public ManagmentServiceTests()
{
_managementService = new ManagementService(_scientificWorkRepositoryMock.Object,
_reviewersScientificWorkRepositoryMock.Object,
_userRepositoryMock.Object,
_emailSenderMock.Object);
}
public virtual void initServices()
{
runtimeService = processEngineRule.RuntimeService;
taskService = processEngineRule.TaskService;
historyService = processEngineRule.HistoryService;
managementService = processEngineRule.ManagementService;
}
/// <summary>
/// Создает экземпляр класса
/// </summary>
/// <param name="service">Служба управления терминалом</param>
public StatisticsProtocolManager(IManagementService service)
{
if (service == null)
throw new ArgumentNullException("service");
_service = service;
// создаем кэш типов, реализующих протоколы статистики
var typesCache = new Dictionary<string, Type>();
foreach (var fileName in Directory.GetFiles(StorageDirectory, "*.dll"))
{
var assembly = LoadAssembly(fileName);
if (assembly != null)
ScanAssembly(assembly, typesCache);
}
// создаем список протоколов
_protocols = new Dictionary<String, IStatisticsProtocol>();
// просматриваем список сконфигурированных протоколов
foreach (var protocolSettings in _service.Settings.Statistics.StatParams)
{
Type implementationType;
if (typesCache.TryGetValue(protocolSettings.Name, out implementationType))
{
// создаем экземпляр протокола
var protocol = (IStatisticsProtocol)Activator.CreateInstance(
implementationType);
// конфигурируем его
protocol.SetManagementService(_service);
protocol.SetProtocolParameter("ТекущийКаталог", StorageDirectory);
foreach (var parameter in protocolSettings.Params)
{
protocol.SetProtocolParameter(parameter.Name, parameter.Value);
}
// добавляем его в список протоколов
if (_protocols.ContainsKey(protocolSettings.Name))
{
_service.EventLink.Post(EventSources.Statistics, EventType.Warning,
String.Format(_configuredMoreThanOnce, protocolSettings.Name));
}
else
_protocols.Add(protocolSettings.Name, protocol);
}
else
_service.EventLink.Post(EventSources.Statistics, EventType.Warning,
String.Format(_implementationNotFound, protocolSettings.Name));
}
// создаем очередь событий
_eventQueueLock = new Object();
_eventQueue = new Queue<EventData>();
// запускаем рабочий поток
_eventsWorker = new PeriodicWorker(ProcessEvents);
_eventsWorker.Start(_workerPeriod);
}
public SearchController(ISearchService searchService,
IManagementService <AgreementT> managementAgreementService,
IManagementService <Brand> managementBrandService,
IManagementService <Cancellation> managementCancellationService,
IManagementService <Company> managementCompanyService,
IManagementService <Contact> managementContactService,
IManagementService <DomainN> managementDomainService,
IManagementService <Enquiry> managementEnquiryService,
IManagementService <Lead> managementLeadService,
IManagementService <LegalCase> managementLegalCaseService,
IManagementService <Office> managementOfficeService,
IManagementService <Register> managementRegisterService,
IManagementService <Trademark> managementTrademarkService,
ITrademarkService trademarkService)
{
this._searchService = searchService;
this._managementAgreementService = managementAgreementService;
this._managementBrandService = managementBrandService;
this._managementCancellationService = managementCancellationService;
this._managementCompanyService = managementCompanyService;
this._managementContactService = managementContactService;
this._managementDomainService = managementDomainService;
this._managementEnquiryService = managementEnquiryService;
this._managementLeadService = managementLeadService;
this._managementLegalCaseService = managementLegalCaseService;
this._managementOfficeService = managementOfficeService;
this._managementRegisterService = managementRegisterService;
this._managementTrademarkService = managementTrademarkService;
this._trademarkService = trademarkService;
}
public StockService(IManagementService managementService,
IRequestHeaderRepository requestHeaderRepository,
IPurchaseService purchaseService,
IRequestService requestService,
IRequestRepository requestRepository,
IPurchaseRepository purchaseRepository,
IPurchaseHeaderRepository purchaseHeaderRepository,
IInStockHeaderRepository inStockHeaderRepository,
IInStockRepository inStockRepository,
IOutStockHeaderRepository outStockHeaderRepository,
IOutStockRepository outStockRepository,
IMapper mapper)
{
_managementService = managementService;
_requestHeaderRepository = requestHeaderRepository;
_purchaseService = purchaseService;
_requestService = requestService;
_requestRepository = requestRepository;
_purchaseRepository = purchaseRepository;
_purchaseHeaderRepository = purchaseHeaderRepository;
_inStockHeaderRepository = inStockHeaderRepository;
_inStockRepository = inStockRepository;
_outStockHeaderRepository = outStockHeaderRepository;
_outStockRepository = outStockRepository;
_mapper = mapper;
}
public static bool IsValid(UserAccount userAccount, IManagementService <UserAccount> service, out Dictionary <string, string> validationResult)
{
validationResult = new Dictionary <string, string>();
if (string.IsNullOrWhiteSpace(userAccount.FirstName))
{
validationResult.Add("Record.FirstName", ValidationMessages.REQUIRED);
}
if (string.IsNullOrWhiteSpace(userAccount.LastName))
{
validationResult.Add("Record.LastName", ValidationMessages.REQUIRED);
}
if (string.IsNullOrWhiteSpace(userAccount.EmailAddress))
{
validationResult.Add("Record.EmailAddress", ValidationMessages.REQUIRED);
}
else
{
var existingAccount = service.GetByEmailAddress(userAccount.EmailAddress).FirstOrDefault();
if ((existingAccount != null && userAccount.ID == 0) || (existingAccount != null && userAccount.ID != existingAccount.ID))
{
validationResult.Add("Record.EmailAddress", ValidationMessages.EMAILADDRESS_EXISTS);
}
}
if (string.IsNullOrWhiteSpace(userAccount.Roles))
{
validationResult.Add("Record.Roles", ValidationMessages.ROLES_REQUIRED);
}
return(!validationResult.Any());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void initServices()
public virtual void initServices()
{
runtimeService = engineRule.RuntimeService;
repositoryService = engineRule.RepositoryService;
managementService = engineRule.ManagementService;
processEngineConfiguration = engineRule.ProcessEngineConfiguration;
}
private void InternalDoWork(IManagementService managementService,
PosTerminalParams pos, Int32 percent)
{
// вызываем делегат для работы с очередным терминалом
_posWorkDelegate(managementService, pos);
// сообщаем о прогрессе выполнения
backgroundWorker.ReportProgress(percent, new WorkStatusHelper(pos, null));
}
//JAVA TO C# CONVERTER TODO Resources.Task: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void initialize()
public virtual void initialize()
{
repositoryService = cacheFactoryEngineRule.RepositoryService;
processEngineConfiguration = cacheFactoryEngineRule.ProcessEngineConfiguration;
runtimeService = cacheFactoryEngineRule.RuntimeService;
taskService = cacheFactoryEngineRule.TaskService;
managementService = cacheFactoryEngineRule.ManagementService;
}
public ConfigurationForm(IManagementService managementService)
{
Prevent.ParameterNull(managementService, nameof(managementService));
_managementService = managementService;
InitializeComponent();
}
public ManagementController(
IManagementService managementService,
IOptions <PagingOptions> defaultPagingOptions
)
{
_managementService = managementService;
_defaultPagingOptions = defaultPagingOptions.Value;
}
/// <summary>
/// Создает экземпляр класса
/// </summary>
/// <param name="service">Интерфейс службы управления подключенного терминала</param>
/// <param name="current">Элемент файловой системы терминала,
/// с которого нужно начинать загрузку</param>
/// <param name="storageFolder">Папка для сохранения скачанных данных</param>
public FormDownloadWorker(IManagementService service, IFileSystemItem current,
String storageFolder)
{
InitializeComponent();
_service = service;
_current = current;
_storageFolder = storageFolder;
_filesProcessed = 0;
}
public void ShowDialog(IManagementService service)
{
LoadPromotion(service);
if (ShowDialog() == DialogResult.OK)
{
SavePromotion(service);
}
}
public AccountController(
IManagementService <UserAccount> service,
IAuditTrailService auditTrailService)
{
this._service = service;
this._auditTrailService = auditTrailService;
}
public SupplierManagementCtrl(IManagementService managemntService) : base()
{
_managementService = managemntService;
InitializeComponent();
this.Dock = DockStyle.Fill;
this.gridControl1.DataSource = _managementService.GetAllSuppliers();
colId.Visible = false;
_refreshHelper = new RefreshHelper(gridView1, nameof(parentModel.Id).ToString());
}
public ConversationViewModel(
IManagementService managementService,
IEventAggregator eventAggregator)
{
_managementService = managementService;
_eventAggregator = eventAggregator;
_nodeMap = new ConcurrentDictionary<string, DiagramNode>();
Graph = new ConversationGraph();
}
public BaseManagementController(IManagementService <TObject, TFilter> managementService,
IServiceProvider serviceProvider)
{
_managementService = managementService;
_mapper = serviceProvider.GetRequiredService <IMapper>();
ListViewName = listViewName;
EditViewName = editViewName;
CreateViewName = createViewName;
DeleteViewName = deleteViewName;
}
public virtual void init()
{
managementService = engineRule.ManagementService;
identityService = engineRule.IdentityService;
testRule.DeployForTenant(TENANT_ONE, BPMN_PROCESS);
testRule.DeployForTenant(TENANT_ONE, BPMN_NO_FAIL_PROCESS);
processInstance = engineRule.RuntimeService.StartProcessInstanceByKey(PROCESS_DEFINITION_KEY);
}
public AboutViewModel(
INetworkOperations networkOperations,
IManagementService managementService,
ILicenseRegistrationViewModel licenseInfo)
{
_networkOperations = networkOperations;
_managementService = managementService;
License = licenseInfo;
DisplayName = "About";
}
public RefundApplicationCtrl(IPurchaseService purchaseService, IManagementService managementService) : base(purchaseService, managementService)
{
SetCurrentRequestCategory(RequestCategoriesEnum.采购退货);
colApplicationNumber.Caption = @"退货申请号";
//colSelectedPurchaseNumber.Visible = true;
//RenderCommonHelper.SetColNotEditable(colSupplierName);
listOfPurchaseViewModels = _purchaseService.GetAllPurchaseNumberByItemCode();
RefreshData();
//this.gridControl1.DataSource = _purchaseService.GetAllPurchaseApplicationViewModels(_currentRequestCategory);
}
public MessageListViewModel(
IEventAggregator eventAggregator,
IWindowManagerEx windowManager,
IManagementService managementService,
IQueueManagerAsync asyncQueueManager)
{
_eventAggregator = eventAggregator;
_windowManager = windowManager;
_managementService = managementService;
_asyncQueueManager = asyncQueueManager;
Messages = new BindableCollection <MessageInfo>();
SelectedMessages = new BindableCollection <MessageInfo>();
}
public MessageListViewModel(
IEventAggregator eventAggregator,
IWindowManagerEx windowManager,
IManagementService managementService,
IQueueManagerAsync asyncQueueManager)
{
_eventAggregator = eventAggregator;
_windowManager = windowManager;
_managementService = managementService;
_asyncQueueManager = asyncQueueManager;
Messages = new BindableCollection<MessageInfo>();
SelectedMessages = new BindableCollection<MessageInfo>();
}
public ContractManagementCtrl(IManagementService managemntService)
{
_managemntService = managemntService;
InitializeComponent();
this.Dock = DockStyle.Fill;
this.gridControl1.DataSource = _managemntService.GetAllPoNumbers();
colPOId.Visible = false;
RenderCommonHelper.SetColNotEditable(colCreateDate);
RenderCommonHelper.SetColNotEditable(colUpdateDate);
_refreshHelper = new RefreshHelper(gridView1, nameof(parentModel.PoNumber).ToString());
}
public BoardsController(
IDepartmentsStructureService departmentsStructureService,
IClientsService clientsService,
IManagementService managementService,
ITrackerClient trackerClient,
IHostingEnvironment hostingEnvironment
)
{
_departmentsStructureService = departmentsStructureService;
_clientsService = clientsService;
_managementService = managementService;
_trackerClient = trackerClient;
_hostingEnvironment = hostingEnvironment;
}
public EndpointExplorerViewModel(
IEventAggregator eventAggregator,
ISettingsProvider settingsProvider,
IManagementConnectionProvider managementConnection,
IManagementService managementService,
INetworkOperations networkOperations)
{
_eventAggregator = eventAggregator;
_settingsProvider = settingsProvider;
_managementService = managementService;
_networkOperations = networkOperations;
_managementConnection = managementConnection;
Items = new BindableCollection<ExplorerItem>();
}
protected internal virtual void InitializeServices()
{
RepositoryService = ProcessEngine.RepositoryService;
RuntimeService = ProcessEngine.RuntimeService;
TaskService = ProcessEngine.TaskService;
HistoricDataService = ProcessEngine.HistoryService;
HistoryService = ProcessEngine.HistoryService;
IdentityService = ProcessEngine.IdentityService;
ManagementService = ProcessEngine.ManagementService;
FormService = ProcessEngine.FormService;
FilterService = ProcessEngine.FilterService;
AuthorizationService = ProcessEngine.AuthorizationService;
CaseService = ProcessEngine.CaseService;
}
protected internal virtual void ClearServiceReferences()
{
processEngineConfiguration = null;
repositoryService = null;
runtimeService = null;
taskService = null;
formService = null;
historyService = null;
identityService = null;
managementService = null;
authorizationService = null;
caseService = null;
filterService = null;
externalTaskService = null;
decisionService = null;
}
protected internal virtual void InitializeServices()
{
processEngineConfiguration = ProcessEngine.ProcessEngineConfiguration as ProcessEngineConfigurationImpl;
repositoryService = ProcessEngine.RepositoryService;
runtimeService = ProcessEngine.RuntimeService;
taskService = ProcessEngine.TaskService;
formService = ProcessEngine.FormService;
historyService = ProcessEngine.HistoryService;
identityService = ProcessEngine.IdentityService;
managementService = ProcessEngine.ManagementService;
authorizationService = ProcessEngine.AuthorizationService;
caseService = ProcessEngine.CaseService;
filterService = ProcessEngine.FilterService;
externalTaskService = ProcessEngine.ExternalTaskService;
decisionService = ProcessEngine.DecisionService;
}
public PublicController(
IManagementService <UserAccount> managementUserAccountService,
IAuditTrailService auditTrailService)
{
this._managementUserAccountService = managementUserAccountService;
this._emailAutomationService = new EmailAutomationService(
ConfigurationManager.AppSettings["SMTP_Host"],
Convert.ToInt32(ConfigurationManager.AppSettings["SMTP_Port"]),
ConfigurationManager.AppSettings["SMTP_FromEmail"],
ConfigurationManager.AppSettings["SMTP_Username"],
ConfigurationManager.AppSettings["SMTP_Password"]);
this._auditTrailService = auditTrailService;
}
public NugetManagerCommand(IStageService stage, IManagementService management)
{
this.stage = stage ?? throw new ArgumentNullException(nameof(stage));
this.management = management ?? throw new ArgumentNullException(nameof(management));
// Stage (default)
RegisterQuery(StageQueries.STAGE, new StageCommand(stage));
// Management
RegisterQuery(ManageQueries.PROJECT, new ProjectCommand(management.Projects));
RegisterQuery(ManageQueries.PACKAGE, new PackageCommand(management.Packages, management.Projects));
// Operations
RegisterQuery(ApplyQueries.INSTALL, new InstallCommand());
RegisterQuery(ApplyQueries.UNINSTALL, new UninstallCommand());
RegisterQuery(ApplyQueries.UPDATE, new UpdateCommand());
}
/// <summary>
///
/// </summary>
/// <param name="historyService"></param>
/// <param name="taskService"></param>
/// <param name="dynamicBpmnService"></param>
/// <param name="repositoryService"></param>
/// <param name="runtimeService"></param>
/// <param name="managementService"></param>
/// <param name="asyncExecutor"></param>
/// <param name="configuration"></param>
public StandaloneProcessEngineConfiguration(IHistoryService historyService,
ITaskService taskService,
IDynamicBpmnService dynamicBpmnService,
IRepositoryService repositoryService,
IRuntimeService runtimeService,
IManagementService managementService,
IAsyncExecutor asyncExecutor,
IConfiguration configuration) : base(historyService,
taskService,
dynamicBpmnService,
repositoryService,
runtimeService,
managementService,
asyncExecutor,
configuration)
{
}
private void SavePromotion(IManagementService service)
{
Cursor = Cursors.WaitCursor;
try
{
service.Promotion = new PromotionData
{
Id = promotionId,
ThresholdQuantity = nudN.Value,
PartitionQuantity = nudX.Value,
ResultQuantity = nudY.Value,
Result = (PromotionGoodsData)cbAvailableResults.SelectedItem
};
}
finally
{
Cursor = Cursors.Default;
}
}
public ProcessEngineImpl(ProcessEngineConfigurationImpl processEngineConfiguration)
{
this.processEngineConfiguration = processEngineConfiguration;
this.name = processEngineConfiguration.ProcessEngineName;
this.repositoryService = processEngineConfiguration.RepositoryService;
this.runtimeService = processEngineConfiguration.RuntimeService;
this.historicDataService = processEngineConfiguration.HistoryService;
this.taskService = processEngineConfiguration.TaskService;
this.managementService = processEngineConfiguration.ManagementService;
this.dynamicBpmnService = processEngineConfiguration.DynamicBpmnService;
this.asyncExecutor = processEngineConfiguration.AsyncExecutor;
this.commandExecutor = processEngineConfiguration.CommandExecutor;
this.sessionFactories = processEngineConfiguration.SessionFactories;
this.transactionContextFactory = processEngineConfiguration.TransactionContextFactory;
if (processEngineConfiguration.UsingRelationalDatabase && processEngineConfiguration.DatabaseSchemaUpdate is object)
{
commandExecutor.Execute(processEngineConfiguration.SchemaCommandConfig, new SchemaOperationsProcessEngineBuild());
}
if (name is null)
{
log.LogInformation("default activiti ProcessEngine created");
}
else
{
log.LogInformation($"ProcessEngine {name} created");
}
ProcessEngineFactory.RegisterProcessEngine(this);
if (asyncExecutor != null && asyncExecutor.AutoActivate)
{
asyncExecutor.Start();
}
if (processEngineConfiguration.ProcessEngineLifecycleListener != null)
{
processEngineConfiguration.ProcessEngineLifecycleListener.OnProcessEngineBuilt(this);
}
processEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateGlobalEvent(ActivitiEventType.ENGINE_CREATED));
}
/// <summary>
/// Создает экземпляр класса
/// </summary>
/// <param name="service">Служба управления</param>
/// <param name="storageFolder">Папка для хранения флага</param>
public StartupFlag(IManagementService service, String storageFolder)
{
_service = service;
_flagName = String.Format("{0}\\startup.flag", storageFolder);
if (File.Exists(_flagName))
{
// флаг существует, предыдущее завершение работы
// было некорректным
_service.EventLink.Post(EventSources.ManagementService, EventType.Error,
_abnormalShutdown);
}
// открываем файл-флаг
_flag = new FileStream(_flagName, FileMode.Create,
FileAccess.ReadWrite, FileShare.Read);
// записываем в него время запуска
WriteTime("Время запуска");
}
private void LoadPromotion(IManagementService service)
{
Cursor = Cursors.WaitCursor;
try
{
var promotion = service.Promotion;
promotionId = promotion.Id;
nudN.Value = promotion.ThresholdQuantity;
nudX.Value = promotion.PartitionQuantity;
nudY.Value = promotion.ResultQuantity;
cbAvailableResults.DataSource = promotion.AvailableResults;
if (promotion.Result != null)
{
cbAvailableResults.SelectedItem = promotion.AvailableResults.FirstOrDefault(_ => _.Id == promotion.Result.Id);
}
}
finally
{
Cursor = Cursors.Default;
}
}
public ManagementConnectionViewModel(IManagementService managementService)
{
_managementService = managementService;
DisplayName = "Connect To Service";
}
/// <summary>
/// Задать экземпляр службы управления терминалом
/// </summary>
/// <param name="service">Экземпляр службы управления терминалом</param>
public void SetManagementService(IManagementService service)
{
Service = service;
}
public ManagementController(IManagementService managementComponent)
{
this.mgmt = managementComponent;
}
/// <summary>
/// Инициализация элементов управления
/// </summary>
/// <param name="service">Ссылка на интерфейс службы управления</param>
public void InitializeControls(IManagementService service)
{
// список строк для сводного отчета
List<String> summary = new List<String>();
// загрузка элементов файловой системы из папки
// установки "Форинт-К"
summary.Add("Папка установки \"Форинт-К\"");
BuildTree("Папка установки \"Форинт-К\"", summary,
service.CashsystemRoot, tvInstallDir, true);
// загрузка элементов файловой системы из
// системной папки ОС
summary.Add(String.Empty);
summary.Add(String.Empty);
summary.Add("Системная папка ОС");
BuildTree("Системная папка ОС", summary, service.BplRoot, tvWinSysDir, false);
// сводный отчет
tbSummary.Lines = summary.ToArray();
// активная закладка - папка установки "Форинт-К"
tcVersionTabs.SelectedIndex = 0;
ActiveControl = tvInstallDir;
}
public ManagementController(IManagementService managementService)
{
ManagementService = managementService;
}
/// <summary>
/// Выполнение диалога
/// </summary>
/// <param name="service">Интерфейс службы управления</param>
public Boolean Execute(IManagementService service)
{
// забираем список пользователей
_users = service.Users;
// инициализируем элементы управления
InitializeControls();
// показываем диалог
return ShowDialog() == DialogResult.OK;
}
static StreamInsight()
{
var core = ServiceLocator.Current.Resolve<QueriesCore>();
_service = core.GetManagementService();
}
/// <summary>
/// Выполнение диалога
/// </summary>
/// <param name="service">Интерфейс службы управления на подключенном терминале</param>
/// <param name="connectedParams">Параметры подключенного терминала</param>
public Boolean Execute(IManagementService service, PosTerminalParams connectedParams)
{
// инициализация полей
_service = service;
_connectedParams = connectedParams;
// инициализация элементов управления
InitializeControls();
// показываем диалог
return ShowDialog() == DialogResult.OK;
}
