feat(claimSubmit) - wait fix 2

apps/SeleniumService/selenium_claimStatusCheckWorker.py

@@ -121,28 +121,32 @@ class AutomationMassHealthClaimStatusCheck:
     def step2(self):
         try:
             # Wait until page is fully loaded
-            WebDriverWait(self.driver, 30).until(
+            try:
-                lambda d: d.execute_script("return document.readyState") == "complete"
+                WebDriverWait(self.driver, 30).until(
-            )
+                    lambda d: d.execute_script("return document.readyState") == "complete"
-            # Small buffer for async content/lazy load
+                )
-            time.sleep(2)
+            except Exception:
+                # proceed anyway if not perfect
+                print("Warning: document.readyState did not become 'complete' within timeout")
 
             # ---- Take full page screenshot ----
             screenshot_path = os.path.join(self.download_dir, f"ss_{self.memberId}.png")
 
-            # JS to get sizes
+            # Get sizes and devicePixelRatio (DPR)
-            total_width = self.driver.execute_script("return Math.max(document.body.scrollWidth, document.documentElement.scrollWidth, document.documentElement.clientWidth);")
+            total_width = int(self.driver.execute_script(
-            total_height = self.driver.execute_script("return Math.max(document.body.scrollHeight, document.documentElement.scrollHeight, document.documentElement.clientHeight);")
+                "return Math.max(document.body.scrollWidth, document.documentElement.scrollWidth, document.documentElement.clientWidth);"
-            viewport_width = self.driver.execute_script("return document.documentElement.clientWidth;")
+            ))
-            viewport_height = self.driver.execute_script("return window.innerHeight;")
+            total_height = int(self.driver.execute_script(
+                "return Math.max(document.body.scrollHeight, document.documentElement.scrollHeight, document.documentElement.clientHeight);"
+            ))
+            viewport_width = int(self.driver.execute_script("return document.documentElement.clientWidth;"))
+            viewport_height = int(self.driver.execute_script("return window.innerHeight;"))
+            dpr = float(self.driver.execute_script("return window.devicePixelRatio || 1;"))
 
-            # Ensure integers
+            # Debug print
-            total_width = int(total_width)
+            print(f"total: {total_width}x{total_height}, viewport: {viewport_width}x{viewport_height}, dpr: {dpr}")
-            total_height = int(total_height)
+            
-            viewport_width = int(viewport_width)
+             # Build slice rectangles in CSS pixels
-            viewport_height = int(viewport_height)
-
-            # number of vertical steps
             rectangles = []
             y = 0
             while y < total_height:
@@ -152,35 +156,88 @@ class AutomationMassHealthClaimStatusCheck:
                 y += viewport_height
 
             stitched_image = Image.new('RGB', (total_width, total_height))
-            stitched_y = 0
+
 
             for idx, rect in enumerate(rectangles):
                 scroll_y = rect[1]
-                # Scroll to the position (do not trigger reload)
+                # Scroll to target Y and wait until pageYOffset is near target
                 self.driver.execute_script(f"window.scrollTo(0, {scroll_y});")
-                # Allow time for lazy content to load after scroll (tweak if needed)
-                time.sleep(1.5)
 
+                # Wait until the browser actually reports the desired scroll position (with a tolerance)
+                max_wait = 5.0
+                start = time.time()
+                while time.time() - start < max_wait:
+                    try:
+                        cur = int(self.driver.execute_script("return Math.round(window.pageYOffset || window.scrollY || 0);"))
+                    except Exception:
+                        cur = -1
+                    # Accept small differences due to rounding / subpixel scrolling
+                    if abs(cur - scroll_y) <= 2:
+                        break
+                    time.sleep(0.05)
+                else:
+                    # timed out waiting for scroll to finish - print but continue
+                    print(f"Warning: scroll to {scroll_y} didn't reach expected offset (got {cur})")
+
+                # Small buffer to let lazy content for this slice load (tweak if needed)
+                time.sleep(0.6)
+
+                
                 # capture viewport screenshot as PNG bytes
-                png = self.driver.get_screenshot_as_png()  # returns bytes
+                png = self.driver.get_screenshot_as_png()
-                img = Image.open(BytesIO(png))
+                img = Image.open(BytesIO(png)).convert("RGB")
 
-                # If full page width > viewport width (rare), optionally resize/crop:
+                # The captured PNG width/height are in *device pixels* (scaled by dpr).
-                if img.width != total_width:
+                # Compute crop box in device pixels.
-                    # Try to crop or expand: prefer cropping center horizontally
+                css_viewport_w = viewport_width
-                    img = img.crop((0, 0, total_width, img.height))
+                css_viewport_h = viewport_height
+                dev_viewport_w = int(round(css_viewport_w * dpr))
+                dev_viewport_h = int(round(css_viewport_h * dpr))
 
-                # Compute paste height (might be partial for last slice)
+                # If captured image dimensions differ from expected device viewport,
-                paste_height = rect[3] - rect[1]  # rect bottom - rect top
+                # try to adjust (some platforms include browser chrome etc.). We'll compute offsets intelligently.
-                # If captured image has same viewport height, we may need to crop to paste_height
+                cap_w, cap_h = img.width, img.height
-                if img.height > paste_height:
-                    img = img.crop((0, 0, img.width, paste_height))
 
-                stitched_image.paste(img, (0, rect[1]))
+                # If cap_h > dev_viewport_h (e.g., when headless gives larger image),
+                # center vertically or just use top-left crop of size dev_viewport_h.
+                crop_left = 0
+                crop_top = 0
+                crop_right = min(cap_w, dev_viewport_w)
+                crop_bottom = min(cap_h, dev_viewport_h)
 
-            # Save stitched image
+                # Defensive: if screenshot is smaller than expected, adjust crop sizes
+                if crop_right <= crop_left or crop_bottom <= crop_top:
+                    print("Captured image smaller than expected viewport; using full captured image.")
+                    crop_left, crop_top, crop_right, crop_bottom = 0, 0, cap_w, cap_h
+
+                cropped = img.crop((crop_left, crop_top, crop_right, crop_bottom))
+
+                # Convert back to CSS pixels for paste: compute paste height based on rect height
+                paste_height_css = rect[3] - rect[1]  # CSS pixels
+                # The cropped image height in CSS pixels:
+                cropped_css_height = int(round(cropped.height / dpr))
+
+                # If the cropped CSS height is larger than required (last slice), crop it in CSS space
+                if cropped_css_height > paste_height_css:
+                    # compute pixels to keep in device pixels
+                    keep_dev_h = int(round(paste_height_css * dpr))
+                    cropped = cropped.crop((0, 0, cropped.width, keep_dev_h))
+                    cropped_css_height = paste_height_css
+
+                # Convert cropped (device pixels) back to image suitable for pasting:
+                # For pasting into stitched_image we need CSS-pixel sized image.
+                # Resize from device pixels to CSS pixels if DPR != 1
+                if dpr != 1.0:
+                    target_w = int(round(cropped.width / dpr))
+                    target_h = int(round(cropped.height / dpr))
+                    cropped = cropped.resize((target_w, target_h), Image.LANCZOS)
+
+                # Paste at the correct vertical CSS pixel position
+                paste_y = rect[1]
+                stitched_image.paste(cropped, (0, paste_y))
+
+            # Save final stitched image
             stitched_image.save(screenshot_path)
-
             print("Screenshot saved at:", screenshot_path)
 
             return {