Update code for nanjing tongren

StationProbe/DelayConfig.cs

@@ -2,7 +2,9 @@
 {
     internal class DelayConfig
     {
-        public const int JumpDelay = 500;
+        public const int JumpDelay = 10000;
+
+        public const int FilterDelay = 15000;
 
         public const int SaveImageDelay = 1000;
 

StationProbe/ProbeTask.cs

@@ -1,4 +1,6 @@
 using PuppeteerSharp;
+using System.Text.Encodings.Web;
+using System.Text.Json;
 
 namespace StationProbe
 {
@@ -21,7 +23,7 @@ namespace StationProbe
     {
         private readonly Dictionary<ElementType, object> _objects = new();
 
-        public object this[ElementType type] => _objects[type];
+        public object this[ElementType type] { get { return _objects[type]; } set { _objects[type] = value; } }
 
         public void AddObject(ElementType element, object obj)
         {
@@ -29,7 +31,7 @@ namespace StationProbe
         }
     }
 
-    internal interface IExamStore:IDisposable
+    internal interface IExamStore : IDisposable
     {
         Exam? GetLastExam(int batchTaskId);
         void AddExam(Exam exam);
@@ -53,20 +55,23 @@ namespace StationProbe
 
         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))
+            if (DebugMode)
             {
-                Directory.CreateDirectory(debugFolder);
-            }
-            var i = 1;
-            while (Directory.Exists(Path.Combine(debugFolder, i.ToString("D6"))))
-            {
-                i++;
+                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);
             }
-            _debugFolder = Path.Combine(debugFolder, i.ToString("D6"));
-            Directory.CreateDirectory(_debugFolder);
         }
 
         public void SaveDebugSnapshot(string name, byte[] imageData)
@@ -104,11 +109,17 @@ namespace StationProbe
                     SaveDebugSnapshot(fileName, imageData);
                 }
 
+                //await using (var userElement = await page.WaitForSelectorAsync("xpath///input[@id=\"userName\"]"))
+                //{
+                //    await userElement.FocusAsync();
+                //    await page.Keyboard.TypeAsync("justin.xing");
+                //}
+
                 //username
-                await using (var userElement = await page.WaitForSelectorAsync("input[id=\"userName\"]"))
+                await using (var userElement = await page.WaitForSelectorAsync("input[name=\"username\"]"))
                 {
                     await userElement.FocusAsync();
-                    await page.Keyboard.TypeAsync("justin.xing");
+                    await page.Keyboard.TypeAsync("1158");
                 }
 
                 if (DebugMode)
@@ -119,10 +130,10 @@ namespace StationProbe
                 }
 
                 //password
-                await using (var passwordElement = await page.WaitForSelectorAsync("input[id=\"password\"]"))
+                await using (var passwordElement = await page.WaitForSelectorAsync("input[name=\"userpass\"]"))
                 {
                     await passwordElement.FocusAsync();
-                    await page.Keyboard.TypeAsync("vinno@123");
+                    await page.Keyboard.TypeAsync("321321");
                 }
 
                 if (DebugMode)
@@ -133,7 +144,7 @@ namespace StationProbe
                 }
 
                 //login
-                await using (var loginButtonElement = await page.WaitForSelectorAsync("button[b-kvd270uhz9]"))
+                await using (var loginButtonElement = await page.WaitForSelectorAsync("img[name=\"inputcode\"]"))
                 {
                     await loginButtonElement.ClickAsync();
                     await page.WaitForNetworkIdleAsync();
@@ -162,17 +173,7 @@ namespace StationProbe
             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);
-                    }
-                }
-
+                await page.GoToAsync("http://192.168.200.85:8080/superimage/front/patientviewQue.jsp");
             }
             return inputs;
         }
@@ -196,375 +197,343 @@ namespace StationProbe
         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) 
+            if (page != 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 queryLink = await page.WaitForSelectorAsync("span[class=\"link_quedetail\"]"))
                 {
-                    await using (var examCountElement = await pageinationElement.QuerySelectorAsync("div[class=\"d-none d-sm-inline-block\"]"))
+                    await queryLink.ClickAsync();
+                    await using (var startInputElement = await page.WaitForSelectorAsync("input[name=\"que_startdate\"]"))
                     {
-                        var examCountStr = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", examCountElement);
-                        var words = examCountStr.Split(' ');
-                        ExamCount = int.Parse(words[1]);
+                        await startInputElement.FocusAsync();
+                        await page.Keyboard.TypeAsync(_start.ToString("yyyy-MM-dd"));
                     }
-
-                }
-
-                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"))
+                    await using (var endInputElement = await page.WaitForSelectorAsync("input[name=\"que_enddate\"]"))
                     {
-                        var lastPageStr = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", textElement);
-                        PageCount = int.Parse(lastPageStr);
+                        await endInputElement.FocusAsync();
+                        await page.Keyboard.TypeAsync(_end.ToString("yyyy-MM-dd"));
                     }
-                    foreach (var pageItemElement in pageItemElements)
+                    await using (var queryButtonElement = await page.WaitForSelectorAsync("input[name=\"is.query\"]"))
                     {
-                        await pageItemElement.DisposeAsync();
+                        await queryButtonElement.ClickAsync();
+                        await Task.Delay(DelayConfig.FilterDelay);
                     }
                 }
+
+                await using (var pageTdELement = await page.WaitForSelectorAsync("body > table.tb_page > tbody > tr > td > table > tbody > tr > td:nth-child(1)"))
+                {
+                    var pageStr = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", pageTdELement);
+                    var words = pageStr.Split(' ');
+                    ExamCount = int.Parse(words[1].Trim());
+                    words = pageStr.Split('/');
+                    PageCount = int.Parse(words[1].Trim());
+                }
+
+                //await using (var pageinationElement = await page.QuerySelectorAsync("table[class=\"tb_page\"]"))
+                //{
+
+                //    await using (var tableElement = await pageinationElement.WaitForSelectorAsync("table"))
+                //    {
+                //        var tdElements = await tableElement.QuerySelectorAllAsync("td");
+                //        if (tdElements.Length == 3)
+                //        {
+                //            var pageStr = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", tdElements[0]);
+                //            var words = pageStr.Split(' ');
+                //            ExamCount = int.Parse(words[1].Trim());
+                //            words = pageStr.Split('/');
+                //            PageCount = int.Parse(words[1].Trim());
+                //        }
+                //        foreach (var tdElement in tdElements)
+                //        {
+                //            await tdElement.DisposeAsync();
+                //        }
+                //    }
+                //}
             }
             return inputs;
         }
-    }
 
-    internal class PageTask : ProbeTask
-    {
-        private readonly int _page;
-        public PageTask(IExamStore examStore, int page) : base(examStore)
+        internal class PageTask : ProbeTask
         {
-            _page = page;
-        }
+            private readonly int _pageIndex;
+            public PageTask(IExamStore examStore, int pageIndex) : base(examStore)
+            {
+                _pageIndex = pageIndex;
+            }
 
-        private async Task JumpToPageAsync(IPage page)
-        {
-            while (true)
+            private async Task JumpToPageAsync(IPage page)
             {
-                await using (var pagesElement = await page.WaitForSelectorAsync("ul[class=\"pagination\"]"))
+                await using (var jumpTableELement = await page.WaitForSelectorAsync("body > table.tb_page > tbody > tr > td > table > tbody > tr > td:nth-child(3) > table"))
                 {
-                    var pageItemElements = await pagesElement.QuerySelectorAllAsync("li");
-                    await using (var currentPageElemment = await pagesElement.QuerySelectorAsync("li[class=\"page-item active\"]"))
+                    var jumpTdElements = await jumpTableELement.QuerySelectorAllAsync("td");
+                    if (jumpTdElements.Length == 4)
                     {
-                        await using (var textElement = await currentPageElemment.QuerySelectorAsync("a"))
+                        await using (var jumpInputElement = await jumpTdElements[1].WaitForSelectorAsync("input"))
                         {
-                            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 page.EvaluateFunctionAsync("(element) => element.value=''", jumpInputElement);
+                            await jumpInputElement.FocusAsync();
+                            await page.Keyboard.TypeAsync((_pageIndex + 1).ToString());
+                        }
+                        await using (var jumpButtonElement = await jumpTdElements[3].WaitForSelectorAsync("input"))
+                        {
+
+                            await jumpButtonElement.ClickAsync();
+                            await Task.Delay(DelayConfig.JumpDelay);
                         }
                     }
+                    foreach (var jumpTdElement in jumpTdElements)
+                    {
+                        await jumpTdElement.DisposeAsync();
+                    }
                 }
-                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)
+            public override async Task<ElementCollection> ExecuteAsync(ElementCollection inputs)
             {
-                await JumpToPageAsync(page);
-                if (DebugMode)
+                var page = inputs[ElementType.Page].As<IPage>();
+                if (page != null)
                 {
-                    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
-                    var fileName = "9" + _page.ToString("D5") + "000.jpg";
-                    SaveDebugSnapshot(fileName, imageData);
+                    await JumpToPageAsync(page);
+                    if (DebugMode)
+                    {
+                        var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
+                        var fileName = "9" + _pageIndex.ToString("D5") + "000.jpg";
+                        SaveDebugSnapshot(fileName, imageData);
+                    }
                 }
+                return inputs;
             }
-            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)
+        internal class ExamTask : ProbeTask
         {
-            _batchTaskId = batchTaskId;
-            _pageIndex = pageIndex;
-            _examIndex = examIndex;
-            _examIndexInPage = examIndexInPage;
-        }
+            private static readonly ScreenshotOptions _opt = new ScreenshotOptions() { Type = ScreenshotType.Jpeg, Quality = 90 };
+            private readonly int _batchTaskId;
+            private readonly int _pageIndex;
+            private readonly int _examIndex;
+            private readonly int _examIndexInPage;
 
-        private async Task JumpToPageAsync(IPage page)
-        {
-            while (true)
+            public ExamTask(IExamStore examStore, int batchTaskId, int pageIndex, int examIndex, int examIndexInPage) : base(examStore)
             {
-                await using (var pagesElement = await page.WaitForSelectorAsync("ul[class=\"pagination\"]"))
+                _batchTaskId = batchTaskId;
+                _pageIndex = pageIndex;
+                _examIndex = examIndex;
+                _examIndexInPage = examIndexInPage;
+            }
+
+            private async Task EnterExamAsync(IPage page)
+            {
+                await using (var tableElement = await page.QuerySelectorAsync("table[class=\"tb_main\"]"))
                 {
-                    var pageItemElements = await pagesElement.QuerySelectorAllAsync("li");
-                    await using (var currentPageElemment = await pagesElement.QuerySelectorAsync("li[class=\"page-item active\"]"))
+                    var examRecordElements = await tableElement.QuerySelectorAllAsync("tr");
+                    var examRecordElement = examRecordElements[_examIndexInPage + 1];
+                    var columnElements = await examRecordElement.QuerySelectorAllAsync("td");
+                    var nameColumnElement = columnElements[1];
+                    await using (var linkElement = await nameColumnElement.WaitForSelectorAsync("a"))
                     {
-                        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 linkElement.ClickAsync();
+                    }
+                    foreach (var toDispose in columnElements)
+                    {
+                        await toDispose.DisposeAsync();
+                    }
+                    foreach (var toDispose in examRecordElements)
+                    {
+                        await toDispose.DisposeAsync();
                     }
                 }
-                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\"]"))
+            private async Task ExitExamAsync(IPage page)
             {
-                var examLinkElements = await tableElement.QuerySelectorAllAsync("div[style=\"cursor:pointer;\"]");
-                var eaxmLinkElement = examLinkElements[_examIndexInPage];
-                await eaxmLinkElement.ClickAsync();
-                foreach(var examLinkElement in examLinkElements)
+                //Wait for the back button.
+                await using (var backButtonElement = await page.WaitForSelectorAsync("input[name=\"Submit222\"]"))
                 {
-                    await examLinkElement.DisposeAsync();
+                    await page.EvaluateFunctionAsync("b => b.click()", backButtonElement);
                 }
             }
-        }
 
-        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\"]"))
+            private async Task DoSaveExamImageAsync(IPage page, string examId, int imageIndex, string imageUrl)
             {
-                await page.EvaluateFunctionAsync("b => b.click()", backButtonElement);
+                await using (var imgElement = await page.WaitForSelectorAsync("img"))
+                {
+                    var imageData = await imgElement.ScreenshotDataAsync(_opt);
+                    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. image sieze:{imageData.Length/1024}kb");
+                }
             }
-        }
-
-        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())
+            private async Task SaveExamImageAsync(IPage page, string examId, int imageIndex, string imageUrl)
             {
-                var finishEvent = new ManualResetEvent(false);
-                finishEvent.Reset();
-                DoSaveExamImageAsync(imagePage, examId, imageIndex, imageUrl, finishEvent);
-                await imagePage.GoToAsync(imageUrl);
-                finishEvent.WaitOne();
-                finishEvent.Dispose();
+                await using (var imagePage = await page.Browser.NewPageAsync())
+                {
+                    await imagePage.GoToAsync(imageUrl);
+                    await Task.Delay(DelayConfig.SaveImageDelay);
+                    await DoSaveExamImageAsync(imagePage, examId, imageIndex, imageUrl);
+                }
             }
-        }
 
-        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\"]"))
+            private async Task<List<string>> GetImageUrlsAsync(IPage page)
             {
-                var imageDivElements = await page.QuerySelectorAllAsync("div[class=\"bb-img is-preview\"]");
-                if (imageDivElements != null)
+                //Get all image urls.
+                var imageUrls = new List<string>();
+                await using (var backButtonElement = await page.WaitForSelectorAsync("input[name=\"Submit222\"]"))
                 {
-                    foreach (var imageDivElement in imageDivElements)
+                    await using (var imageTableElement = await page.WaitForSelectorAsync("body > form > table:nth-child(1) > tbody > tr:nth-child(2) > td > table > tbody > tr > td:nth-child(2) > table:nth-child(8)"))
                     {
-                        await using (var imageElement = await imageDivElement.QuerySelectorAsync("img"))
+                        var imageTrs = await imageTableElement.QuerySelectorAllAsync("tr");
+                        if (imageTrs != null)
                         {
-                            await using (var imageUrl = await imageElement.GetPropertyAsync("src"))
+                            foreach (var imageTr in imageTrs)
                             {
-                                var url = await imageUrl.JsonValueAsync<string>();
-                                imageUrls.Add(url);
+                                var linkElements = await imageTr.QuerySelectorAllAsync("a");
+                                foreach (var linkElement in linkElements)
+                                {
+                                    await using (var imageUrl = await linkElement.GetPropertyAsync("href"))
+                                    {
+                                        var url = await imageUrl.JsonValueAsync<string>();
+                                        imageUrls.Add(url);
+                                        await linkElement.DisposeAsync();
+                                    }
+                                }
+                                await imageTr.DisposeAsync();
                             }
                         }
-                        await imageDivElement.DisposeAsync();
                     }
                 }
+                Logger.WriteLine($"Get image url count:{imageUrls.Count}");
+                return imageUrls;
             }
-            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)
+            private async Task<string> GetReportAsync(IPage page)
             {
-                await using (var strong = await reportElement.QuerySelectorAsync("strong"))
+                var reportDic = new Dictionary<string, string>();
+                await using (var partElement = await page.WaitForSelectorAsync("body > form > table:nth-child(1) > tbody > tr:nth-child(2) > td > table > tbody > tr > td:nth-child(2) > table:nth-child(6) > tbody > tr:nth-child(4) > td:nth-child(2)"))
                 {
-                    if (strong != null)
-                    {
-                        var content = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", strong);
-                        report += " " + content;
-                    }
+                    var content = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", partElement);
+                    reportDic.Add("Part", content);
+                }
+                await using (var deviceElement = await page.WaitForSelectorAsync("body > form > table:nth-child(1) > tbody > tr:nth-child(2) > td > table > tbody > tr > td:nth-child(2) > table:nth-child(6) > tbody > tr:nth-child(4) > td:nth-child(4)"))
+                {
+                    var content = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", deviceElement);
+                    reportDic.Add("Device", content);
+                }
+                await using (var conclusionElement = await page.WaitForSelectorAsync("body > form > table:nth-child(1) > tbody > tr:nth-child(2) > td > table > tbody > tr > td:nth-child(2) > table:nth-child(6) > tbody > tr:nth-child(5) > td:nth-child(4)"))
+                {
+                    var content = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", conclusionElement);
+                    reportDic.Add("Conclusion", content);
+                }
+                await using (var summaryElement = await page.WaitForSelectorAsync("body > form > table:nth-child(1) > tbody > tr:nth-child(2) > td > table > tbody > tr > td:nth-child(2) > table:nth-child(6) > tbody > tr:nth-child(6) > td.list_cell_bg"))
+                {
+                    var content = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", summaryElement);
+                    reportDic.Add("Summary", content);
+                }
+                await using (var commentElement = await page.WaitForSelectorAsync("body > form > table:nth-child(1) > tbody > tr:nth-child(2) > td > table > tbody > tr > td:nth-child(2) > table:nth-child(6) > tbody > tr:nth-child(7) > td.list_cell_bg"))
+                {
+                    var content = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", commentElement);
+                    reportDic.Add("Comment", content);
                 }
-                await reportElement.DisposeAsync();
+                var report = JsonSerializer.Serialize(reportDic,new JsonSerializerOptions() { WriteIndented = true, Encoder = JavaScriptEncoder.Create(System.Text.Unicode.UnicodeRanges.All)});
+                Logger.WriteLine($"Get report:{report}");
+                return report;
             }
-            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)
+            public override async Task<ElementCollection> ExecuteAsync(ElementCollection inputs)
             {
-                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++)
+                var page = inputs[ElementType.Page].As<IPage>();
+                //var frame = inputs[ElementType.Frame].As<IFrame>();
+                if (page != null) //&& frame != null)
                 {
-                    await SaveExamImageAsync(page, examId, i, imageUrls[i]);
-                    //Do not save to fast to avoid network trouble.
-                    await Task.Delay(DelayConfig.SaveImageDelay);
-                }
+                    var examId = Guid.NewGuid().ToString("N");
+                    //First time enter exam.
+                    await EnterExamAsync(page);
 
-                if (DebugMode)
-                {
-                    var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
-                    var fileName = "9" + _pageIndex.ToString("D5") + _examIndexInPage.ToString("D3") + ".jpg";
-                    SaveDebugSnapshot(fileName, imageData);
-                }
+                    //wait for page loaded.
+                    await Task.Delay(DelayConfig.ExamContentDelay);
 
-                //Get patient info
-                //var patientName = "";
-                var patientSex = "";
-                var patientAge = 0;
-                //var examDate = DateTime.Now;
+                    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);
+                    }
 
-                var report = await GetReportAsync(page);
+                    if (DebugMode)
+                    {
+                        var imageData = await page.ScreenshotDataAsync(_snapshotOpts);
+                        var fileName = "9" + _pageIndex.ToString("D5") + _examIndexInPage.ToString("D3") + ".jpg";
+                        SaveDebugSnapshot(fileName, imageData);
+                    }
 
-                //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);
+                    //Get patient info
+                    var patientName = "";
+                    await using (var patientNameElement = await page.WaitForSelectorAsync("body > form > table:nth-child(1) > tbody > tr:nth-child(2) > td > table > tbody > tr > td:nth-child(2) > table:nth-child(2) > tbody > tr:nth-child(1) > td:nth-child(2)"))
+                    {
+                        patientName = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", patientNameElement);
+                    }
+                    var patientSex = "";
+                    await using (var patientSexElement = await page.WaitForSelectorAsync("body > form > table:nth-child(1) > tbody > tr:nth-child(2) > td > table > tbody > tr > td:nth-child(2) > table:nth-child(2) > tbody > tr:nth-child(1) > td:nth-child(4)"))
+                    {
+                        patientSex = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", patientSexElement);
+                    }
+
+                    var patientAge = 0;
+                    await using (var patientAgeElement = await page.WaitForSelectorAsync("body > form > table:nth-child(1) > tbody > tr:nth-child(2) > td > table > tbody > tr > td:nth-child(2) > table:nth-child(2) > tbody > tr:nth-child(2) > td:nth-child(2)"))
+                    {
+                        var patientAgeStr = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", patientAgeElement);
+                        var words = patientAgeStr.Split(' ');
+                        if (words.Length == 2)
+                        {
+                             int.TryParse(words[0].Trim(),out patientAge);
+                        }
+                    }
+                    var examDate = DateTime.Now;
+                    await using (var examDateElement = await page.WaitForSelectorAsync("body > form > table:nth-child(1) > tbody > tr:nth-child(2) > td > table > tbody > tr > td:nth-child(2) > table:nth-child(6) > tbody > tr:nth-child(2) > td:nth-child(4)"))
+                    {
+                        var examDateStr = await page.EvaluateFunctionAsync<string>("(element) => element.textContent", examDateElement);
+                        DateTime.TryParse(examDateStr, out examDate);
+                    }
+
+                    var report = await GetReportAsync(page);
+
+                    //Save exam.
+                    var exam = new Exam()
+                    {
+                        Id = examId,
+                        PatientName = patientName,
+                        PatientSex = patientSex,
+                        PatientAge = patientAge,
+                        ExamDate = examDate,
+                        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;
             }
-            return inputs;
         }
     }
 }

StationProbe/Program.cs

@@ -58,7 +58,7 @@ else
                         Width = 1920,
                         Height = 1080
                     });
-                    var superImageTask = new SuperImageTask(batchTask, 10);
+                    var superImageTask = new SuperImageTask(batchTask, 15);
                     await superImageTask.RunAsync(page);
                     error = false;
                 }

StationProbe/SuperImageTask.cs

@@ -1,4 +1,5 @@
 using PuppeteerSharp;
+using static StationProbe.FilterTask;
 
 namespace StationProbe
 {
@@ -52,7 +53,7 @@ namespace StationProbe
         {
             var outputs = new ElementCollection();
             outputs.AddObject(ElementType.Page, page);
-            var url = "http://www.xinglinghui.com:9112/login";//"http://192.168.200.85:8080";
+            var url = "http://192.168.200.85:8080/superimage/login.jsp";
             Logger.WriteLine($"Start login task (url:{url})...");
             try
             {
@@ -119,7 +120,7 @@ namespace StationProbe
                     var currentExamCountinPage = _pageIndex < (_batchTask.PageCount - 1) ? _examCountInPage : (_batchTask.ExamCount - _pageIndex * _examCountInPage);
                     while (_examIndexInPage < currentExamCountinPage)
                     {
-                        Logger.WriteLine($"Start exam task (exam index: {_examIndexInPage})...");
+                        Logger.WriteLine($"Start exam task (exam index: {_examIndexInPage}) in page {_pageIndex}...");
                         try
                         {
                             outputs = await new ExamTask(_examStore, _batchTask.Id, _pageIndex, _examIndex ,_examIndexInPage).ExecuteAsync(outputs);