StationProbe/StationProbe/ProbeTask.cs

using PuppeteerSharp;

namespace StationProbe
{

    internal enum ElementType
    {
        Page,
        Frame
    }

    internal static class ElementConverter
    {
        public static T? As<T>(this object obj) where T : class
        {
            return obj as T;
        }
    }

    internal class ElementCollection
    {
        private readonly Dictionary<ElementType, object> _objects = new();

        public object this[ElementType type] => _objects[type];

        public void AddObject(ElementType element, object obj)
        {
            _objects.Add(element, obj);
        }
    }

    internal interface IExamStore:IDisposable
    {
        Exam? GetLastExam(int batchTaskId);
        void AddExam(Exam exam);
        void AddImage(Image image);
        void UpdateBatchTask(BatchTask batchTask);
    }

    internal abstract class ProbeTask
    {
        public static bool DebugMode { get; set; }

        private static string _debugFolder = string.Empty;

        protected ScreenshotOptions _snapshotOpts = new ScreenshotOptions() { Type = ScreenshotType.Png };

        protected readonly IExamStore _examStore;
        public ProbeTask(IExamStore examStore)
        {
            _examStore = examStore;
        }

        public static void InitDebugFolder()
        {
            var drives = DriveInfo.GetDrives();
            var largestDriver = drives.OrderByDescending(x => x.TotalFreeSpace).First();
            var debugFolder = largestDriver.Name + "debug";
            if (!Directory.Exists(debugFolder))
            {
                Directory.CreateDirectory(debugFolder);
            }
            var i = 1;
            while (Directory.Exists(Path.Combine(debugFolder, i.ToString("D6"))))
            {
                i++;
            }
            _debugFolder = Path.Combine(debugFolder, i.ToString("D6"));
            Directory.CreateDirectory(_debugFolder);
        }

        public void SaveDebugSnapshot(string name, byte[] imageData)
        {
            if (Directory.Exists(_debugFolder))
            {
                var file = Path.Combine(_debugFolder, name);
                File.WriteAllBytes(file, imageData);
            }
        }

        public abstract Task<ElementCollection> ExecuteAsync(ElementCollection inputs);
    }

    internal class LoginTask : ProbeTask
    {
        private readonly string _loginUrl;

        public LoginTask(IExamStore examStore, string loginUrl) : base(examStore)
        {
            _loginUrl = loginUrl;
        }

        public override async Task<ElementCollection> ExecuteAsync(ElementCollection inputs)
        {
            var page = inputs[ElementType.Page].As<IPage>();
            if (page != null)
            {
                await page.GoToAsync(_loginUrl);

                if (DebugMode)
                {
                    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                    var fileName = "100000000.jpg";
                    SaveDebugSnapshot(fileName, imageData);
                }

                //username
                await using (var userElement = await page.WaitForSelectorAsync("input[id=\"userName\"]"))
                {
                    await userElement.FocusAsync();
                    await page.Keyboard.TypeAsync("justin.xing");
                }

                if (DebugMode)
                {
                    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                    var fileName = "200000000.jpg";
                    SaveDebugSnapshot(fileName, imageData);
                }

                //password
                await using (var passwordElement = await page.WaitForSelectorAsync("input[id=\"password\"]"))
                {
                    await passwordElement.FocusAsync();
                    await page.Keyboard.TypeAsync("vinno@123");
                }

                if (DebugMode)
                {
                    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                    var fileName = "300000000.jpg";
                    SaveDebugSnapshot(fileName, imageData);
                }

                //login
                await using (var loginButtonElement = await page.WaitForSelectorAsync("button[b-kvd270uhz9]"))
                {
                    await loginButtonElement.ClickAsync();
                    await page.WaitForNetworkIdleAsync();
                }

                if (DebugMode)
                {
                    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                    var fileName = "400000000.jpg";
                    SaveDebugSnapshot(fileName, imageData);
                }
            }
            return inputs;
        }
    }

    internal class MenuTask : ProbeTask
    {
        public MenuTask(IExamStore examStore) : base(examStore)
        {
        }

        public override async Task<ElementCollection> ExecuteAsync(ElementCollection inputs)
        {
            Logger.WriteLine("Finding menu...");
            var page = inputs[ElementType.Page].As<IPage>();
            if (page != null)
            {
                await using (var menuElement = await page.WaitForSelectorAsync("a[href=\"feedback/list\"]"))
                {
                    await menuElement.ClickAsync();
                    if (DebugMode)
                    {
                        var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                        var fileName = "500000000.jpg";
                        SaveDebugSnapshot(fileName, imageData);
                    }
                }

            }
            return inputs;
        }
    }

    internal class FilterTask : ProbeTask
    {
        private readonly DateTime _start;
        private readonly DateTime _end;

        public int PageCount { get; private set; }

        public int ExamCount { get; private set; }

        public FilterTask(IExamStore examStore, DateTime start, DateTime end) : base(examStore)
        {
            _start = start;
            _end = end;
        }

        public override async Task<ElementCollection> ExecuteAsync(ElementCollection inputs)
        {
            var page = inputs[ElementType.Page].As<IPage>();
            //var frame = inputs[ElementType.Frame].As<IFrame>();
            if (page != null) //&& frame != null) 
            {
                //var filterElements = await page.QuerySelectorAllAsync("div[class=\"me-3 my-1\"]");
                //var filterElement1 = filterElements[3];
                //var filterElement2 = filterElements[4];

                ////show filter dialog
                //if (DebugMode)
                //{
                //    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                //    var fileName = "600000000.jpg";
                //    SaveDebugSnapshot(fileName, imageData);
                //}

                ////input start
                //var openElement1 = await filterElement1.WaitForSelectorAsync("div[class=\"multi-select\"]");
                //await openElement1.ClickAsync();
                //var optionListElement1 = await filterElement1.WaitForSelectorAsync("div[class=\"dropdown-menu shadow\"]");
                //var optionElements = await optionListElement1.QuerySelectorAllAsync("div[class=\"dropdown-item\"]");
                //var targetElement = optionElements[0];
                //await targetElement.ClickAsync();

                //if (DebugMode)
                //{
                //    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                //    var fileName = "700000000.jpg";
                //    SaveDebugSnapshot(fileName, imageData);
                //}

                //var openlement2 = await filterElement2.WaitForSelectorAsync("div[class=\"multi-select\"]");
                //await openlement2.ClickAsync();
                //var optionListElement2 = await filterElement2.WaitForSelectorAsync("div[class=\"dropdown-menu shadow\"]");
                //optionElements = await optionListElement2.QuerySelectorAllAsync("div[class=\"dropdown-item\"]");
                //targetElement = optionElements[0];
                //await targetElement.ClickAsync();

                ////input end
                //if (DebugMode)
                //{
                //    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                //    var fileName = "800000000.jpg";
                //    SaveDebugSnapshot(fileName, imageData);
                //}

                //var searchTableElement = await page.QuerySelectorAsync("div[class=\"table-search\"]");
                //var searchButtonElement = await searchTableElement.QuerySelectorAsync("button[class=\"btn btn-primary btn-xs ms-2\"]");
                //await searchButtonElement.ClickAsync();
                //await page.WaitForNetworkIdleAsync();

                //if (DebugMode)
                //{
                //    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                //    var fileName = "900000000.jpg";
                //    SaveDebugSnapshot(fileName, imageData);
                //}

                await using (var pageinationElement = await page.QuerySelectorAsync("div[class=\"table-pagination\"]"))
                {
                    await using (var examCountElement = await pageinationElement.QuerySelectorAsync("div[class=\"d-none d-sm-inline-block\"]"))
                    {
                        var examCountStr = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", examCountElement);
                        var words = examCountStr.Split(' ');
                        ExamCount = int.Parse(words[1]);
                    }

                }

                await using (var pagesElement = await page.QuerySelectorAsync("ul[class=\"pagination\"]"))
                {
                    var pageItemElements = await pagesElement.QuerySelectorAllAsync("li");
                    var lastPageElement = pageItemElements[pageItemElements.Length - 2];
                    await using (var textElement = await lastPageElement.QuerySelectorAsync("a"))
                    {
                        var lastPageStr = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", textElement);
                        PageCount = int.Parse(lastPageStr);
                    }
                    foreach (var pageItemElement in pageItemElements)
                    {
                        await pageItemElement.DisposeAsync();
                    }
                }
            }
            return inputs;
        }
    }

    internal class PageTask : ProbeTask
    {
        private readonly int _page;
        public PageTask(IExamStore examStore, int page) : base(examStore)
        {
            _page = page;
        }

        private async Task JumpToPageAsync(IPage page)
        {
            while (true)
            {
                await using (var pagesElement = await page.WaitForSelectorAsync("ul[class=\"pagination\"]"))
                {
                    var pageItemElements = await pagesElement.QuerySelectorAllAsync("li");
                    await using (var currentPageElemment = await pagesElement.QuerySelectorAsync("li[class=\"page-item active\"]"))
                    {
                        await using (var textElement = await currentPageElemment.QuerySelectorAsync("a"))
                        {
                            var currentPageStr = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", textElement);
                            var currentPage = int.Parse(currentPageStr);
                            if (currentPage != _page + 1)
                            {
                                var nextPageElement = pageItemElements[pageItemElements.Length - 1];
                                await nextPageElement.ClickAsync();
                                foreach(var pageItemElement in pageItemElements)
                                {
                                   await pageItemElement.DisposeAsync();
                                }
                            }
                            else
                            {
                                foreach (var pageItemElement in pageItemElements)
                                {
                                    await pageItemElement.DisposeAsync();
                                }
                                break;
                            }
                        }
                    }
                }
                await Task.Delay(DelayConfig.JumpDelay);
            }

        }

        public override async Task<ElementCollection> ExecuteAsync(ElementCollection inputs)
        {
            var page = inputs[ElementType.Page].As<IPage>();
            //var frame = inputs[ElementType.Frame].As<IFrame>();
            if (page != null) //&& frame != null)
            {
                await JumpToPageAsync(page);
                if (DebugMode)
                {
                    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                    var fileName = "9" + _page.ToString("D5") + "000.jpg";
                    SaveDebugSnapshot(fileName, imageData);
                }
            }
            return inputs;
        }
    }

    internal class ExamTask : ProbeTask
    {
        private readonly int _batchTaskId;
        private readonly int _pageIndex;
        private readonly int _examIndex;
        private readonly int _examIndexInPage;

        public ExamTask(IExamStore examStore, int batchTaskId, int pageIndex, int examIndex, int examIndexInPage) : base(examStore)
        {
            _batchTaskId = batchTaskId;
            _pageIndex = pageIndex;
            _examIndex = examIndex;
            _examIndexInPage = examIndexInPage;
        }

        private async Task JumpToPageAsync(IPage page)
        {
            while (true)
            {
                await using (var pagesElement = await page.WaitForSelectorAsync("ul[class=\"pagination\"]"))
                {
                    var pageItemElements = await pagesElement.QuerySelectorAllAsync("li");
                    await using (var currentPageElemment = await pagesElement.QuerySelectorAsync("li[class=\"page-item active\"]"))
                    {
                        await using (var textElement = await currentPageElemment.QuerySelectorAsync("a"))
                        {
                            var currentPageStr = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", textElement);
                            var currentPage = int.Parse(currentPageStr);
                            if (currentPage != _pageIndex + 1)
                            {
                                var nextPageElement = pageItemElements[pageItemElements.Length - 1];
                                await nextPageElement.ClickAsync();
                                foreach (var pageItemElement in pageItemElements)
                                {
                                    await pageItemElement.DisposeAsync();
                                }
                            }
                            else
                            {
                                foreach (var pageItemElement in pageItemElements)
                                {
                                    await pageItemElement.DisposeAsync();
                                }
                                break;
                            }
                        }
                    }
                }
                await Task.Delay(DelayConfig.JumpDelay);
            }

        }

        private async Task EnterExamAsync(IPage page)
        {
            await JumpToPageAsync(page);
            await using (var tableElement = await page.QuerySelectorAsync("table[class=\"table table-bordered table-striped table-hover\"]"))
            {
                var examLinkElements = await tableElement.QuerySelectorAllAsync("div[style=\"cursor:pointer;\"]");
                var eaxmLinkElement = examLinkElements[_examIndexInPage];
                await eaxmLinkElement.ClickAsync();
                foreach(var examLinkElement in examLinkElements)
                {
                    await examLinkElement.DisposeAsync();
                }
            }
        }

        private async Task ExitExamAsync(IPage page)
        {
            //Wait for the back button.
            await using (var backButtonElement = await page.WaitForSelectorAsync("button[class=\"btn fix-item feedback-common-button\"]"))
            {
                await page.EvaluateFunctionAsync("b => b.click()", backButtonElement);
            }
        }

        private async void DoSaveExamImageAsync(IPage page, string examId, int imageIndex, string imageUrl, ManualResetEvent finishEvent)
        {
            var response = await page.WaitForResponseAsync(imageUrl);
            var imageData = await response.BufferAsync();
            var image = new Image()
            {
                Id = Guid.NewGuid().ToString("N"),
                ExamId = examId,
                ImageIndex = imageIndex,
                Data = imageData,
                CreateTime = DateTime.Now,
            };
            _examStore.AddImage(image);
            Logger.WriteLine($"Image:{imageUrl} stored.");
            finishEvent.Set();
        }

        private async Task SaveExamImageAsync(IPage page, string examId, int imageIndex, string imageUrl)
        {
            await using (var imagePage = await page.Browser.NewPageAsync())
            {
                var finishEvent = new ManualResetEvent(false);
                finishEvent.Reset();
                DoSaveExamImageAsync(imagePage, examId, imageIndex, imageUrl, finishEvent);
                await imagePage.GoToAsync(imageUrl);
                finishEvent.WaitOne();
                finishEvent.Dispose();
            }
        }

        private async Task<List<string>> GetImageUrlsAsync(IPage page)
        {
            //Get all image urls.
            var imageUrls = new List<string>();
            await using (var backButtonElement = await page.WaitForSelectorAsync("button[class=\"btn fix-item feedback-common-button\"]"))
            {
                var imageDivElements = await page.QuerySelectorAllAsync("div[class=\"bb-img is-preview\"]");
                if (imageDivElements != null)
                {
                    foreach (var imageDivElement in imageDivElements)
                    {
                        await using (var imageElement = await imageDivElement.QuerySelectorAsync("img"))
                        {
                            await using (var imageUrl = await imageElement.GetPropertyAsync("src"))
                            {
                                var url = await imageUrl.JsonValueAsync<string>();
                                imageUrls.Add(url);
                            }
                        }
                        await imageDivElement.DisposeAsync();
                    }
                }
            }
            Logger.WriteLine($"Get image url count:{imageUrls.Count}");
            return imageUrls;
        }

        private async Task<string> GetReportAsync(IPage page)
        {
            var report = "";
            var reportElements = await page.QuerySelectorAllAsync("div[class=\"col\"]");
            foreach (var reportElement in reportElements)
            {
                await using (var strong = await reportElement.QuerySelectorAsync("strong"))
                {
                    if (strong != null)
                    {
                        var content = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", strong);
                        report += " " + content;
                    }
                }
                await reportElement.DisposeAsync();
            }
            Logger.WriteLine($"Get report:{report}");
            return report;
        }

        public override async Task<ElementCollection> ExecuteAsync(ElementCollection inputs)
        {
            var page = inputs[ElementType.Page].As<IPage>();
            //var frame = inputs[ElementType.Frame].As<IFrame>();
            if (page != null) //&& frame != null)
            {
                var examId = Guid.NewGuid().ToString("N");
                //First time enter exam.
                await EnterExamAsync(page);

                //wait for page loaded.
                await Task.Delay(DelayConfig.ExamContentDelay);
                
                var imageUrls = await GetImageUrlsAsync(page);
                for (var i = 0; i < imageUrls.Count; i++)
                {
                    await SaveExamImageAsync(page, examId, i, imageUrls[i]);
                    //Do not save to fast to avoid network trouble.
                    await Task.Delay(DelayConfig.SaveImageDelay);
                }

                if (DebugMode)
                {
                    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                    var fileName = "9" + _pageIndex.ToString("D5") + _examIndexInPage.ToString("D3") + ".jpg";
                    SaveDebugSnapshot(fileName, imageData);
                }

                //Get patient info
                //var patientName = "";
                var patientSex = "";
                var patientAge = 0;
                //var examDate = DateTime.Now;

                var report = await GetReportAsync(page);

                //Save exam.
                var exam = new Exam()
                {
                    Id = examId,
                    PatientName = "",
                    PatientSex = patientSex,
                    PatientAge = patientAge,
                    ExamDate = DateTime.Now,
                    Report = report,
                    BatchTaskId = _batchTaskId,
                    ExamIndex = _examIndex,
                    PageIndex = _pageIndex,
                    ExamIndexInPage = _examIndexInPage,
                    CreateTime = DateTime.Now
                };
                _examStore.AddExam(exam);

                //Back to examl list page.
                await ExitExamAsync(page);

                if (DebugMode)
                {
                    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
                    var fileName = "9" + _pageIndex.ToString("D5") + "999.jpg";
                    SaveDebugSnapshot(fileName, imageData);
                }
            }
            return inputs;
        }
    }
}