500 lines
19 KiB
Python
Executable File
500 lines
19 KiB
Python
Executable File
"""
|
|
FileCabinet CS - Batch Export Automation (Step 2)
|
|
=================================================
|
|
Reads a list of drawer IDs from a file, then for each drawer:
|
|
1. Navigates to it in the main window (type ID -> Go)
|
|
2. Opens File > Send To > File
|
|
3. Clicks "Select ->" (grabs all documents via the tree root)
|
|
4. Clicks OK
|
|
5. Waits for the "Exporting Documents" progress dialog to appear and finish
|
|
6. Logs success/failure and moves to the next drawer
|
|
|
|
Key safety features:
|
|
- RESUME: completed drawer IDs are appended to a progress log. On restart,
|
|
already-completed drawers are skipped. A multi-hour run that dies partway
|
|
can simply be re-run and it picks up where it left off.
|
|
- LOGGING: every action and error is timestamped to a log file.
|
|
- DEFENSIVE: unexpected states are caught, logged, screenshotted, and the
|
|
run continues with the next drawer rather than crashing.
|
|
|
|
PREREQUISITES:
|
|
- Run from 32-bit Python (matches FileCabinet CS's architecture)
|
|
- FileCabinet CS already open, pointed at the correct data location
|
|
- Export options/checkboxes and destination already set MANUALLY once
|
|
(they persist between exports within a session)
|
|
- Neither FileCabinet nor this script running elevated (they must match)
|
|
"""
|
|
|
|
import time
|
|
import sys
|
|
import os
|
|
|
|
from pywinauto import Desktop, Application
|
|
from pywinauto import timings
|
|
|
|
from fccs_config import parse_args, load_config, make_logger, load_lines
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# HELPERS
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def load_completed(path):
|
|
"""Read the set of already-completed drawer IDs for resume support."""
|
|
if not os.path.exists(path):
|
|
return set()
|
|
with open(path, "r", encoding="utf-8") as f:
|
|
return {line.strip() for line in f if line.strip()}
|
|
|
|
|
|
def mark_completed(path, drawer_id):
|
|
"""Append a drawer ID to the completed log (resume tracking)."""
|
|
with open(path, "a", encoding="utf-8") as f:
|
|
f.write(drawer_id + "\n")
|
|
|
|
|
|
def take_screenshot(window, drawer_id, tag, screenshot_dir, log):
|
|
"""Save a screenshot of a window for later diagnosis of a failure."""
|
|
from datetime import datetime
|
|
try:
|
|
os.makedirs(screenshot_dir, exist_ok=True)
|
|
fname = os.path.join(
|
|
screenshot_dir,
|
|
f"{drawer_id}_{tag}_{datetime.now():%Y%m%d_%H%M%S}.png"
|
|
)
|
|
window.capture_as_image().save(fname)
|
|
log(f" Screenshot saved: {fname}")
|
|
except Exception as e:
|
|
log(f" Could not capture screenshot: {e}")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# CONNECTION
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def connect_main(ctrl, log):
|
|
"""Find and connect to the running FileCabinet CS main window."""
|
|
target = None
|
|
for w in Desktop(backend="win32").windows():
|
|
if w.class_name() == ctrl["main_class"]:
|
|
target = w
|
|
break
|
|
if target is None:
|
|
log("ERROR: FileCabinet CS window not found. Is it open?")
|
|
sys.exit(1)
|
|
|
|
app = Application(backend="win32").connect(handle=target.handle)
|
|
main = app.window(handle=target.handle)
|
|
log(f"Connected to: {main.window_text()}")
|
|
return app, main
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# PER-DRAWER EXPORT
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def find_search_box(main, ctrl, timeouts, log):
|
|
"""Locate the drawer search box reliably using the Go button as an anchor.
|
|
|
|
The main window has several Edit controls (notably the data-location box
|
|
inside a ComboBox). Their best_match names ("Edit", "Edit0"...) are
|
|
unstable and the placeholder title only exists in a fresh session, so we
|
|
anchor off the Go button instead: the search box sits on the same row
|
|
(same top Y) as Go, immediately to its left. Call once before the drawer
|
|
loop — the returned wrapper stays valid for the window's lifetime.
|
|
"""
|
|
go = main.child_window(title=ctrl["go_button_title"], class_name="Button")
|
|
go.wait("visible ready", timeout=timeouts["nav"])
|
|
go_rect = go.rectangle()
|
|
|
|
edits = main.children(class_name="Edit")
|
|
if not edits:
|
|
edits = main.descendants(class_name="Edit")
|
|
|
|
tolerance = 10
|
|
candidates = [
|
|
e for e in edits
|
|
if abs(e.rectangle().top - go_rect.top) <= tolerance
|
|
]
|
|
if not candidates:
|
|
raise RuntimeError(
|
|
"Could not find the drawer search box (no Edit control on the "
|
|
"Go button's row). FCCS may not be on the main drawer view."
|
|
)
|
|
|
|
# If several share the row, pick the one whose right edge is closest to
|
|
# (and left of) the Go button — that's the box directly beside Go.
|
|
left_of_go = [e for e in candidates if e.rectangle().right <= go_rect.left]
|
|
pool = left_of_go if left_of_go else candidates
|
|
box = max(pool, key=lambda e: e.rectangle().right)
|
|
|
|
r = box.rectangle()
|
|
log(f" Search box located at {(r.left, r.top, r.right, r.bottom)} "
|
|
f"(Go button top={go_rect.top})")
|
|
return box
|
|
|
|
|
|
def navigate_to_drawer(main, search_box, drawer_id, ctrl, timeouts, log):
|
|
"""Type the drawer ID into the search box and click Go."""
|
|
# search_box is a control wrapper (from find_search_box), not a
|
|
# WindowSpecification, so it has no .wait() — it was already confirmed
|
|
# present/visible when located. set_edit_text works directly on it.
|
|
search_box.set_edit_text("")
|
|
search_box.set_edit_text(drawer_id)
|
|
time.sleep(timeouts["settle"])
|
|
|
|
main.child_window(title=ctrl["go_button_title"], class_name="Button").click()
|
|
|
|
deadline = time.time() + timeouts["nav"]
|
|
# Whatever drawer your are actively on becomes the actual name of the App Window. We are checking that again to make sure we found the drawer.
|
|
while time.time() < deadline:
|
|
title = main.window_text()
|
|
if f"[{drawer_id}" in title:
|
|
log(f" Navigated to drawer {drawer_id}: {title}")
|
|
return True
|
|
time.sleep(0.3)
|
|
|
|
log(f" WARNING: window title did not confirm drawer {drawer_id} "
|
|
f"(title is: {main.window_text()!r})")
|
|
return False
|
|
|
|
|
|
def open_send_to_file(main, app, ctrl, timeouts):
|
|
"""Open File > Send To > File and return the dialog window object."""
|
|
main.menu_select("File->Send To->File")
|
|
|
|
dlg = app.window(title=ctrl["dialog_title"], class_name=ctrl["dialog_class"])
|
|
dlg.wait("visible ready", timeout=timeouts["dialog"])
|
|
return dlg
|
|
|
|
|
|
def read_manifest(dlg, drawer_id, log):
|
|
"""Read the selected documents from the ListView into clean rows.
|
|
|
|
The ListView (`List1`) has columns Drawer ID, Page Title (the document
|
|
name) and Application. `texts()` returns a flat, row-major dump led by the
|
|
control's own name ('List1'), which is why the raw capture looked messy.
|
|
|
|
This parses it into one row per document and drops the redundant Drawer ID
|
|
column (always equal to drawer_id) and any empty columns, leaving the
|
|
document name (and Application) per line. Returns a list of rows (each a
|
|
list of cell strings), [] if empty, or None if it couldn't be read.
|
|
"""
|
|
try:
|
|
lv = dlg.child_window(title="List1", class_name="SysListView32")
|
|
n_rows = lv.item_count()
|
|
except Exception as e:
|
|
log(f" WARNING: could not read manifest list: {e}")
|
|
return None
|
|
|
|
if n_rows == 0:
|
|
log(" WARNING: ListView is empty after Select")
|
|
return []
|
|
|
|
try:
|
|
n_cols = lv.column_count()
|
|
except Exception:
|
|
n_cols = 0
|
|
if not n_cols or n_cols < 1:
|
|
n_cols = 3 # observed columns: Drawer ID, Page Title, Application
|
|
|
|
# Read every cell. Primary: get_item(row, col). Fallback: reshape texts().
|
|
try:
|
|
grid = [[lv.get_item(r, c).text() for c in range(n_cols)]
|
|
for r in range(n_rows)]
|
|
except Exception as e:
|
|
log(f" NOTE: get_item failed ({e}); falling back to texts().")
|
|
raw = lv.texts()
|
|
if raw and raw[0] == lv.window_text():
|
|
raw = raw[1:] # drop the control's own name ('List1')
|
|
grid = [raw[i:i + n_cols] for i in range(0, len(raw), n_cols)]
|
|
grid = [row for row in grid if len(row) == n_cols]
|
|
|
|
# Keep only columns that carry real, non-redundant info.
|
|
keep_cols = []
|
|
for c in range(n_cols):
|
|
vals = [(row[c].strip() if c < len(row) else "") for row in grid]
|
|
if all(v == drawer_id for v in vals):
|
|
continue # redundant Drawer ID column
|
|
if all(v == "" for v in vals):
|
|
continue # empty column
|
|
keep_cols.append(c)
|
|
|
|
rows = [[(row[c] if c < len(row) else "") for c in keep_cols]
|
|
for row in grid]
|
|
log(f" Manifest captured: {len(rows)} documents selected")
|
|
return rows
|
|
|
|
|
|
def save_manifest(drawer_id, items, manifest_dir, log):
|
|
"""Save the list of expected export items to a manifest file."""
|
|
os.makedirs(manifest_dir, exist_ok=True)
|
|
path = os.path.join(manifest_dir, f"{drawer_id}.txt")
|
|
with open(path, "w", encoding="utf-8") as f:
|
|
for row in items:
|
|
if isinstance(row, (list, tuple)):
|
|
f.write("\t".join(str(c) for c in row) + "\n")
|
|
else:
|
|
f.write(str(row) + "\n")
|
|
log(f" Manifest saved: {path}")
|
|
|
|
|
|
def perform_export(dlg, drawer_id, ctrl, timeouts, log):
|
|
"""Click Select -> then OK to start the export. Returns manifest rows."""
|
|
select_btn = dlg.child_window(title=ctrl["select_btn_title"], class_name="Button")
|
|
select_btn.wait("visible ready enabled", timeout=timeouts["dialog"])
|
|
select_btn.click()
|
|
|
|
ok_btn = dlg.child_window(title=ctrl["ok_btn_title"], class_name="Button")
|
|
ok_btn.wait("visible ready enabled", timeout=timeouts["select"])
|
|
|
|
manifest = read_manifest(dlg, drawer_id, log)
|
|
|
|
ok_btn.click()
|
|
return manifest
|
|
|
|
|
|
def dismiss_any_dialog(app, ctrl, log):
|
|
"""Try to find and dismiss any stale dialogs left from a previous failure."""
|
|
# Dismiss "Send to" file saved confirmation dialog (OK)
|
|
w = _find_desktop_dialog(ctrl["saved_title"])
|
|
if w:
|
|
try:
|
|
_click_dialog_button(w, "OK", log)
|
|
log(" Dismissed stale confirmation dialog.")
|
|
except Exception:
|
|
pass
|
|
|
|
# Dismiss Send To File Location dialog (Cancel)
|
|
w = _find_desktop_dialog(ctrl["dialog_title"])
|
|
if w:
|
|
try:
|
|
_click_dialog_button(w, "Cancel", log)
|
|
log(" Dismissed stale Send To File dialog.")
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def _find_desktop_dialog(title_match):
|
|
"""Search all top-level windows for a visible #32770 dialog matching title."""
|
|
for w in Desktop(backend="win32").windows():
|
|
try:
|
|
if w.class_name() == "#32770" and w.is_visible() and title_match in w.window_text():
|
|
return w
|
|
except Exception:
|
|
continue
|
|
return None
|
|
|
|
|
|
def _click_dialog_button(dialog, button_title, log):
|
|
"""Connect to a desktop dialog and click a button on it."""
|
|
app = Application(backend="win32").connect(handle=dialog.handle)
|
|
dlg = app.window(handle=dialog.handle)
|
|
dlg.child_window(title=button_title, class_name="Button").click()
|
|
dlg.wait_not("visible", timeout=10)
|
|
|
|
|
|
def wait_for_export(app, ctrl, timeouts, log):
|
|
"""
|
|
Wait for the full export lifecycle to complete:
|
|
1. 'Exporting Documents' progress dialog appears (export running)
|
|
2. Poll until '"Send to" file saved' confirmation dialog appears
|
|
3. Click OK to dismiss it
|
|
"""
|
|
progress = app.window(title=ctrl["progress_title"], class_name=ctrl["progress_class"])
|
|
|
|
try:
|
|
progress.wait("visible", timeout=timeouts["progress_appear"])
|
|
log(" Export in progress...")
|
|
except timings.TimeoutError:
|
|
log(" NOTE: progress dialog not seen; checking for confirmation dialog "
|
|
"(drawer may have exported very quickly).")
|
|
|
|
# Poll the entire desktop for the confirmation dialog.
|
|
# app.window() can miss it — the dialog may not be owned by the app.
|
|
# Use the exact saved_title to avoid matching the "Send To File Location" dialog.
|
|
deadline = time.time() + timeouts["progress_finish"]
|
|
saved_win = None
|
|
while time.time() < deadline:
|
|
saved_win = _find_desktop_dialog(ctrl["saved_title"])
|
|
if saved_win is not None:
|
|
break
|
|
time.sleep(2)
|
|
|
|
if saved_win is None:
|
|
log(f" ERROR: confirmation dialog never appeared within {timeouts['progress_finish']}s.")
|
|
return False
|
|
|
|
log(f" Confirmation dialog found: {saved_win.window_text()!r}")
|
|
|
|
try:
|
|
_click_dialog_button(saved_win, "OK", log)
|
|
log(" Confirmation dismissed.")
|
|
except Exception as e:
|
|
log(f" WARNING: could not dismiss confirmation dialog: {e}")
|
|
log(" Export succeeded but dialog remains — will be dismissed next iteration.")
|
|
|
|
log(" Export complete.")
|
|
return True
|
|
|
|
|
|
def export_drawer(app, main, search_box, drawer_id, ctrl, timeouts,
|
|
screenshot_dir, manifest_dir, log):
|
|
"""Full per-drawer sequence. Returns True on success."""
|
|
log(f"Drawer {drawer_id}: starting")
|
|
|
|
# 0. Dismiss any stale dialogs left from a previous failure
|
|
dismiss_any_dialog(app, ctrl, log)
|
|
|
|
# 1. Navigate
|
|
if not navigate_to_drawer(main, search_box, drawer_id, ctrl, timeouts, log):
|
|
take_screenshot(main, drawer_id, "nav_fail", screenshot_dir, log)
|
|
return False
|
|
|
|
# 2. Open Send To File dialog
|
|
try:
|
|
dlg = open_send_to_file(main, app, ctrl, timeouts)
|
|
except Exception as e:
|
|
log(f" ERROR opening Send To File dialog: {e}")
|
|
take_screenshot(main, drawer_id, "dialog_fail", screenshot_dir, log)
|
|
return False
|
|
|
|
# 3 & 4. Select -> and OK (captures manifest before clicking OK)
|
|
try:
|
|
manifest = perform_export(dlg, drawer_id, ctrl, timeouts, log)
|
|
if manifest is not None:
|
|
save_manifest(drawer_id, manifest, manifest_dir, log)
|
|
except Exception as e:
|
|
log(f" ERROR during export selection: {e}")
|
|
take_screenshot(dlg, drawer_id, "export_fail", screenshot_dir, log)
|
|
try:
|
|
dlg.child_window(title="Cancel", class_name="Button").click()
|
|
except Exception:
|
|
pass
|
|
return False
|
|
|
|
# 5. Monitor progress
|
|
ok = wait_for_export(app, ctrl, timeouts, log)
|
|
if not ok:
|
|
take_screenshot(main, drawer_id, "progress_fail", screenshot_dir, log)
|
|
return False
|
|
|
|
time.sleep(timeouts["settle"])
|
|
return True
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# MAIN LOOP
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def main():
|
|
args = parse_args()
|
|
cfg = load_config(args.config)
|
|
log = make_logger(cfg.get("paths", "log_file"))
|
|
|
|
# Build lookup dicts from config
|
|
paths = {
|
|
"drawer_id_file": cfg.get("paths", "drawer_id_file"),
|
|
"completed_file": cfg.get("paths", "completed_file"),
|
|
"ignore_file": cfg.get("paths", "ignore_file"),
|
|
"screenshot_dir": cfg.get("paths", "screenshot_dir"),
|
|
"manifest_dir": cfg.get("paths", "manifest_dir"),
|
|
}
|
|
timeouts = {
|
|
"nav": cfg.getfloat("timeouts", "nav_timeout"),
|
|
"dialog": cfg.getfloat("timeouts", "dialog_timeout"),
|
|
"select": cfg.getfloat("timeouts", "select_timeout"),
|
|
"progress_appear": cfg.getfloat("timeouts", "progress_appear"),
|
|
"progress_finish": cfg.getfloat("timeouts", "progress_finish"),
|
|
"settle": cfg.getfloat("timeouts", "settle"),
|
|
"confirm": cfg.getfloat("timeouts", "confirm_timeout"),
|
|
}
|
|
ctrl = {
|
|
"main_class": cfg.get("controls", "main_class"),
|
|
"drawer_box_title": cfg.get("controls", "drawer_box_title"),
|
|
"go_button_title": cfg.get("controls", "go_button_title"),
|
|
"dialog_title": cfg.get("controls", "dialog_title"),
|
|
"dialog_class": cfg.get("controls", "dialog_class"),
|
|
"select_btn_title": cfg.get("controls", "select_btn_title"),
|
|
"ok_btn_title": cfg.get("controls", "ok_btn_title"),
|
|
"progress_title": cfg.get("controls", "progress_title"),
|
|
"progress_class": cfg.get("controls", "progress_class"),
|
|
"saved_title": cfg.get("controls", "saved_title"),
|
|
"saved_class": cfg.get("controls", "saved_class"),
|
|
"saved_ok_title": cfg.get("controls", "saved_ok_title"),
|
|
}
|
|
|
|
log("=" * 60)
|
|
log("FileCabinet CS batch export - run starting")
|
|
log("=" * 60)
|
|
|
|
all_ids = load_lines(paths["drawer_id_file"])
|
|
if not all_ids:
|
|
log(f"ERROR: no drawer IDs found in {paths['drawer_id_file']}")
|
|
sys.exit(1)
|
|
|
|
completed = load_completed(paths["completed_file"])
|
|
ignored = set(load_lines(paths["ignore_file"]))
|
|
|
|
pending = [d for d in all_ids if d not in completed and d not in ignored]
|
|
log(f"Total drawers in list : {len(all_ids)}")
|
|
log(f"Already completed : {len(completed)}")
|
|
log(f"Ignored (skipped) : {len(ignored & set(all_ids))}")
|
|
log(f"Remaining to process : {len(pending)}")
|
|
|
|
if not pending:
|
|
log("Nothing to do - all drawers already completed.")
|
|
return
|
|
|
|
app, main_win = connect_main(ctrl, log)
|
|
|
|
try:
|
|
search_box = find_search_box(main_win, ctrl, timeouts, log)
|
|
except Exception as e:
|
|
log(f"ERROR: {e}")
|
|
sys.exit(1)
|
|
|
|
success_count = 0
|
|
fail_count = 0
|
|
failed_ids = []
|
|
|
|
for i, drawer_id in enumerate(pending, start=1):
|
|
log(f"--- [{i}/{len(pending)}] Drawer {drawer_id} ---")
|
|
try:
|
|
ok = export_drawer(app, main_win, search_box, drawer_id, ctrl,
|
|
timeouts, paths["screenshot_dir"],
|
|
paths["manifest_dir"], log)
|
|
except Exception as e:
|
|
log(f" UNEXPECTED ERROR on drawer {drawer_id}: {e}")
|
|
try:
|
|
take_screenshot(main_win, drawer_id, "unexpected",
|
|
paths["screenshot_dir"], log)
|
|
except Exception:
|
|
pass
|
|
ok = False
|
|
|
|
if ok:
|
|
mark_completed(paths["completed_file"], drawer_id)
|
|
success_count += 1
|
|
log(f" Drawer {drawer_id} DONE ({success_count} ok / "
|
|
f"{fail_count} failed so far)")
|
|
else:
|
|
fail_count += 1
|
|
failed_ids.append(drawer_id)
|
|
log(f" Drawer {drawer_id} FAILED - will NOT be marked complete. "
|
|
f"Re-run later to retry.")
|
|
|
|
log("=" * 60)
|
|
log("Run finished.")
|
|
log(f" Succeeded : {success_count}")
|
|
log(f" Failed : {fail_count}")
|
|
if failed_ids:
|
|
log(f" Failed drawer IDs: {', '.join(failed_ids)}")
|
|
log(" These were NOT marked complete; re-running the script "
|
|
"will retry them.")
|
|
log("=" * 60)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|