public ExecutorService(IAnimeRepository repository, IAnalyzeService analyzer, AnimePublisherService publisher, TransactionService transactionService)
 {
     _repository         = repository;
     _analyzer           = analyzer;
     _publisher          = publisher;
     _transactionService = transactionService;
 }
Example #2
0
        public PageScoreNodeHelper(ITypedPublishedContentQuery typedPublishedContentQuery, INodeReportRepository nodeReportRepository,
                                   IPageScoreSerializer pageScoreSerializer, IAnalyzeService analyzeService)
        {
            if (typedPublishedContentQuery == null)
            {
                throw new ArgumentNullException(nameof(typedPublishedContentQuery));
            }
            if (nodeReportRepository == null)
            {
                throw new ArgumentNullException(nameof(nodeReportRepository));
            }
            if (pageScoreSerializer == null)
            {
                throw new ArgumentNullException(nameof(pageScoreSerializer));
            }
            if (analyzeService == null)
            {
                throw new ArgumentNullException(nameof(analyzeService));
            }

            _typedPublishedContentQuery = typedPublishedContentQuery;
            _nodeReportRepository       = nodeReportRepository;
            _pagescoreSerializer        = pageScoreSerializer;
            _analyzeService             = analyzeService;
        }
Example #3
0
        public CreateIssueForm()
        {
            InitializeComponent();

            dialogService  = MetaManagerServices.GetDialogService();
            analyzeService = MetaManagerServices.GetAnalyzeService();
        }
Example #4
0
        public Analyze()
        {
            InitializeComponent();

            analyzeService = MetaManagerServices.GetAnalyzeService();
            appService     = MetaManagerServices.GetApplicationService();
        }
Example #5
0
        public static AcquireData GetAcquireData(this IAnalyzeService service, int projectId)
        {
            var operation = new AsyncServiceOperation <AcquireData>();

            service.GetAcquireData(projectId, operation.OnDone, operation.OnError);

            return(operation.WaitCompletion());
        }
Example #6
0
        public ShowIssueList(AnalyzeIssueTree issueTree)
        {
            InitializeComponent();

            AnalyzeIssueTree = issueTree;

            analyzeService = MetaManagerServices.GetAnalyzeService();
        }
Example #7
0
        public static RestitutionData GetFullProjectDetails(this IAnalyzeService service, int projectId)
        {
            var operation = new AsyncServiceOperation <RestitutionData>();

            service.GetFullProjectDetails(projectId, operation.OnDone, operation.OnError);

            return(operation.WaitCompletion());
        }
Example #8
0
        public static void SaveAcquireData(this IAnalyzeService service, Scenario[] allScenarios, Scenario updatedScenario)
        {
            var operation = new AsyncServiceOperation();

            service.SaveAcquireData(allScenarios, updatedScenario, operation.OnDone, operation.OnError);

            operation.WaitCompletion();
        }
Example #9
0
        public CompareService(ICompareConfigDocumentType configDocumentType, IReadFileService readFileService, IAnalyzeService analyzeService)
        {
            this.configDocumentType = configDocumentType;
            this.readFileService    = readFileService;
            this.analyzeService     = analyzeService;

            supportJTokenTypes = new Dictionary <FieldType, JTokenType>();
            supportJTokenTypes.Add(FieldType.Boolean, JTokenType.Boolean);
            supportJTokenTypes.Add(FieldType.Integer, JTokenType.Integer);
            supportJTokenTypes.Add(FieldType.String, JTokenType.String);
        }
Example #10
0
        public AnalysisApiController(IAnalyzeService analyzeService, ITypedPublishedContentQuery typedPublishedContentQuery)
        {
            if (analyzeService == null)
            {
                throw new ArgumentNullException(nameof(analyzeService));
            }
            if (typedPublishedContentQuery == null)
            {
                throw new ArgumentNullException(nameof(typedPublishedContentQuery));
            }

            _analyzeService             = analyzeService;
            _typedPublishedContentQuery = typedPublishedContentQuery;
        }
Example #11
0
        public MainForm(IUnitOfWork unitOfWork, ISearchSortService searchSortService, IAnalyzeService analyzeService, IOrderService orderService)
        {
            InitializeComponent();

            _unitOfWork        = unitOfWork;
            _searchSortService = searchSortService;
            _orderService      = orderService;
            _analyzeService    = analyzeService;

            pnItem = new ItemPnl(_unitOfWork, _searchSortService);
            tabItem.Controls.Add(pnItem);

            pnOrder = new OrderPnl(_unitOfWork, _searchSortService, _orderService);
            tabOrder.Controls.Add(pnOrder);

            pnAnalyze = new AnalyzePnl(_unitOfWork, _searchSortService, _analyzeService);
            tabAnalyze.Controls.Add(pnAnalyze);
        }
        public FeatureLogViewModel(IAnalyzeService service)
        {
            Messenger.Default.Register <Exception>(this, (exception) =>
            {
                var sb = new StringBuilder();
                sb.AppendLine("Exception:");
                sb.AppendLine(exception.Message);

                sb.AppendLine("Inner exception:");
                sb.AppendLine(exception.InnerException != null ? exception.InnerException.Message : string.Empty);

                System.Windows.MessageBox.Show(sb.ToString());
            });

            try
            {
                _analyzeService          = service;
                _analyzeService.PageSize = 100;

                Filter = new FilterViewModel();

                Users          = _analyzeService.GetUsers();
                FeatureClasses = _analyzeService.GetFeatureClasses();

                CommandApplyFilter  = new RelayCommand(ApplyFilter);
                CommandTakeFirst    = new RelayCommand(TakeFirst);
                CommandTakePrevious = new RelayCommand(TakePrevious);
                CommandTakeNext     = new RelayCommand(TakeNext);
                CommandTakeLast     = new RelayCommand(TakeLast);

                State = ModifyState.None;

                DateFrom = DateTime.Now;
                DateTo   = DateTime.Now + new TimeSpan(1, 0, 0, 0);

                CurrentPage = 0;

                //LoadObjects();
            }
            catch (Exception ex)
            {
                Messenger.Default.Send(ex);
            }
        }
        public AnalyzePnl(IUnitOfWork unitOfWork, ISearchSortService searchSortService, IAnalyzeService analyzeService)
        {
            InitializeComponent();
            this.Dock = DockStyle.Fill;

            _unitOfWork        = unitOfWork;
            _searchSortService = searchSortService;
            _analyzeService    = analyzeService;
            _logs = _analyzeService.Logs();
            LoadCheckBoxType();
            LoadItemData();
            LoadGridItem();

            this.numberFrom.Minimum = 0;
            this.numberTo.Minimum   = 0;
            this.numberFrom.Maximum = decimal.MaxValue;
            this.numberTo.Maximum   = Decimal.MaxValue;
            this.numberTo.Value     = 100000000;

            this.dateEnd.MinDate = this.dateStart.Value.Date;
        }
Example #14
0
 /// <summary>
 /// AnalyzeServiceController ctors
 /// </summary>
 /// <param name="analyzeService"></param>
 /// <param name="securityContext"></param>
 public AnalyzeServiceController(ITraceManager traceManager, IAnalyzeService analyzeService, ISecurityContext securityContext)
 {
     _traceManager    = traceManager;
     _analyzeService  = analyzeService;
     _securityContext = securityContext;
 }
 public HomeController(IAnalyzeService analyzeService)
 {
     _analyzeService = analyzeService;
 }
        public AnalyzeIssueList(AnalyzeIssueNode parentNode)
        {
            ParentNode = parentNode;

            analyzeService = MetaManagerServices.GetAnalyzeService();
        }
 public AnalysisApiController(IAnalyzeService analyzeService)
 {
     _analyzeService = analyzeService;
     _umbracoHelper  = new UmbracoHelper(UmbracoContext.Current);
 }
Example #18
0
 public AnalyzesController(IAnalyzeService analyzeService)
 {
     _analyzeService = analyzeService;
 }