StationProbe/StationProbe/SuperImageTask.cs

using PuppeteerSharp;
using static StationProbe.FilterTask;

namespace StationProbe
{
    internal class DefaultExamStore : IExamStore
    {
        private readonly Database _db = new Database();

        public void AddExam(Exam exam)
        {
            _db.AddExam(exam);
        }

        public void AddImage(Image image)
        {
            _db.AddImage(image);
        }

        public void Dispose()
        {
            _db.Dispose();
        }

        public Exam? GetLastExam(int batchTaskId)
        {
            return _db.GetLastExam(batchTaskId, DateTime.MinValue, DateTime.MaxValue);
        }

        public void UpdateBatchTask(BatchTask batchTask)
        {
            _db.UpdateBatchTask(batchTask);
        }
    }

    internal class SuperImageTask : IDisposable
    {
        private readonly IExamStore _examStore;
        private readonly BatchTask _batchTask;
        private readonly int _examCountInPage;
        private int _pageIndex = 0;
        private int _examIndex = 0;
        private int _examIndexInPage = 0;

        public SuperImageTask(BatchTask batchTask, int examCountInPage)
        {
            _batchTask = batchTask;
            _examCountInPage = examCountInPage;
            _examStore = new DefaultExamStore();
        }

        public async Task RunAsync(IPage page)
        {
            var outputs = new ElementCollection();
            outputs.AddObject(ElementType.Page, page);
            var url = "http://192.168.200.85:8080/superimage/login.jsp";
            Logger.WriteLine($"Start login task (url:{url})...");
            try
            {
                outputs = await new LoginTask(_examStore, url).ExecuteAsync(outputs);
            }
            catch (Exception ex)
            {
                Logger.WriteLine($"Run LoginTask failed:{ex}");
                throw;
            }
            await Task.Delay(DelayConfig.TaskDelay);
            Logger.WriteLine("Start menu task...");
            try
            {
                outputs = await new MenuTask(_examStore).ExecuteAsync(outputs);
            }
            catch (Exception ex)
            {
                Logger.WriteLine($"Run MenuTask failed:{ex}");
                throw;
            }
            await Task.Delay(DelayConfig.TaskDelay);
            Logger.WriteLine($"Start filter task（start:{_batchTask.Start:yyyy-MM-dd}, end:{_batchTask.End:yyyy-MM-dd}）...");
            try
            {
                var filterTask = new FilterTask(_examStore, _batchTask.Start, _batchTask.End);
                outputs = await filterTask.ExecuteAsync(outputs);
                if (filterTask.PageCount != _batchTask.PageCount || filterTask.ExamCount != _batchTask.ExamCount)
                {
                    //Update the batchTask
                    _batchTask.ExamCount = filterTask.ExamCount;
                    _batchTask.PageCount = filterTask.PageCount;
                    _examStore.UpdateBatchTask(_batchTask);
                }
                Logger.WriteLine($"Get page count:{filterTask.PageCount}, exam count:{filterTask.ExamCount}");
            }
            catch (Exception ex)
            {
                Logger.WriteLine($"Run FilterTask failed:{ex}");
                throw;
            }
            await Task.Delay(DelayConfig.TaskDelay);
            var lastExam = _examStore.GetLastExam(_batchTask.Id);
            if (lastExam != null)
            {
                _pageIndex = lastExam.PageIndex;
                _examIndex = lastExam.ExamIndex + 1;
                _examIndexInPage = lastExam.ExamIndexInPage + 1;
                if (_examIndexInPage + 1 == _examCountInPage)
                {
                    _pageIndex++;
                    _examIndexInPage = 0;
                }
            }
            Logger.WriteLine($"Start from page: {_pageIndex}, exam index: {_examIndexInPage}");
            while (_pageIndex < _batchTask.PageCount)
            {
                Logger.WriteLine($"Start page task (page:{_pageIndex})");
                try
                {
                    var pageTask = new PageTask(_examStore, _pageIndex);
                    outputs = await pageTask.ExecuteAsync(outputs);
                    var currentExamCountinPage = _pageIndex < (_batchTask.PageCount - 1) ? _examCountInPage : (_batchTask.ExamCount - _pageIndex * _examCountInPage);
                    while (_examIndexInPage < currentExamCountinPage)
                    {
                        Logger.WriteLine($"Start exam task (exam index: {_examIndexInPage}, page index:{_pageIndex})...");
                        try
                        {
                            outputs = await new ExamTask(_examStore, _batchTask.Id, _pageIndex, _examIndex ,_examIndexInPage).ExecuteAsync(outputs);
                        }
                        catch (Exception ex)
                        {
                            Logger.WriteLine($"Run ExamTask failed:{ex}");
                            throw;
                        }
                        _examIndex++;
                        _examIndexInPage++;
                        Counter.IncreaseExamCount();
                        await Task.Delay(DelayConfig.TaskDelay);
                    }
                    _examIndexInPage = 0;
                }
                catch (Exception ex)
                {
                    Logger.WriteLine($"Run PageTask failed:{ex}");
                    throw;
                }
                _pageIndex++;
                await Task.Delay(DelayConfig.TaskDelay);
            }
        }

        public void Dispose()
        {
            _examStore.Dispose();
        }
    }
}