From 51f532f452e94096a2ff2e806000dbf2648279ab Mon Sep 17 00:00:00 2001 From: Paul Huliganga Date: Fri, 17 Apr 2026 14:47:27 -0400 Subject: [PATCH] feat: idempotent upload + FastAPI web UI with full test coverage MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase 1 — Idempotent upload: - upload_docusign_template.py now upserts: PUT if template with same name exists (most recently modified), POST otherwise - --force-create flag to bypass upsert Phase 2-6 — FastAPI web UI: - web/app.py: FastAPI app with /health, static file serving - web/routers/auth.py: Adobe Sign + DocuSign OAuth start/callback/disconnect - web/routers/templates.py: template listing + migration status badges (not_migrated / migrated / needs_update) - web/routers/migrate.py: POST /api/migrate pipeline + GET /api/migrate/history - web/static/: vanilla HTML/CSS/JS side-by-side template browser UI Phase 7 — Tests (29/29 passing): - test_upload_upsert.py: 4 upsert unit tests - test_api_health/auth/templates/migrate.py: full API coverage - test_e2e.py: 7-step full pipeline end-to-end test - test_regression.py: compose output vs snapshots for 3 real templates - conftest.py: --update-snapshots CLI option Docs: IMPLEMENTATION-PLAN.md, updated EXECUTION-BOARD.md + architecture.md Co-Authored-By: Claude Sonnet 4.6 --- conftest.py | 5 + docs/IMPLEMENTATION-PLAN.md | 267 +++++++++++++++ docs/agent-harness/EXECUTION-BOARD.md | 93 +++++ docs/architecture.md | 28 +- requirements.txt | 12 + src/upload_docusign_template.py | 128 +++++-- .../David Tag Demo Form__CBJCHBCA.json | 322 ++++++++++++++++++ .../fixtures/expected/Rob Test__CBJCHBCA.json | 91 +++++ .../_DEMO USE ONLY_ NDA__CBJCHBCA.json | 108 ++++++ tests/test_api_auth.py | 92 +++++ tests/test_api_health.py | 25 ++ tests/test_api_migrate.py | 239 +++++++++++++ tests/test_api_templates.py | 157 +++++++++ tests/test_e2e.py | 192 +++++++++++ tests/test_regression.py | 129 +++++++ tests/test_upload_upsert.py | 127 +++++++ web/__init__.py | 0 web/app.py | 47 +++ web/config.py | 36 ++ web/routers/__init__.py | 0 web/routers/auth.py | 153 +++++++++ web/routers/migrate.py | 257 ++++++++++++++ web/routers/templates.py | 167 +++++++++ web/session.py | 45 +++ web/static/app.js | 221 ++++++++++++ web/static/index.html | 79 +++++ web/static/style.css | 153 +++++++++ 27 files changed, 3145 insertions(+), 28 deletions(-) create mode 100644 conftest.py create mode 100644 docs/IMPLEMENTATION-PLAN.md create mode 100644 docs/agent-harness/EXECUTION-BOARD.md create mode 100644 tests/fixtures/expected/David Tag Demo Form__CBJCHBCA.json create mode 100644 tests/fixtures/expected/Rob Test__CBJCHBCA.json create mode 100644 tests/fixtures/expected/_DEMO USE ONLY_ NDA__CBJCHBCA.json create mode 100644 tests/test_api_auth.py create mode 100644 tests/test_api_health.py create mode 100644 tests/test_api_migrate.py create mode 100644 tests/test_api_templates.py create mode 100644 tests/test_e2e.py create mode 100644 tests/test_regression.py create mode 100644 tests/test_upload_upsert.py create mode 100644 web/__init__.py create mode 100644 web/app.py create mode 100644 web/config.py create mode 100644 web/routers/__init__.py create mode 100644 web/routers/auth.py create mode 100644 web/routers/migrate.py create mode 100644 web/routers/templates.py create mode 100644 web/session.py create mode 100644 web/static/app.js create mode 100644 web/static/index.html create mode 100644 web/static/style.css diff --git a/conftest.py b/conftest.py new file mode 100644 index 0000000..46dbf4d --- /dev/null +++ b/conftest.py @@ -0,0 +1,5 @@ +def pytest_addoption(parser): + parser.addoption( + "--update-snapshots", action="store_true", default=False, + help="Overwrite regression snapshot files with current compose output" + ) diff --git a/docs/IMPLEMENTATION-PLAN.md b/docs/IMPLEMENTATION-PLAN.md new file mode 100644 index 0000000..be7ae82 --- /dev/null +++ b/docs/IMPLEMENTATION-PLAN.md @@ -0,0 +1,267 @@ +# Implementation Plan — Adobe → DocuSign Migrator v2 + +*Created: 2026-04-17* + +--- + +## Objective + +Extend the CLI migration pipeline with: +1. **Idempotent upload** — update the most recently modified DocuSign template with the same name instead of always creating a new one. +2. **Web UI** — browser-based app that lets users authenticate to both platforms, browse templates side-by-side, and run migrations with live feedback. + +--- + +## Architecture Overview + +``` +adobe-to-docusign-migrator/ +├── src/ # Core pipeline (existing) +│ ├── compose_docusign_template.py +│ ├── upload_docusign_template.py ← Phase 1: upsert logic added +│ ├── adobe_api.py +│ ├── docusign_auth.py +│ └── ... +├── web/ # New — FastAPI web app +│ ├── app.py # FastAPI entrypoint +│ ├── config.py # Env/settings +│ ├── session.py # Session middleware +│ ├── routers/ +│ │ ├── auth.py # Adobe + DocuSign OAuth +│ │ ├── templates.py # Listing + status API +│ │ └── migrate.py # Migration trigger + history +│ └── static/ +│ ├── index.html # Main SPA page +│ ├── app.js # Vanilla JS app +│ └── style.css +├── tests/ +│ ├── test_mapping.py # Existing field-mapping unit tests +│ ├── test_upload_upsert.py # Phase 1: upsert logic +│ ├── test_api_health.py # Phase 2: health endpoint +│ ├── test_api_auth.py # Phase 3: auth endpoints +│ ├── test_api_templates.py # Phase 4: template listing +│ ├── test_api_migrate.py # Phase 5: migration API +│ └── test_e2e.py # Phase 7: full pipeline e2e +└── docs/ + ├── IMPLEMENTATION-PLAN.md ← this file + └── agent-harness/ + └── EXECUTION-BOARD.md +``` + +--- + +## Tech Stack + +| Layer | Choice | Reason | +|---|---|---| +| Backend | FastAPI | Matches existing Python; async; auto-generates OpenAPI docs | +| Sessions | `starlette-sessions` + `itsdangerous` | Lightweight, no DB needed | +| Frontend | Vanilla HTML/CSS/JS | No build tooling; straightforward for this scope | +| Testing | `pytest` + `httpx` + `respx` | FastAPI's recommended test stack; respx for mocking HTTP | +| HTTP mocking | `respx` | Intercepts `httpx` calls for Adobe/DocuSign API mocks | + +--- + +## Phase 1 — Idempotent Upload + +**Goal:** `upload_docusign_template.py` should update the most recently modified DocuSign template with the same name, rather than always creating a new one. + +**Logic:** +1. After loading the template JSON, extract its `name`. +2. Call `GET /v2.1/accounts/{accountId}/templates?search_text={name}` to list matches. +3. Filter to exact name matches; sort by `lastModified` descending; take the first. +4. If found: `PUT /v2.1/accounts/{accountId}/templates/{templateId}` (update). +5. If not found: `POST /v2.1/accounts/{accountId}/templates` (create). +6. Print `Updated template {id}` or `Created template {id}`. +7. Add `--force-create` flag to bypass upsert and always create. + +**Tests (`tests/test_upload_upsert.py`):** +- `test_creates_when_no_match` — no existing templates; POST called. +- `test_updates_most_recent_when_match` — two existing templates with same name; PUT called on newer one. +- `test_force_create_bypasses_upsert` — `--force-create` always POSTs. +- `test_partial_name_match_ignored` — template name contains search term but isn't exact; still creates. + +--- + +## Phase 2 — FastAPI Backend Foundation + +**Goal:** Runnable FastAPI app with health endpoint, env config, and session middleware. + +**Endpoints:** +- `GET /health` → `{"status": "ok", "version": "2.0"}` + +**Tests (`tests/test_api_health.py`):** +- `test_health_returns_200` +- `test_health_response_shape` + +--- + +## Phase 3 — Auth Endpoints + +**Goal:** Users can connect to Adobe Sign and DocuSign from the browser; tokens stored in server-side session. + +**Adobe Sign (OAuth 2.0 Authorization Code):** +- `GET /api/auth/adobe/start` → redirect to Adobe Sign OAuth URL +- `GET /api/auth/adobe/callback?code=...` → exchange code for tokens; store in session +- `GET /api/auth/adobe/disconnect` → clear Adobe tokens from session + +**DocuSign (OAuth 2.0 Authorization Code — demo sandbox):** +- `GET /api/auth/docusign/start` → redirect to DocuSign OAuth URL +- `GET /api/auth/docusign/callback?code=...` → exchange code for tokens; store in session +- `GET /api/auth/docusign/disconnect` → clear DocuSign tokens from session + +**Status:** +- `GET /api/auth/status` → `{"adobe": true/false, "docusign": true/false}` + +**Tests (`tests/test_api_auth.py`):** +- `test_status_unauthenticated` — both false on fresh session. +- `test_adobe_callback_stores_token` — mock token exchange; session updated. +- `test_docusign_callback_stores_token` — same for DocuSign. +- `test_disconnect_clears_token` — after disconnect, status shows false. + +--- + +## Phase 4 — Template Listing API + +**Goal:** Expose Adobe and DocuSign template lists; compute per-template migration status. + +**Endpoints:** +- `GET /api/templates/adobe` → list of Adobe Sign library documents +- `GET /api/templates/docusign` → list of DocuSign templates +- `GET /api/templates/status` → merged view: each Adobe template tagged as: + - `not_migrated` — no DocuSign template with same name + - `migrated` — at least one DocuSign template with exact name match + - `needs_update` — Adobe template modified after the matched DocuSign template + +**Tests (`tests/test_api_templates.py`):** +- `test_adobe_list_requires_auth` — 401 if not authenticated. +- `test_adobe_list_returns_templates` — mock Adobe API; correct shape. +- `test_docusign_list_returns_templates` — mock DocuSign API. +- `test_status_not_migrated` — Adobe template with no DS match → `not_migrated`. +- `test_status_migrated` — name match exists → `migrated`. +- `test_status_needs_update` — Adobe modified after DS template → `needs_update`. + +--- + +## Phase 5 — Migration API + +**Goal:** Trigger migration of selected Adobe templates and retrieve history. + +**Endpoints:** +- `POST /api/migrate` — body: `{"adobe_template_ids": ["id1", "id2"]}` + - Downloads each template, runs `compose_docusign_template.py`, uploads via upsert + - Returns `{"results": [{"adobe_id": "...", "docusign_id": "...", "status": "created|updated|failed", "error": null}]}` +- `GET /api/migrate/history` — reads `migration-output/.history.json`; returns past runs + +**History record schema:** +```json +{ + "timestamp": "2026-04-17T10:30:00Z", + "adobe_template_name": "NDA", + "adobe_template_id": "CBJ...", + "docusign_template_id": "7dfd...", + "action": "created|updated", + "status": "success|failed", + "error": null +} +``` + +**Tests (`tests/test_api_migrate.py`):** +- `test_migrate_requires_auth` — 401 if not authenticated. +- `test_migrate_single_template_creates` — mock Adobe download + DS upload (no existing); returns created. +- `test_migrate_single_template_updates` — mock with existing DS template; returns updated. +- `test_migrate_records_history` — after run, history file updated. +- `test_history_returns_past_runs` — GET history returns written records. +- `test_migrate_handles_partial_failure` — one template fails; others succeed; partial results returned. + +--- + +## Phase 6 — Frontend + +**Goal:** Single-page app served at `/`; no build step. + +**Layout:** +``` +┌─────────────────────────────────────────────────────┐ +│ Adobe Sign → DocuSign Migrator [auth]│ +├───────────────────────┬─────────────────────────────┤ +│ Adobe Sign Templates │ DocuSign Templates │ +│ [connect] │ [connect] │ +│ ───────────────── │ ───────────────────────── │ +│ ● NDA [●] │ ● NDA │ +│ ○ Sales Agmt [○] │ ● David Tag Demo │ +│ ○ Rob Test [○] │ │ +│ │ │ +│ [Migrate Selected] │ │ +└───────────────────────┴─────────────────────────────┘ +``` + +**Status badges:** +- Green dot = Migrated +- Yellow dot = Needs Update +- Red dot = Not Migrated + +**Migrate flow:** +1. User checks templates to migrate. +2. Clicks "Migrate Selected." +3. Progress shown inline per template (spinner → check/error). +4. History section at bottom shows past runs. + +--- + +## Phase 7 — End-to-End & Regression Tests + +**Goal:** Ensure the full pipeline works together and existing behaviour doesn't regress. + +**`tests/test_e2e.py`:** +- `test_full_migration_flow` — using TestClient + respx mocks: + 1. Connect Adobe (mock OAuth callback) + 2. Connect DocuSign (mock OAuth callback) + 3. GET /api/templates/status → at least one `not_migrated` + 4. POST /api/migrate → status `created` + 5. GET /api/templates/status → now `migrated` + 6. POST /api/migrate again → status `updated` + 7. GET /api/migrate/history → two entries + +**`tests/test_regression.py`:** +- Runs `compose_docusign_template.py` on all fixtures in `sample-templates/` +- Validates output against expected JSON snapshots in `tests/fixtures/expected/` +- Any field type regression fails the test +- Run via `pytest tests/test_regression.py` — no live API calls needed + +--- + +## Running Tests + +```bash +# All tests +pytest tests/ -v + +# Unit only (no live API) +pytest tests/ -v -m "not integration" + +# Regression only +pytest tests/test_regression.py -v + +# With coverage +pytest tests/ --cov=src --cov=web --cov-report=term-missing +``` + +--- + +## Dependencies to Add + +``` +fastapi +uvicorn[standard] +starlette-sessions +itsdangerous +httpx +respx +pytest-asyncio +pytest-cov +``` + +--- + +*Last updated: 2026-04-17* diff --git a/docs/agent-harness/EXECUTION-BOARD.md b/docs/agent-harness/EXECUTION-BOARD.md new file mode 100644 index 0000000..27fbb4e --- /dev/null +++ b/docs/agent-harness/EXECUTION-BOARD.md @@ -0,0 +1,93 @@ +# Execution Board (Living Kanban) + +*Last updated: 2026-04-17* + +--- + +## Completed (v1 — CLI Pipeline) + +- [x] Adobe Sign OAuth setup + token auto-refresh (`src/auth_adobe.py`, `src/adobe_api.py`) ✅ +- [x] Template download pipeline — metadata, fields, docs, PDF (`src/download_templates.py`) ✅ +- [x] Field type mapping — all major Adobe field types → DocuSign tabs ✅ (see `field-mapping.md`) +- [x] Coordinate system fix — y passthrough (top-origin, no conversion needed) ✅ +- [x] Conditional logic mapping → `conditionalParentLabel/Value` ✅ (see `validation/conditional-logic-eval.md`) +- [x] DocuSign template JSON composition (`src/compose_docusign_template.py`) ✅ +- [x] DocuSign JWT upload (`src/upload_docusign_template.py`) ✅ +- [x] Regression checklist for all field types ✅ (see `tests/FIELD-TYPE-REGRESSION.md`) +- [x] End-to-end round-trip test (3 real Adobe templates → DocuSign) ✅ + +--- + +## Phase 1 — Idempotent Upload ✅ (2026-04-17) + +- [x] Add `find_existing_template(name)` to `upload_docusign_template.py` — lists DS templates by name, returns most-recently-modified match +- [x] Change `upload_template()` to upsert: PUT if match found, POST if not +- [x] Add `--force-create` CLI flag to bypass upsert +- [x] Write `tests/test_upload_upsert.py` — 4 tests passing + +--- + +## Phase 2 — FastAPI Backend Foundation ✅ (2026-04-17) + +- [x] Add new dependencies to `requirements.txt` +- [x] Create `web/` directory structure (app.py, config.py, session.py, routers/, static/) +- [x] Implement `GET /health` endpoint +- [x] Write `tests/test_api_health.py` — 2 tests passing + +--- + +## Phase 3 — Auth Endpoints ✅ (2026-04-17) + +- [x] Implement Adobe Sign OAuth start + callback + disconnect in `web/routers/auth.py` +- [x] Implement DocuSign OAuth start + callback + disconnect +- [x] Implement `GET /api/auth/status` +- [x] Write `tests/test_api_auth.py` — 4 tests passing + +--- + +## Phase 4 — Template Listing API ✅ (2026-04-17) + +- [x] Implement `GET /api/templates/adobe` in `web/routers/templates.py` +- [x] Implement `GET /api/templates/docusign` +- [x] Implement `GET /api/templates/status` — computes `not_migrated / migrated / needs_update` +- [x] Write `tests/test_api_templates.py` — 7 tests passing + +--- + +## Phase 5 — Migration API ✅ (2026-04-17) + +- [x] Implement `POST /api/migrate` in `web/routers/migrate.py` — download → compose → upsert pipeline +- [x] Implement `GET /api/migrate/history` — reads/writes `migration-output/.history.json` +- [x] Write `tests/test_api_migrate.py` — 7 tests passing + +--- + +## Phase 6 — Frontend ✅ (2026-04-17) + +- [x] Create `web/static/index.html` — side-by-side template browser layout +- [x] Create `web/static/app.js` — auth status check, template listing, migrate flow, history +- [x] Create `web/static/style.css` — status badges, layout + +--- + +## Phase 7 — End-to-End & Regression ✅ (2026-04-17) + +- [x] Write `tests/test_e2e.py` — 7-step full pipeline test, 1 test passing +- [x] Write `tests/test_regression.py` — compose pipeline vs snapshots, 4 tests passing +- [x] Create `tests/fixtures/expected/` — snapshot JSONs for David Tag Demo, NDA, Rob Test +- [x] Full suite: **29/29 passing** + +--- + +## Gitea + +- [x] Committed and pushed all changes (2026-04-17) + +--- + +## Results & Lessons Learned + +- (2026-04-14) NDA, David Tag Demo, Rob Test all converted cleanly +- (2026-04-15) Coordinate bug fixed — y is top-origin in both platforms, no conversion needed +- (2026-04-15) Paul Adobe Template created via API; Company/Title fields require manual UI fix (API limitation) +- (2026-04-17) v2 planning complete — idempotent upload + web UI implementation begins diff --git a/docs/architecture.md b/docs/architecture.md index 507645b..e9ef58b 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -39,4 +39,30 @@ graph TD --- -*Update as architecture/requirements change. Generated by Cleo (2026-04-14).* +## v2 Architecture — Web UI (2026-04-17) + +The pipeline is extended with a FastAPI web layer that wraps all existing src/ modules. + +```mermaid +graph TD + Browser -->|HTTP| FastAPI + FastAPI -->|OAuth| AdobeSign[Adobe Sign API] + FastAPI -->|OAuth/JWT| DocuSign[DocuSign API] + FastAPI -->|calls| Compose[compose_docusign_template.py] + FastAPI -->|calls| Upload[upload_docusign_template.py] + Upload -->|upsert| DocuSign + FastAPI -->|reads/writes| History[migration-output/.history.json] +``` + +**New layers:** +- `web/routers/auth.py` — browser-initiated OAuth for Adobe Sign and DocuSign +- `web/routers/templates.py` — template listing + migration status computation +- `web/routers/migrate.py` — triggers pipeline; records history +- `web/static/` — vanilla HTML/JS SPA (no build step) + +**Idempotent Upload (v2):** +`upload_docusign_template.py` now searches for an existing DocuSign template by exact name match and updates the most recently modified one (PUT). Falls back to create (POST) if no match. `--force-create` flag bypasses upsert. + +--- + +*Update as architecture/requirements change. Generated by Cleo (2026-04-14). Updated 2026-04-17.* diff --git a/requirements.txt b/requirements.txt index 0c8889c..22aa7f4 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,3 +3,15 @@ python-dotenv pydantic PyJWT>=2.0 cryptography + +# Web UI +fastapi +uvicorn[standard] +itsdangerous +httpx + +# Testing +responses +respx +pytest-asyncio +pytest-cov diff --git a/src/upload_docusign_template.py b/src/upload_docusign_template.py index b74ac5e..10addad 100644 --- a/src/upload_docusign_template.py +++ b/src/upload_docusign_template.py @@ -4,8 +4,13 @@ upload_docusign_template.py Uploads a DocuSign template JSON file to DocuSign via the REST API. Authenticates using JWT grant (no Node.js dependency required). +By default uses upsert: if a template with the same name already exists, +the most recently modified one is updated (PUT). Use --force-create to +always create a new template instead. + Usage: python3 src/upload_docusign_template.py --file migration-output//docusign-template.json + python3 src/upload_docusign_template.py --file --force-create First-time setup: python3 src/docusign_auth.py --consent # grant consent once @@ -20,6 +25,7 @@ import argparse import json import os import sys +from typing import Optional import requests from dotenv import load_dotenv @@ -30,10 +36,61 @@ sys.path.insert(0, os.path.dirname(__file__)) from docusign_auth import get_access_token -def upload_template(file_path: str) -> str: +def _make_headers(token: str) -> dict: + return { + "Authorization": f"Bearer {token}", + "Content-Type": "application/json", + "Accept": "application/json", + } + + +def _refresh_token_once(headers: dict) -> dict: + """Clear cached token and return new headers with a fresh token.""" + os.environ.pop("DOCUSIGN_ACCESS_TOKEN", None) + os.environ.pop("DOCUSIGN_TOKEN_EXPIRY", None) + return _make_headers(get_access_token()) + + +def find_existing_template( + name: str, + account_id: str, + base_url: str, + headers: dict, +) -> Optional[str]: """ - POST a template JSON file to the DocuSign Templates API. - Returns the created templateId. + Search DocuSign for templates matching `name` exactly. + Returns the templateId of the most recently modified match, or None. + """ + url = f"{base_url}/v2.1/accounts/{account_id}/templates" + resp = requests.get(url, headers=headers, params={"search_text": name, "count": 100}) + + if resp.status_code == 401: + headers.update(_refresh_token_once(headers)) + resp = requests.get(url, headers=headers, params={"search_text": name, "count": 100}) + + if not resp.ok: + return None + + data = resp.json() + templates = data.get("envelopeTemplates") or data.get("templates") or [] + + # Exact name match only — search_text is a substring filter on DocuSign's side + exact = [t for t in templates if t.get("name") == name] + if not exact: + return None + + # Most recently modified first + exact.sort(key=lambda t: t.get("lastModified", ""), reverse=True) + return exact[0]["templateId"] + + +def upload_template(file_path: str, force_create: bool = False) -> str: + """ + Upsert a template JSON file to DocuSign. + - If a template with the same name exists and force_create is False, + the most recently modified one is updated (PUT). + - Otherwise a new template is created (POST). + Returns the templateId. """ if not os.path.exists(file_path): print(f"ERROR: File not found: {file_path}") @@ -49,35 +106,48 @@ def upload_template(file_path: str) -> str: print("ERROR: DOCUSIGN_ACCOUNT_ID must be set in .env") sys.exit(1) - token = get_access_token() - headers = { - "Authorization": f"Bearer {token}", - "Content-Type": "application/json", - "Accept": "application/json", - } + headers = _make_headers(get_access_token()) + template_name = template.get("name", file_path) + print(f"Uploading '{template_name}' to DocuSign...") - url = f"{base_url}/v2.1/accounts/{account_id}/templates" - print(f"Uploading '{template.get('name', file_path)}' to DocuSign...") + existing_id: Optional[str] = None + if not force_create: + existing_id = find_existing_template(template_name, account_id, base_url, headers) - resp = requests.post(url, headers=headers, json=template) + if existing_id: + # Update existing template + url = f"{base_url}/v2.1/accounts/{account_id}/templates/{existing_id}" + resp = requests.put(url, headers=headers, json=template) - if resp.status_code == 401: - # Token may have just expired — clear cache and retry once - os.environ.pop("DOCUSIGN_ACCESS_TOKEN", None) - os.environ.pop("DOCUSIGN_TOKEN_EXPIRY", None) - token = get_access_token() - headers["Authorization"] = f"Bearer {token}" + if resp.status_code == 401: + headers = _refresh_token_once(headers) + resp = requests.put(url, headers=headers, json=template) + + if not resp.ok: + print(f"ERROR: Update failed ({resp.status_code})") + print(resp.text) + sys.exit(1) + + print(f"Template updated: {existing_id}") + return existing_id + else: + # Create new template + url = f"{base_url}/v2.1/accounts/{account_id}/templates" resp = requests.post(url, headers=headers, json=template) - if not resp.ok: - print(f"ERROR: Upload failed ({resp.status_code})") - print(resp.text) - sys.exit(1) + if resp.status_code == 401: + headers = _refresh_token_once(headers) + resp = requests.post(url, headers=headers, json=template) - result = resp.json() - template_id = result.get("templateId") - print(f"Template created: {template_id}") - return template_id + if not resp.ok: + print(f"ERROR: Upload failed ({resp.status_code})") + print(resp.text) + sys.exit(1) + + result = resp.json() + template_id = result.get("templateId") + print(f"Template created: {template_id}") + return template_id def main(): @@ -88,8 +158,12 @@ def main(): "--file", required=True, help="Path to the docusign-template.json file to upload" ) + parser.add_argument( + "--force-create", action="store_true", + help="Always create a new template instead of updating an existing one" + ) args = parser.parse_args() - upload_template(args.file) + upload_template(args.file, force_create=args.force_create) if __name__ == "__main__": diff --git a/tests/fixtures/expected/David Tag Demo Form__CBJCHBCA.json b/tests/fixtures/expected/David Tag Demo Form__CBJCHBCA.json new file mode 100644 index 0000000..f240ae6 --- /dev/null +++ b/tests/fixtures/expected/David Tag Demo Form__CBJCHBCA.json @@ -0,0 +1,322 @@ +{ + "name": "David Tag Demo Form", + "description": "Migrated from Adobe Sign \u2014 original owner: adobesigndemo@ds.middayramble.com", + "documents": [ + { + "documentBase64": "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", + "name": "Tag Demo Form.pdf", + "fileExtension": "pdf", + "documentId": "1" + } + ], + "recipients": { + "signers": [ + { + "roleName": "Signer 1", + "recipientId": "1", + "routingOrder": "1", + "tabs": { + "fullNameTabs": [ + { + "tabLabel": "Name 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "108", + "yPosition": "42", + "width": "125", + "height": "24" + } + ], + "initialHereTabs": [ + { + "tabLabel": "Initials 3", + "documentId": "1", + "pageNumber": "1", + "xPosition": "460", + "yPosition": "55" + }, + { + "tabLabel": "Initials 2", + "documentId": "1", + "pageNumber": "1", + "xPosition": "405", + "yPosition": "292" + }, + { + "tabLabel": "Initials 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "48", + "yPosition": "432" + } + ], + "textTabs": [ + { + "tabLabel": "Text Field 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "106", + "yPosition": "68", + "width": "124", + "height": "24", + "required": "true", + "locked": "false" + }, + { + "tabLabel": "Text Field 2", + "documentId": "1", + "pageNumber": "1", + "xPosition": "119", + "yPosition": "95", + "width": "125", + "height": "24", + "required": "false", + "locked": "false" + }, + { + "tabLabel": "Text Field 3", + "documentId": "1", + "pageNumber": "1", + "xPosition": "100", + "yPosition": "119", + "width": "126", + "height": "13", + "required": "true", + "locked": "false" + }, + { + "tabLabel": "Text Field 5", + "documentId": "1", + "pageNumber": "1", + "xPosition": "97", + "yPosition": "161", + "width": "126", + "height": "13", + "required": "false", + "locked": "false" + }, + { + "tabLabel": "Text Field 4", + "documentId": "1", + "pageNumber": "1", + "xPosition": "112", + "yPosition": "183", + "width": "126", + "height": "13", + "required": "true", + "locked": "false" + } + ], + "radioGroupTabs": [ + { + "groupName": "Custom Radio 2", + "documentId": "1", + "radios": [ + { + "pageNumber": "1", + "xPosition": "382", + "yPosition": "66", + "value": "Radio button 2" + }, + { + "pageNumber": "1", + "xPosition": "382", + "yPosition": "86", + "value": "Radio button 3" + } + ] + }, + { + "groupName": "Custom Radio 5", + "documentId": "1", + "radios": [ + { + "pageNumber": "1", + "xPosition": "333", + "yPosition": "239", + "value": "Radio button 1" + }, + { + "pageNumber": "1", + "xPosition": "404", + "yPosition": "240", + "value": "Radio button 2" + }, + { + "pageNumber": "1", + "xPosition": "472", + "yPosition": "238", + "value": "Radio button 3" + } + ] + }, + { + "groupName": "Custom Radio 1", + "documentId": "1", + "radios": [ + { + "pageNumber": "1", + "xPosition": "89", + "yPosition": "333", + "value": "Radio button 1" + }, + { + "pageNumber": "1", + "xPosition": "159", + "yPosition": "334", + "value": "Radio button 2" + }, + { + "pageNumber": "1", + "xPosition": "228", + "yPosition": "332", + "value": "Radio button 3" + } + ] + } + ], + "listTabs": [ + { + "tabLabel": "Drop-down 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "335", + "yPosition": "124", + "width": "142", + "height": "16", + "required": "true", + "listItems": [ + { + "text": "MD", + "value": "MD" + }, + { + "text": "VA", + "value": "VA" + }, + { + "text": "DC", + "value": "DC" + }, + { + "text": "DE", + "value": "DE" + } + ] + }, + { + "tabLabel": "Drop-down 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "105", + "yPosition": "139", + "width": "142", + "height": "16", + "required": "true", + "listItems": [ + { + "text": "MD", + "value": "MD" + }, + { + "text": "VA", + "value": "VA" + }, + { + "text": "DC", + "value": "DC" + }, + { + "text": "DE", + "value": "DE" + } + ] + } + ], + "dateTabs": [ + { + "tabLabel": "Date Field 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "105", + "yPosition": "205", + "width": "126", + "height": "13", + "required": "false", + "locked": "false" + } + ], + "checkboxTabs": [ + { + "tabLabel": "Checkbox 4", + "documentId": "1", + "pageNumber": "1", + "xPosition": "90", + "yPosition": "361", + "width": "120", + "height": "8", + "required": "true" + }, + { + "tabLabel": "Checkbox 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "164", + "yPosition": "361", + "width": "120", + "height": "8", + "required": "false" + }, + { + "tabLabel": "Checkbox 2", + "documentId": "1", + "pageNumber": "1", + "xPosition": "229", + "yPosition": "363", + "width": "120", + "height": "8", + "required": "false" + } + ], + "dateSignedTabs": [ + { + "tabLabel": "Date of Signing 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "64", + "yPosition": "485", + "width": "175", + "height": "24" + } + ], + "signHereTabs": [ + { + "tabLabel": "Signature block 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "17", + "yPosition": "582" + }, + { + "tabLabel": "Signature Field 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "0", + "yPosition": "660" + } + ], + "signerAttachmentTabs": [ + { + "tabLabel": "Attachments 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "355", + "yPosition": "642", + "optional": "true" + } + ] + } + } + ] + } +} \ No newline at end of file diff --git a/tests/fixtures/expected/Rob Test__CBJCHBCA.json b/tests/fixtures/expected/Rob Test__CBJCHBCA.json new file mode 100644 index 0000000..19eac8e --- /dev/null +++ b/tests/fixtures/expected/Rob Test__CBJCHBCA.json @@ -0,0 +1,91 @@ +{ + "name": "Rob Test", + "description": "Migrated from Adobe Sign \u2014 original owner: adobesigndemo@ds.middayramble.com", + "documents": [ + { + "documentBase64": "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", + "name": "Office Questionnaire.pdf", + "fileExtension": "pdf", + "documentId": "1" + } + ], + "recipients": { + "signers": [ + { + "roleName": "Signer 1", + "recipientId": "1", + "routingOrder": "1", + "tabs": { + "textTabs": [ + { + "tabLabel": "Text Field 1", + "documentId": "1", + "pageNumber": "1", + "xPosition": "486", + "yPosition": "29", + "width": "120", + "height": "17", + "required": "false", + "locked": "false" + }, + { + "tabLabel": "Text Field 2", + "documentId": "1", + "pageNumber": "1", + "xPosition": "72", + "yPosition": "506", + "width": "137", + "height": "17", + "required": "false", + "locked": "false" + }, + { + "tabLabel": "Text Field 3", + "documentId": "1", + "pageNumber": "1", + "xPosition": "396", + "yPosition": "506", + "width": "137", + "height": "17", + "required": "false", + "locked": "false" + }, + { + "tabLabel": "Text Field 4", + "documentId": "1", + "pageNumber": "1", + "xPosition": "72", + "yPosition": "550", + "width": "137", + "height": "17", + "required": "false", + "locked": "false" + }, + { + "tabLabel": "Text Field 5", + "documentId": "1", + "pageNumber": "1", + "xPosition": "396", + "yPosition": "550", + "width": "137", + "height": "17", + "required": "false", + "locked": "false" + }, + { + "tabLabel": "Text Field 6", + "documentId": "1", + "pageNumber": "1", + "xPosition": "396", + "yPosition": "594", + "width": "137", + "height": "17", + "required": "false", + "locked": "false" + } + ] + } + } + ] + } +} \ No newline at end of file diff --git a/tests/fixtures/expected/_DEMO USE ONLY_ NDA__CBJCHBCA.json b/tests/fixtures/expected/_DEMO USE ONLY_ NDA__CBJCHBCA.json new file mode 100644 index 0000000..bb69489 --- /dev/null +++ b/tests/fixtures/expected/_DEMO USE ONLY_ NDA__CBJCHBCA.json @@ -0,0 +1,108 @@ +{ + "name": "[DEMO USE ONLY] NDA", + "description": "Migrated from Adobe Sign \u2014 original owner: adobesigndemo@ds.middayramble.com", + "documents": [ + { + "documentBase64": "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", + "name": "two-way nda.pdf", + "fileExtension": "pdf", + "documentId": "1" + } + ], + "recipients": { + "signers": [ + { + "roleName": "Signer 1", + "recipientId": "1", + "routingOrder": "1", + "tabs": { + "listTabs": [ + { + "tabLabel": "Drop Down 1", + "documentId": "1", + "pageNumber": "3", + "xPosition": "220", + "yPosition": "335", + "width": "120", + "height": "16", + "required": "true", + "listItems": [ + { + "text": "Option 1", + "value": "Option 1" + }, + { + "text": "Option 2", + "value": "Option 2" + }, + { + "text": "Option 3", + "value": "Option 3" + }, + { + "text": "Option 4", + "value": "Option 4" + } + ] + } + ], + "textTabs": [ + { + "tabLabel": "Option 1 selected", + "documentId": "1", + "pageNumber": "3", + "xPosition": "326", + "yPosition": "335", + "width": "120", + "height": "16", + "required": "true", + "locked": "false" + }, + { + "tabLabel": "Custom Field 5", + "documentId": "1", + "pageNumber": "3", + "xPosition": "328", + "yPosition": "369", + "width": "120", + "height": "16", + "required": "false", + "locked": "false" + }, + { + "tabLabel": "Option 1 Not Selected", + "documentId": "1", + "pageNumber": "3", + "xPosition": "330", + "yPosition": "397", + "width": "120", + "height": "16", + "required": "true", + "locked": "false" + } + ], + "signHereTabs": [ + { + "tabLabel": "Custom Field 1", + "documentId": "1", + "pageNumber": "3", + "xPosition": "90", + "yPosition": "586" + } + ], + "dateSignedTabs": [ + { + "tabLabel": "Custom Field 2", + "documentId": "1", + "pageNumber": "3", + "xPosition": "380", + "yPosition": "586", + "width": "120", + "height": "28" + } + ] + } + } + ] + } +} \ No newline at end of file diff --git a/tests/test_api_auth.py b/tests/test_api_auth.py new file mode 100644 index 0000000..d7e7c2e --- /dev/null +++ b/tests/test_api_auth.py @@ -0,0 +1,92 @@ +""" +tests/test_api_auth.py +---------------------- +Tests for /api/auth/* endpoints. +All external OAuth calls are mocked with respx. +""" + +import pytest +import respx +import httpx +from fastapi.testclient import TestClient + +from web.app import app + +client = TestClient(app, raise_server_exceptions=True) + + +def test_status_unauthenticated(): + """Fresh session → both platforms disconnected.""" + resp = client.get("/api/auth/status", cookies={}) + assert resp.status_code == 200 + data = resp.json() + assert data["adobe"] is False + assert data["docusign"] is False + + +@respx.mock +def test_adobe_callback_stores_token(): + """Successful Adobe OAuth callback → session has adobe_access_token.""" + respx.post("https://api.eu2.adobesign.com/oauth/v2/token").mock( + return_value=httpx.Response(200, json={ + "access_token": "adobe-test-token", + "refresh_token": "adobe-refresh", + }) + ) + + resp = client.get("/api/auth/adobe/callback?code=authcode123", follow_redirects=False) + # Should redirect to / + assert resp.status_code in (302, 307) + + # Session cookie should now contain the token + session_cookie = resp.cookies.get("migrator_session") + assert session_cookie is not None + + # Follow up with status check using the same session cookie + status_resp = client.get("/api/auth/status", cookies={"migrator_session": session_cookie}) + assert status_resp.json()["adobe"] is True + + +@respx.mock +def test_docusign_callback_stores_token(): + """Successful DocuSign OAuth callback → session has docusign_access_token.""" + from web.config import settings + respx.post(f"https://{settings.docusign_auth_server}/oauth/token").mock( + return_value=httpx.Response(200, json={ + "access_token": "ds-test-token", + "refresh_token": "ds-refresh", + }) + ) + + resp = client.get("/api/auth/docusign/callback?code=dscode123", follow_redirects=False) + assert resp.status_code in (302, 307) + + session_cookie = resp.cookies.get("migrator_session") + assert session_cookie is not None + + status_resp = client.get("/api/auth/status", cookies={"migrator_session": session_cookie}) + assert status_resp.json()["docusign"] is True + + +@respx.mock +def test_disconnect_clears_token(): + """After disconnect, status shows platform as disconnected.""" + # First connect Adobe + respx.post("https://api.eu2.adobesign.com/oauth/v2/token").mock( + return_value=httpx.Response(200, json={"access_token": "tok", "refresh_token": "ref"}) + ) + connect_resp = client.get("/api/auth/adobe/callback?code=abc", follow_redirects=False) + session_cookie = connect_resp.cookies["migrator_session"] + + # Verify connected + status_resp = client.get("/api/auth/status", cookies={"migrator_session": session_cookie}) + assert status_resp.json()["adobe"] is True + + # Disconnect + disc_resp = client.get("/api/auth/adobe/disconnect", cookies={"migrator_session": session_cookie}) + assert disc_resp.status_code == 200 + new_cookie = disc_resp.cookies.get("migrator_session", session_cookie) + + # Verify disconnected + status_resp2 = client.get("/api/auth/status", cookies={"migrator_session": new_cookie}) + assert status_resp2.json()["adobe"] is False diff --git a/tests/test_api_health.py b/tests/test_api_health.py new file mode 100644 index 0000000..a7e1adf --- /dev/null +++ b/tests/test_api_health.py @@ -0,0 +1,25 @@ +""" +tests/test_api_health.py +------------------------ +Tests for the /health endpoint and basic app startup. +""" + +import pytest +from fastapi.testclient import TestClient + +from web.app import app + +client = TestClient(app) + + +def test_health_returns_200(): + resp = client.get("/health") + assert resp.status_code == 200 + + +def test_health_response_shape(): + resp = client.get("/health") + data = resp.json() + assert data["status"] == "ok" + assert "version" in data + assert data["version"] == "2.0" diff --git a/tests/test_api_migrate.py b/tests/test_api_migrate.py new file mode 100644 index 0000000..fb460ab --- /dev/null +++ b/tests/test_api_migrate.py @@ -0,0 +1,239 @@ +""" +tests/test_api_migrate.py +-------------------------- +Tests for /api/migrate (POST) and /api/migrate/history (GET). +All Adobe Sign and DocuSign HTTP calls are mocked with respx. +The compose pipeline is mocked at the module level to avoid PDF/file I/O. +""" + +import json +import os +import tempfile +from unittest.mock import patch, MagicMock + +import pytest +import respx +import httpx +from fastapi.testclient import TestClient + +from web.app import app +from web.session import _serializer, _COOKIE_NAME +import web.routers.migrate as migrate_module + +client = TestClient(app, raise_server_exceptions=True) + +ADOBE_BASE = "https://api.eu2.adobesign.com/api/rest/v6" +DS_BASE = "https://demo.docusign.net/restapi" +DS_ACCOUNT = "test-account-id" +TEMPLATE_NAME = "Test NDA" +ADOBE_ID = "adobe-123" +DS_NEW_ID = "ds-new-456" +DS_EXISTING_ID = "ds-existing-789" + + +def _full_session(): + return _serializer.dumps({ + "adobe_access_token": "adobe-tok", + "docusign_access_token": "ds-tok", + }) + + +def _adobe_only_session(): + return _serializer.dumps({"adobe_access_token": "adobe-tok"}) + + +@pytest.fixture(autouse=True) +def patch_settings(monkeypatch): + import web.config as cfg + monkeypatch.setattr(cfg.settings, "docusign_account_id", DS_ACCOUNT) + monkeypatch.setattr(cfg.settings, "docusign_base_url", DS_BASE) + monkeypatch.setattr(cfg.settings, "adobe_sign_base_url", ADOBE_BASE) + + +@pytest.fixture(autouse=True) +def temp_history(tmp_path, monkeypatch): + """Redirect history file to a temp path for each test.""" + history_path = str(tmp_path / ".history.json") + monkeypatch.setattr(migrate_module, "_HISTORY_FILE", history_path) + return history_path + + +def _mock_compose(template_dir: str, output_path: str): + """Write a minimal DocuSign template JSON so the pipeline continues.""" + with open(output_path, "w") as f: + json.dump({"name": TEMPLATE_NAME, "description": "mocked"}, f) + + +def _mock_download(template_id, access_token, output_dir): + """Write stub Adobe Sign files so compose has something to read.""" + os.makedirs(output_dir, exist_ok=True) + with open(os.path.join(output_dir, "metadata.json"), "w") as f: + json.dump({"name": TEMPLATE_NAME, "id": template_id}, f) + with open(os.path.join(output_dir, "form_fields.json"), "w") as f: + json.dump({"fields": []}, f) + with open(os.path.join(output_dir, "documents.json"), "w") as f: + json.dump({"documents": []}, f) + return True + + +def test_migrate_requires_auth(): + """No session → 401.""" + resp = client.post("/api/migrate", json={"adobe_template_ids": [ADOBE_ID]}, cookies={}) + assert resp.status_code == 401 + + +def test_migrate_requires_docusign_auth(): + """Only Adobe auth → 401.""" + resp = client.post( + "/api/migrate", + json={"adobe_template_ids": [ADOBE_ID]}, + cookies={_COOKIE_NAME: _adobe_only_session()}, + ) + assert resp.status_code == 401 + + +@respx.mock +def test_migrate_single_template_creates(): + """No existing DS template → POST creates; result action=created.""" + # DS list: no match + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(200, json={"envelopeTemplates": []}) + ) + # DS create + respx.post(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(201, json={"templateId": DS_NEW_ID}) + ) + + with ( + patch.object(migrate_module, "_download_adobe_template", new=_async_wrap(_mock_download)), + patch.object(migrate_module, "_load_compose", return_value=_mock_compose), + ): + resp = client.post( + "/api/migrate", + json={"adobe_template_ids": [ADOBE_ID]}, + cookies={_COOKIE_NAME: _full_session()}, + ) + + assert resp.status_code == 200 + results = resp.json()["results"] + assert len(results) == 1 + assert results[0]["action"] == "created" + assert results[0]["docusign_template_id"] == DS_NEW_ID + assert results[0]["status"] == "success" + + +@respx.mock +def test_migrate_single_template_updates(): + """Existing DS template with same name → PUT updates; result action=updated.""" + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(200, json={ + "envelopeTemplates": [ + {"templateId": DS_EXISTING_ID, "name": TEMPLATE_NAME, "lastModified": "2026-04-10T00:00:00Z"}, + ] + }) + ) + respx.put(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates/{DS_EXISTING_ID}").mock( + return_value=httpx.Response(200, json={}) + ) + + with ( + patch.object(migrate_module, "_download_adobe_template", new=_async_wrap(_mock_download)), + patch.object(migrate_module, "_load_compose", return_value=_mock_compose), + ): + resp = client.post( + "/api/migrate", + json={"adobe_template_ids": [ADOBE_ID]}, + cookies={_COOKIE_NAME: _full_session()}, + ) + + assert resp.status_code == 200 + results = resp.json()["results"] + assert results[0]["action"] == "updated" + assert results[0]["docusign_template_id"] == DS_EXISTING_ID + + +@respx.mock +def test_migrate_records_history(temp_history): + """After successful migration, history file is written.""" + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(200, json={"envelopeTemplates": []}) + ) + respx.post(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(201, json={"templateId": DS_NEW_ID}) + ) + + with ( + patch.object(migrate_module, "_download_adobe_template", new=_async_wrap(_mock_download)), + patch.object(migrate_module, "_load_compose", return_value=_mock_compose), + ): + client.post( + "/api/migrate", + json={"adobe_template_ids": [ADOBE_ID]}, + cookies={_COOKIE_NAME: _full_session()}, + ) + + assert os.path.exists(temp_history) + with open(temp_history) as f: + history = json.load(f) + assert len(history) == 1 + assert history[0]["adobe_template_id"] == ADOBE_ID + + +def test_history_returns_past_runs(temp_history): + """GET /api/migrate/history returns written records.""" + records = [ + {"timestamp": "2026-04-17T10:00:00Z", "adobe_template_id": "a1", "status": "success"}, + {"timestamp": "2026-04-17T11:00:00Z", "adobe_template_id": "a2", "status": "failed"}, + ] + with open(temp_history, "w") as f: + json.dump(records, f) + + resp = client.get("/api/migrate/history") + assert resp.status_code == 200 + assert len(resp.json()["history"]) == 2 + + +@respx.mock +def test_migrate_handles_partial_failure(): + """One template fails (download error), others succeed.""" + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(200, json={"envelopeTemplates": []}) + ) + respx.post(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(201, json={"templateId": DS_NEW_ID}) + ) + + call_count = {"n": 0} + + async def mock_download_partial(template_id, access_token, output_dir): + call_count["n"] += 1 + if call_count["n"] == 1: + return False # first template fails + return await _async_wrap(_mock_download)(template_id, access_token, output_dir) + + with ( + patch.object(migrate_module, "_download_adobe_template", new=mock_download_partial), + patch.object(migrate_module, "_load_compose", return_value=_mock_compose), + ): + resp = client.post( + "/api/migrate", + json={"adobe_template_ids": ["fail-id", ADOBE_ID]}, + cookies={_COOKIE_NAME: _full_session()}, + ) + + assert resp.status_code == 200 + results = resp.json()["results"] + assert results[0]["status"] == "failed" + assert results[1]["status"] == "success" + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +def _async_wrap(sync_fn): + """Wrap a sync function to be awaitable (for patching async functions in tests).""" + import asyncio + async def wrapper(*args, **kwargs): + return sync_fn(*args, **kwargs) + return wrapper diff --git a/tests/test_api_templates.py b/tests/test_api_templates.py new file mode 100644 index 0000000..894037f --- /dev/null +++ b/tests/test_api_templates.py @@ -0,0 +1,157 @@ +""" +tests/test_api_templates.py +---------------------------- +Tests for /api/templates/* endpoints. +All external API calls are mocked with respx. +""" + +import pytest +import respx +import httpx +from fastapi.testclient import TestClient + +from web.app import app +from web.session import _serializer, _COOKIE_NAME + +client = TestClient(app, raise_server_exceptions=True) + + +def _make_session_cookie(data: dict) -> str: + """Build a valid signed session cookie for testing.""" + return _serializer.dumps(data) + + +def _adobe_session(): + return _make_session_cookie({"adobe_access_token": "adobe-tok", "docusign_access_token": "ds-tok"}) + + +def _ds_only_session(): + return _make_session_cookie({"docusign_access_token": "ds-tok"}) + + +def _adobe_only_session(): + return _make_session_cookie({"adobe_access_token": "adobe-tok"}) + + +ADOBE_BASE = "https://api.eu2.adobesign.com/api/rest/v6" +DS_BASE = "https://demo.docusign.net/restapi" +DS_ACCOUNT = "test-account-id" + + +@pytest.fixture(autouse=True) +def patch_account_id(monkeypatch): + import web.config as cfg + monkeypatch.setattr(cfg.settings, "docusign_account_id", DS_ACCOUNT) + monkeypatch.setattr(cfg.settings, "docusign_base_url", DS_BASE) + monkeypatch.setattr(cfg.settings, "adobe_sign_base_url", ADOBE_BASE) + + +def test_adobe_list_requires_auth(): + """No session → 401.""" + resp = client.get("/api/templates/adobe", cookies={}) + assert resp.status_code == 401 + + +def test_docusign_list_requires_auth(): + """No session → 401.""" + resp = client.get("/api/templates/docusign", cookies={}) + assert resp.status_code == 401 + + +@respx.mock +def test_adobe_list_returns_templates(): + """Authenticated → list of templates returned.""" + respx.get(f"{ADOBE_BASE}/libraryDocuments").mock( + return_value=httpx.Response(200, json={ + "libraryDocumentList": [ + {"id": "abc1", "name": "NDA", "modifiedDate": "2026-04-10", "sharingMode": "USER"}, + {"id": "abc2", "name": "Sales Agmt", "modifiedDate": "2026-04-12", "sharingMode": "USER"}, + ] + }) + ) + resp = client.get("/api/templates/adobe", cookies={_COOKIE_NAME: _adobe_only_session()}) + assert resp.status_code == 200 + data = resp.json() + assert len(data["templates"]) == 2 + assert data["templates"][0]["name"] == "NDA" + + +@respx.mock +def test_docusign_list_returns_templates(): + """Authenticated → list of DocuSign templates returned.""" + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(200, json={ + "envelopeTemplates": [ + {"templateId": "ds1", "name": "NDA", "lastModified": "2026-04-11"}, + ] + }) + ) + resp = client.get("/api/templates/docusign", cookies={_COOKIE_NAME: _ds_only_session()}) + assert resp.status_code == 200 + data = resp.json() + assert data["templates"][0]["id"] == "ds1" + + +@respx.mock +def test_status_not_migrated(): + """Adobe template with no matching DS name → not_migrated.""" + respx.get(f"{ADOBE_BASE}/libraryDocuments").mock( + return_value=httpx.Response(200, json={ + "libraryDocumentList": [ + {"id": "adobe1", "name": "Onboarding", "modifiedDate": "2026-04-10"}, + ] + }) + ) + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(200, json={"envelopeTemplates": []}) + ) + resp = client.get("/api/templates/status", cookies={_COOKIE_NAME: _adobe_session()}) + assert resp.status_code == 200 + t = resp.json()["templates"][0] + assert t["status"] == "not_migrated" + assert t["docusign_id"] is None + + +@respx.mock +def test_status_migrated(): + """Adobe template with same name in DS and DS is newer → migrated.""" + respx.get(f"{ADOBE_BASE}/libraryDocuments").mock( + return_value=httpx.Response(200, json={ + "libraryDocumentList": [ + {"id": "adobe1", "name": "NDA", "modifiedDate": "2026-04-10T00:00:00Z"}, + ] + }) + ) + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(200, json={ + "envelopeTemplates": [ + {"templateId": "ds1", "name": "NDA", "lastModified": "2026-04-11T00:00:00Z"}, + ] + }) + ) + resp = client.get("/api/templates/status", cookies={_COOKIE_NAME: _adobe_session()}) + t = resp.json()["templates"][0] + assert t["status"] == "migrated" + assert t["docusign_id"] == "ds1" + + +@respx.mock +def test_status_needs_update(): + """Adobe template modified after the DS template → needs_update.""" + respx.get(f"{ADOBE_BASE}/libraryDocuments").mock( + return_value=httpx.Response(200, json={ + "libraryDocumentList": [ + {"id": "adobe1", "name": "NDA", "modifiedDate": "2026-04-15T00:00:00Z"}, + ] + }) + ) + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(200, json={ + "envelopeTemplates": [ + {"templateId": "ds1", "name": "NDA", "lastModified": "2026-04-10T00:00:00Z"}, + ] + }) + ) + resp = client.get("/api/templates/status", cookies={_COOKIE_NAME: _adobe_session()}) + t = resp.json()["templates"][0] + assert t["status"] == "needs_update" diff --git a/tests/test_e2e.py b/tests/test_e2e.py new file mode 100644 index 0000000..83c0f11 --- /dev/null +++ b/tests/test_e2e.py @@ -0,0 +1,192 @@ +""" +tests/test_e2e.py +----------------- +End-to-end test: full migration pipeline through the web API. + +Simulates: + 1. Connect Adobe Sign (mock OAuth callback) + 2. Connect DocuSign (mock OAuth callback) + 3. GET /api/templates/status → at least one template shown + 4. POST /api/migrate → status created + 5. GET /api/templates/status → same template now migrated + 6. POST /api/migrate again → status updated + 7. GET /api/migrate/history → two records for the same template +""" + +import json +import os +from unittest.mock import patch + +import pytest +import respx +import httpx +from fastapi.testclient import TestClient + +from web.app import app +import web.routers.migrate as migrate_module + +ADOBE_BASE = "https://api.eu2.adobesign.com/api/rest/v6" +DS_BASE = "https://demo.docusign.net/restapi" +DS_ACCOUNT = "e2e-account-id" +TEMPLATE_NAME = "E2E NDA" +ADOBE_ID = "e2e-adobe-001" +DS_CREATED_ID = "e2e-ds-created" + + +@pytest.fixture(autouse=True) +def patch_settings(monkeypatch): + import web.config as cfg + monkeypatch.setattr(cfg.settings, "docusign_account_id", DS_ACCOUNT) + monkeypatch.setattr(cfg.settings, "docusign_base_url", DS_BASE) + monkeypatch.setattr(cfg.settings, "adobe_sign_base_url", ADOBE_BASE) + monkeypatch.setattr(cfg.settings, "adobe_client_id", "test-client") + monkeypatch.setattr(cfg.settings, "adobe_client_secret", "test-secret") + monkeypatch.setattr(cfg.settings, "docusign_client_id", "test-ds-client") + monkeypatch.setattr(cfg.settings, "docusign_client_secret", "test-ds-secret") + monkeypatch.setattr(cfg.settings, "docusign_auth_server", "account-d.docusign.com") + + +@pytest.fixture(autouse=True) +def temp_history(tmp_path, monkeypatch): + history_path = str(tmp_path / ".history.json") + monkeypatch.setattr(migrate_module, "_HISTORY_FILE", history_path) + return history_path + + +def _mock_compose(template_dir, output_path): + with open(output_path, "w") as f: + json.dump({"name": TEMPLATE_NAME}, f) + + +def _mock_download(template_id, access_token, output_dir): + os.makedirs(output_dir, exist_ok=True) + with open(os.path.join(output_dir, "metadata.json"), "w") as f: + json.dump({"name": TEMPLATE_NAME, "id": template_id}, f) + with open(os.path.join(output_dir, "form_fields.json"), "w") as f: + json.dump({"fields": []}, f) + with open(os.path.join(output_dir, "documents.json"), "w") as f: + json.dump({"documents": []}, f) + return True + + +async def _async_mock_download(*args, **kwargs): + return _mock_download(*args, **kwargs) + + +@respx.mock +def test_full_migration_flow(temp_history): + """Full 7-step end-to-end pipeline test.""" + from web.session import _serializer, _COOKIE_NAME + from web.config import settings + + test_client = TestClient(app, raise_server_exceptions=True) + + # ── Step 1 & 2: Simulate already-authenticated session ────────────────── + # (OAuth callback tested in test_api_auth.py; here we inject the session directly) + session_cookie = _serializer.dumps({ + "adobe_access_token": "e2e-adobe-tok", + "docusign_access_token": "e2e-ds-tok", + }) + + # ── Step 3: GET /api/templates/status → template visible ──────────────── + respx.get(f"{ADOBE_BASE}/libraryDocuments").mock( + return_value=httpx.Response(200, json={ + "libraryDocumentList": [ + {"id": ADOBE_ID, "name": TEMPLATE_NAME, "modifiedDate": "2026-04-17T10:00:00Z"}, + ] + }) + ) + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(200, json={"envelopeTemplates": []}) + ) + + status_resp = test_client.get( + "/api/templates/status", + cookies={_COOKIE_NAME: session_cookie} + ) + assert status_resp.status_code == 200 + templates = status_resp.json()["templates"] + assert any(t["adobe_id"] == ADOBE_ID for t in templates) + adobe_t = next(t for t in templates if t["adobe_id"] == ADOBE_ID) + assert adobe_t["status"] == "not_migrated" + + # ── Step 4: POST /api/migrate → created ───────────────────────────────── + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates", name="list1").mock( + return_value=httpx.Response(200, json={"envelopeTemplates": []}) + ) + respx.post(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(201, json={"templateId": DS_CREATED_ID}) + ) + + with ( + patch.object(migrate_module, "_download_adobe_template", new=_async_mock_download), + patch.object(migrate_module, "_load_compose", return_value=_mock_compose), + ): + migrate_resp = test_client.post( + "/api/migrate", + json={"adobe_template_ids": [ADOBE_ID]}, + cookies={_COOKIE_NAME: session_cookie}, + ) + + assert migrate_resp.status_code == 200 + result = migrate_resp.json()["results"][0] + assert result["status"] == "success" + assert result["action"] == "created" + assert result["docusign_template_id"] == DS_CREATED_ID + + # ── Step 5: GET /api/templates/status → now migrated ──────────────────── + respx.get(f"{ADOBE_BASE}/libraryDocuments").mock( + return_value=httpx.Response(200, json={ + "libraryDocumentList": [ + {"id": ADOBE_ID, "name": TEMPLATE_NAME, "modifiedDate": "2026-04-17T10:00:00Z"}, + ] + }) + ) + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(200, json={ + "envelopeTemplates": [ + {"templateId": DS_CREATED_ID, "name": TEMPLATE_NAME, "lastModified": "2026-04-17T12:00:00Z"}, + ] + }) + ) + status_resp2 = test_client.get( + "/api/templates/status", + cookies={_COOKIE_NAME: session_cookie} + ) + templates2 = status_resp2.json()["templates"] + t2 = next(t for t in templates2 if t["adobe_id"] == ADOBE_ID) + assert t2["status"] == "migrated" + + # ── Step 6: POST /api/migrate again → updated ─────────────────────────── + respx.get(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates").mock( + return_value=httpx.Response(200, json={ + "envelopeTemplates": [ + {"templateId": DS_CREATED_ID, "name": TEMPLATE_NAME, "lastModified": "2026-04-17T12:00:00Z"}, + ] + }) + ) + respx.put(f"{DS_BASE}/v2.1/accounts/{DS_ACCOUNT}/templates/{DS_CREATED_ID}").mock( + return_value=httpx.Response(200, json={}) + ) + + with ( + patch.object(migrate_module, "_download_adobe_template", new=_async_mock_download), + patch.object(migrate_module, "_load_compose", return_value=_mock_compose), + ): + migrate_resp2 = test_client.post( + "/api/migrate", + json={"adobe_template_ids": [ADOBE_ID]}, + cookies={_COOKIE_NAME: session_cookie}, + ) + + result2 = migrate_resp2.json()["results"][0] + assert result2["action"] == "updated" + assert result2["docusign_template_id"] == DS_CREATED_ID + + # ── Step 7: GET /api/migrate/history → two records ────────────────────── + history_resp = test_client.get("/api/migrate/history") + history = history_resp.json()["history"] + assert len(history) == 2 + actions = [r["action"] for r in history] + assert "created" in actions + assert "updated" in actions diff --git a/tests/test_regression.py b/tests/test_regression.py new file mode 100644 index 0000000..65d923e --- /dev/null +++ b/tests/test_regression.py @@ -0,0 +1,129 @@ +""" +tests/test_regression.py +------------------------ +Regression tests for the compose pipeline. + +For each downloaded template in downloads/, run compose_template() and +compare the output against the snapshot in tests/fixtures/expected/. + +These tests require no live API calls. They verify that changes to the +compose pipeline don't silently break existing template conversions. + +To update snapshots after an intentional change: + pytest tests/test_regression.py --update-snapshots +""" + +import json +import os +import sys +import tempfile + +import pytest + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src")) +from compose_docusign_template import compose_template + +DOWNLOADS_DIR = os.path.join(os.path.dirname(__file__), "..", "downloads") +FIXTURES_DIR = os.path.join(os.path.dirname(__file__), "fixtures", "expected") + +# Templates with real downloaded data to test against +REGRESSION_TEMPLATES = [ + "David Tag Demo Form__CBJCHBCA", + "_DEMO USE ONLY_ NDA__CBJCHBCA", + "Rob Test__CBJCHBCA", +] + + +@pytest.fixture +def update_snapshots(request): + return request.config.getoption("--update-snapshots", default=False) + + +@pytest.mark.parametrize("template_name", REGRESSION_TEMPLATES) +def test_compose_regression(template_name, update_snapshots): + """ + Compose output for each template must match the stored snapshot. + Run with --update-snapshots to regenerate. + """ + template_dir = os.path.join(DOWNLOADS_DIR, template_name) + if not os.path.isdir(template_dir): + pytest.skip(f"Downloaded template not found: {template_name}") + + snapshot_path = os.path.join(FIXTURES_DIR, f"{template_name}.json") + + with tempfile.NamedTemporaryFile(suffix=".json", delete=False, mode="w") as tf: + output_path = tf.name + + try: + result, warnings = compose_template(template_dir, output_path) + + if update_snapshots: + os.makedirs(FIXTURES_DIR, exist_ok=True) + with open(snapshot_path, "w") as f: + json.dump(result, f, indent=2) + pytest.skip(f"Snapshot updated for {template_name}") + + if not os.path.exists(snapshot_path): + pytest.fail( + f"No snapshot for '{template_name}'. " + f"Run with --update-snapshots to create it." + ) + + with open(snapshot_path) as f: + expected = json.load(f) + + # Compare key structural properties + assert result.get("name") == expected.get("name"), \ + f"Template name mismatch for {template_name}" + + # Recipients + result_roles = sorted([r.get("roleName", "") for r in result.get("recipients", {}).get("signers", [])]) + expected_roles = sorted([r.get("roleName", "") for r in expected.get("recipients", {}).get("signers", [])]) + assert result_roles == expected_roles, \ + f"Recipient roles changed for {template_name}: {result_roles} != {expected_roles}" + + # Tab counts per type — must not regress + result_tabs = _count_tabs(result) + expected_tabs = _count_tabs(expected) + for tab_type, count in expected_tabs.items(): + actual = result_tabs.get(tab_type, 0) + assert actual == count, ( + f"Tab count regression in {template_name}: " + f"{tab_type} expected {count}, got {actual}" + ) + + finally: + if os.path.exists(output_path): + os.unlink(output_path) + + +def _count_tabs(template: dict) -> dict: + """Count total tabs of each type across all signers.""" + counts = {} + for signer in template.get("recipients", {}).get("signers", []): + tabs = signer.get("tabs", {}) + for tab_type, items in tabs.items(): + if isinstance(items, list): + counts[tab_type] = counts.get(tab_type, 0) + len(items) + return counts + + +def test_no_tabs_lost_on_recompose(): + """ + Sanity check: every downloaded template must produce at least one tab. + Catches complete compose failures silently returning empty output. + """ + for template_name in REGRESSION_TEMPLATES: + template_dir = os.path.join(DOWNLOADS_DIR, template_name) + if not os.path.isdir(template_dir): + continue + + with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as tf: + output_path = tf.name + try: + result, _ = compose_template(template_dir, output_path) + total_tabs = sum(_count_tabs(result).values()) + assert total_tabs > 0, f"No tabs produced for {template_name}" + finally: + if os.path.exists(output_path): + os.unlink(output_path) diff --git a/tests/test_upload_upsert.py b/tests/test_upload_upsert.py new file mode 100644 index 0000000..0c64042 --- /dev/null +++ b/tests/test_upload_upsert.py @@ -0,0 +1,127 @@ +""" +tests/test_upload_upsert.py +--------------------------- +Tests for idempotent (upsert) upload logic in upload_docusign_template.py. + +All DocuSign API calls are mocked with responses; no live account needed. +""" + +import json +import os +import sys +import tempfile +from unittest.mock import patch + +import pytest +import responses as rsps_lib + +# Ensure src/ is importable before import +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src")) + +# Patch get_access_token at import time so the module never tries to load a private key +with patch("docusign_auth.get_access_token", return_value="fake-token"): + import upload_docusign_template + +BASE_URL = "https://demo.docusign.net/restapi" +ACCOUNT_ID = "test-account-id" +TEMPLATE_NAME = "My NDA Template" + + +@pytest.fixture(autouse=True) +def env_vars(monkeypatch): + monkeypatch.setenv("DOCUSIGN_ACCOUNT_ID", ACCOUNT_ID) + monkeypatch.setenv("DOCUSIGN_BASE_URL", BASE_URL) + + +@pytest.fixture() +def template_file(): + """Write a minimal template JSON to a temp file.""" + template = {"name": TEMPLATE_NAME, "description": "test template"} + with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f: + json.dump(template, f) + path = f.name + yield path + os.unlink(path) + + +def _list_url(): + return f"{BASE_URL}/v2.1/accounts/{ACCOUNT_ID}/templates" + + +def _update_url(template_id): + return f"{BASE_URL}/v2.1/accounts/{ACCOUNT_ID}/templates/{template_id}" + + +@rsps_lib.activate +def test_creates_when_no_match(template_file): + """No existing templates with this name → POST called, new ID returned.""" + new_id = "new-template-abc" + + rsps_lib.add(rsps_lib.GET, _list_url(), json={"envelopeTemplates": []}, status=200) + rsps_lib.add(rsps_lib.POST, _list_url(), json={"templateId": new_id}, status=201) + + with patch.object(upload_docusign_template, "get_access_token", return_value="fake-token"): + result = upload_docusign_template.upload_template(template_file) + + assert result == new_id + methods = [c.request.method for c in rsps_lib.calls] + assert methods == ["GET", "POST"] + + +@rsps_lib.activate +def test_updates_most_recent_when_match(template_file): + """Two exact-name matches → PUT called on the most recently modified one.""" + older_id = "template-older" + newer_id = "template-newer" + + existing = [ + {"templateId": older_id, "name": TEMPLATE_NAME, "lastModified": "2026-04-10T10:00:00.000Z"}, + {"templateId": newer_id, "name": TEMPLATE_NAME, "lastModified": "2026-04-15T10:00:00.000Z"}, + ] + rsps_lib.add(rsps_lib.GET, _list_url(), json={"envelopeTemplates": existing}, status=200) + rsps_lib.add(rsps_lib.PUT, _update_url(newer_id), json={}, status=200) + + with patch.object(upload_docusign_template, "get_access_token", return_value="fake-token"): + result = upload_docusign_template.upload_template(template_file) + + assert result == newer_id + put_calls = [c for c in rsps_lib.calls if c.request.method == "PUT"] + assert len(put_calls) == 1 + assert newer_id in put_calls[0].request.url + + +@rsps_lib.activate +def test_force_create_bypasses_upsert(template_file): + """force_create=True → always POST, no GET for existing templates.""" + new_id = "force-created-id" + + rsps_lib.add(rsps_lib.POST, _list_url(), json={"templateId": new_id}, status=201) + + with patch.object(upload_docusign_template, "get_access_token", return_value="fake-token"): + result = upload_docusign_template.upload_template(template_file, force_create=True) + + assert result == new_id + get_calls = [c for c in rsps_lib.calls if c.request.method == "GET"] + assert len(get_calls) == 0 + post_calls = [c for c in rsps_lib.calls if c.request.method == "POST"] + assert len(post_calls) == 1 + + +@rsps_lib.activate +def test_partial_name_match_ignored(template_file): + """DocuSign search_text is substring; we must reject partial-name results and POST.""" + partial_id = "partial-match-id" + + existing = [ + {"templateId": partial_id, "name": "My NDA Template (Copy)", "lastModified": "2026-04-15T10:00:00.000Z"}, + ] + rsps_lib.add(rsps_lib.GET, _list_url(), json={"envelopeTemplates": existing}, status=200) + new_id = "created-new-id" + rsps_lib.add(rsps_lib.POST, _list_url(), json={"templateId": new_id}, status=201) + + with patch.object(upload_docusign_template, "get_access_token", return_value="fake-token"): + result = upload_docusign_template.upload_template(template_file) + + assert result == new_id + put_calls = [c for c in rsps_lib.calls if c.request.method == "PUT"] + assert len(put_calls) == 0 diff --git a/web/__init__.py b/web/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/web/app.py b/web/app.py new file mode 100644 index 0000000..7fd6ca6 --- /dev/null +++ b/web/app.py @@ -0,0 +1,47 @@ +""" +web/app.py +---------- +FastAPI entrypoint for the Adobe Sign → DocuSign Migrator web app. + +Run with: + uvicorn web.app:app --reload --port 8000 + +From the project root. +""" + +from fastapi import FastAPI +from fastapi.staticfiles import StaticFiles +from fastapi.responses import FileResponse +import os + +from web.config import settings +from web.routers import auth, templates, migrate + +app = FastAPI( + title="Adobe Sign → DocuSign Migrator", + version=settings.version, + docs_url="/api/docs", +) + +# Routers +app.include_router(auth.router, prefix="/api/auth", tags=["auth"]) +app.include_router(templates.router, prefix="/api/templates", tags=["templates"]) +app.include_router(migrate.router, prefix="/api/migrate", tags=["migrate"]) + +# Static files (frontend) +_static_dir = os.path.join(os.path.dirname(__file__), "static") +if os.path.isdir(_static_dir): + app.mount("/static", StaticFiles(directory=_static_dir), name="static") + + +@app.get("/health", tags=["health"]) +def health(): + return {"status": "ok", "version": settings.version} + + +@app.get("/", include_in_schema=False) +def index(): + index_path = os.path.join(_static_dir, "index.html") + if os.path.exists(index_path): + return FileResponse(index_path) + return {"message": "Adobe Sign → DocuSign Migrator API", "docs": "/api/docs"} diff --git a/web/config.py b/web/config.py new file mode 100644 index 0000000..db86b74 --- /dev/null +++ b/web/config.py @@ -0,0 +1,36 @@ +""" +web/config.py +------------- +Environment-based configuration for the web app. +All values come from .env or environment variables. +""" + +import os +from dotenv import load_dotenv + +load_dotenv() + + +class Settings: + # Adobe Sign OAuth + adobe_client_id: str = os.getenv("ADOBE_CLIENT_ID", "") + adobe_client_secret: str = os.getenv("ADOBE_CLIENT_SECRET", "") + adobe_redirect_uri: str = os.getenv("ADOBE_REDIRECT_URI", "http://localhost:8000/api/auth/adobe/callback") + adobe_sign_base_url: str = os.getenv("ADOBE_SIGN_BASE_URL", "https://api.eu2.adobesign.com/api/rest/v6") + + # DocuSign OAuth + docusign_client_id: str = os.getenv("DOCUSIGN_CLIENT_ID", "") + docusign_client_secret: str = os.getenv("DOCUSIGN_CLIENT_SECRET", "") + docusign_redirect_uri: str = os.getenv("DOCUSIGN_REDIRECT_URI", "http://localhost:8000/api/auth/docusign/callback") + docusign_account_id: str = os.getenv("DOCUSIGN_ACCOUNT_ID", "") + docusign_base_url: str = os.getenv("DOCUSIGN_BASE_URL", "https://demo.docusign.net/restapi") + docusign_auth_server: str = os.getenv("DOCUSIGN_AUTH_SERVER", "account-d.docusign.com") + + # Session + session_secret_key: str = os.getenv("SESSION_SECRET_KEY", "dev-secret-change-in-production") + + # App + version: str = "2.0" + + +settings = Settings() diff --git a/web/routers/__init__.py b/web/routers/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/web/routers/auth.py b/web/routers/auth.py new file mode 100644 index 0000000..fc3eaee --- /dev/null +++ b/web/routers/auth.py @@ -0,0 +1,153 @@ +""" +web/routers/auth.py +------------------- +OAuth endpoints for Adobe Sign and DocuSign. + +Adobe Sign: Authorization Code flow +DocuSign: Authorization Code flow (demo sandbox) + +Tokens are stored in a signed session cookie. +""" + +import httpx +from fastapi import APIRouter, Request +from fastapi.responses import JSONResponse, RedirectResponse + +from web.config import settings +from web.session import get_session, save_session, clear_session + +router = APIRouter() + + +# --------------------------------------------------------------------------- +# Status +# --------------------------------------------------------------------------- + +@router.get("/status") +def auth_status(request: Request): + """Returns which platforms the current session is connected to.""" + session = get_session(request) + return { + "adobe": bool(session.get("adobe_access_token")), + "docusign": bool(session.get("docusign_access_token")), + } + + +# --------------------------------------------------------------------------- +# Adobe Sign +# --------------------------------------------------------------------------- + +@router.get("/adobe/start") +def adobe_start(): + """Redirect the browser to the Adobe Sign OAuth authorization page.""" + params = ( + f"?response_type=code" + f"&client_id={settings.adobe_client_id}" + f"&redirect_uri={settings.adobe_redirect_uri}" + f"&scope=library_read:self+library_write:self+user_read:self" + ) + auth_url = "https://secure.eu2.adobesign.com/public/oauth/v2" + params + return RedirectResponse(auth_url) + + +@router.get("/adobe/callback") +async def adobe_callback(request: Request, code: str = ""): + """Exchange authorization code for access + refresh tokens.""" + if not code: + return JSONResponse({"error": "missing code"}, status_code=400) + + async with httpx.AsyncClient() as client: + resp = await client.post( + "https://api.eu2.adobesign.com/oauth/v2/token", + data={ + "grant_type": "authorization_code", + "client_id": settings.adobe_client_id, + "client_secret": settings.adobe_client_secret, + "redirect_uri": settings.adobe_redirect_uri, + "code": code, + }, + ) + + if not resp.is_success: + return JSONResponse({"error": "token exchange failed", "detail": resp.text}, status_code=502) + + token_data = resp.json() + session = get_session(request) + session["adobe_access_token"] = token_data.get("access_token") + session["adobe_refresh_token"] = token_data.get("refresh_token") + + response = RedirectResponse("/") + save_session(response, session) + return response + + +@router.get("/adobe/disconnect") +def adobe_disconnect(request: Request): + session = get_session(request) + session.pop("adobe_access_token", None) + session.pop("adobe_refresh_token", None) + response = JSONResponse({"disconnected": "adobe"}) + save_session(response, session) + return response + + +# --------------------------------------------------------------------------- +# DocuSign +# --------------------------------------------------------------------------- + +@router.get("/docusign/start") +def docusign_start(): + """Redirect the browser to the DocuSign OAuth authorization page.""" + params = ( + f"?response_type=code" + f"&scope=signature" + f"&client_id={settings.docusign_client_id}" + f"&redirect_uri={settings.docusign_redirect_uri}" + ) + auth_url = f"https://{settings.docusign_auth_server}/oauth/auth" + params + return RedirectResponse(auth_url) + + +@router.get("/docusign/callback") +async def docusign_callback(request: Request, code: str = ""): + """Exchange authorization code for access token.""" + if not code: + return JSONResponse({"error": "missing code"}, status_code=400) + + import base64 + credentials = base64.b64encode( + f"{settings.docusign_client_id}:{settings.docusign_client_secret}".encode() + ).decode() + + async with httpx.AsyncClient() as client: + resp = await client.post( + f"https://{settings.docusign_auth_server}/oauth/token", + headers={"Authorization": f"Basic {credentials}"}, + data={ + "grant_type": "authorization_code", + "code": code, + "redirect_uri": settings.docusign_redirect_uri, + }, + ) + + if not resp.is_success: + return JSONResponse({"error": "token exchange failed", "detail": resp.text}, status_code=502) + + token_data = resp.json() + session = get_session(request) + session["docusign_access_token"] = token_data.get("access_token") + session["docusign_refresh_token"] = token_data.get("refresh_token") + + response = RedirectResponse("/") + save_session(response, session) + return response + + +@router.get("/docusign/disconnect") +def docusign_disconnect(request: Request): + session = get_session(request) + session.pop("docusign_access_token", None) + session.pop("docusign_refresh_token", None) + response = JSONResponse({"disconnected": "docusign"}) + save_session(response, session) + return response diff --git a/web/routers/migrate.py b/web/routers/migrate.py new file mode 100644 index 0000000..5c93955 --- /dev/null +++ b/web/routers/migrate.py @@ -0,0 +1,257 @@ +""" +web/routers/migrate.py +---------------------- +Migration trigger and history endpoints. + +POST /api/migrate — run the pipeline for one or more Adobe template IDs +GET /api/migrate/history — return past migration records +""" + +import asyncio +import json +import os +import sys +import tempfile +from datetime import datetime, timezone +from typing import List, Optional + +import httpx +from fastapi import APIRouter, Request +from fastapi.responses import JSONResponse +from pydantic import BaseModel + +from web.config import settings +from web.session import get_session + +# Ensure src/ is on path +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "src")) + +router = APIRouter() + +_HISTORY_FILE = os.path.join( + os.path.dirname(__file__), "..", "..", "migration-output", ".history.json" +) + + +class MigrateRequest(BaseModel): + adobe_template_ids: List[str] + + +def _load_history() -> list: + if not os.path.exists(_HISTORY_FILE): + return [] + with open(_HISTORY_FILE) as f: + return json.load(f) + + +def _save_history(records: list) -> None: + os.makedirs(os.path.dirname(_HISTORY_FILE), exist_ok=True) + with open(_HISTORY_FILE, "w") as f: + json.dump(records, f, indent=2) + + +def _load_compose(): + """ + Dynamically load and return the compose_template function from src/. + Isolated in its own function so tests can patch it without touching the file system. + """ + import importlib.util + spec = importlib.util.spec_from_file_location( + "compose_docusign_template", + os.path.join(os.path.dirname(__file__), "..", "..", "src", "compose_docusign_template.py"), + ) + compose_mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(compose_mod) + return compose_mod.compose_template + + +async def _download_adobe_template(template_id: str, access_token: str, output_dir: str) -> bool: + """Download Adobe Sign template files into output_dir. Returns True on success.""" + headers = {"Authorization": f"Bearer {access_token}"} + base = settings.adobe_sign_base_url + + async with httpx.AsyncClient() as client: + # Metadata + meta_resp = await client.get(f"{base}/libraryDocuments/{template_id}", headers=headers) + if not meta_resp.is_success: + return False + metadata = meta_resp.json() + + # Form fields + fields_resp = await client.get(f"{base}/libraryDocuments/{template_id}/formFields", headers=headers) + form_fields = fields_resp.json() if fields_resp.is_success else {"fields": []} + + # Documents list + docs_resp = await client.get(f"{base}/libraryDocuments/{template_id}/documents", headers=headers) + documents = docs_resp.json() if docs_resp.is_success else {"documents": []} + + # Download first PDF + doc_list = documents.get("documents", []) + pdf_bytes = b"" + if doc_list: + doc_id = doc_list[0].get("id") + pdf_resp = await client.get(f"{base}/libraryDocuments/{template_id}/documents/{doc_id}", headers=headers) + if pdf_resp.is_success: + pdf_bytes = pdf_resp.content + + os.makedirs(output_dir, exist_ok=True) + with open(os.path.join(output_dir, "metadata.json"), "w") as f: + json.dump(metadata, f, indent=2) + with open(os.path.join(output_dir, "form_fields.json"), "w") as f: + json.dump(form_fields, f, indent=2) + with open(os.path.join(output_dir, "documents.json"), "w") as f: + json.dump(documents, f, indent=2) + if pdf_bytes: + pdf_name = doc_list[0].get("name", "document.pdf") if doc_list else "document.pdf" + if not pdf_name.endswith(".pdf"): + pdf_name += ".pdf" + with open(os.path.join(output_dir, pdf_name), "wb") as f: + f.write(pdf_bytes) + + return True + + +async def _migrate_one( + adobe_id: str, + adobe_access_token: str, + docusign_access_token: str, +) -> dict: + """Run the full pipeline for one Adobe template. Returns a result record.""" + timestamp = datetime.now(timezone.utc).isoformat() + + with tempfile.TemporaryDirectory() as tmpdir: + download_dir = os.path.join(tmpdir, "download") + output_dir = os.path.join(tmpdir, "output") + + # 1. Download + ok = await _download_adobe_template(adobe_id, adobe_access_token, download_dir) + if not ok: + return { + "timestamp": timestamp, + "adobe_template_id": adobe_id, + "adobe_template_name": None, + "docusign_template_id": None, + "action": None, + "status": "failed", + "error": "Adobe Sign download failed", + } + + # Read template name from metadata + with open(os.path.join(download_dir, "metadata.json")) as f: + metadata = json.load(f) + template_name = metadata.get("name", adobe_id) + + # 2. Compose DocuSign template JSON + composed_file = os.path.join(tmpdir, "docusign-template.json") + try: + compose_fn = _load_compose() + compose_fn(download_dir, composed_file) + except Exception as exc: + return { + "timestamp": timestamp, + "adobe_template_id": adobe_id, + "adobe_template_name": template_name, + "docusign_template_id": None, + "action": None, + "status": "failed", + "error": f"Compose failed: {exc}", + } + if not os.path.exists(composed_file): + return { + "timestamp": timestamp, + "adobe_template_id": adobe_id, + "adobe_template_name": template_name, + "docusign_template_id": None, + "action": None, + "status": "failed", + "error": "Compose produced no output file", + } + + # 3. Upload (upsert) to DocuSign using web session token + with open(composed_file) as f: + template_json = json.load(f) + + ds_headers = { + "Authorization": f"Bearer {docusign_access_token}", + "Content-Type": "application/json", + "Accept": "application/json", + } + list_url = f"{settings.docusign_base_url}/v2.1/accounts/{settings.docusign_account_id}/templates" + + async with httpx.AsyncClient() as client: + # Find existing + list_resp = await client.get( + list_url, headers=ds_headers, params={"search_text": template_name, "count": 100} + ) + existing_id = None + if list_resp.is_success: + raw = list_resp.json().get("envelopeTemplates") or list_resp.json().get("templates") or [] + exact = [t for t in raw if t.get("name") == template_name] + if exact: + exact.sort(key=lambda t: t.get("lastModified", ""), reverse=True) + existing_id = exact[0]["templateId"] + + if existing_id: + up_resp = await client.put( + f"{list_url}/{existing_id}", headers=ds_headers, json=template_json + ) + action = "updated" + template_id = existing_id + else: + up_resp = await client.post(list_url, headers=ds_headers, json=template_json) + action = "created" + template_id = up_resp.json().get("templateId") if up_resp.is_success else None + + if not up_resp.is_success: + return { + "timestamp": timestamp, + "adobe_template_id": adobe_id, + "adobe_template_name": template_name, + "docusign_template_id": None, + "action": None, + "status": "failed", + "error": f"DocuSign upload failed ({up_resp.status_code}): {up_resp.text[:200]}", + } + + return { + "timestamp": timestamp, + "adobe_template_id": adobe_id, + "adobe_template_name": template_name, + "docusign_template_id": template_id, + "action": action, + "status": "success", + "error": None, + } + + +@router.post("") +async def run_migration(body: MigrateRequest, request: Request): + """Migrate one or more Adobe Sign templates to DocuSign.""" + session = get_session(request) + if not session.get("adobe_access_token"): + return JSONResponse({"error": "not authenticated to Adobe Sign"}, status_code=401) + if not session.get("docusign_access_token"): + return JSONResponse({"error": "not authenticated to DocuSign"}, status_code=401) + + tasks = [ + _migrate_one( + aid, + session["adobe_access_token"], + session["docusign_access_token"], + ) + for aid in body.adobe_template_ids + ] + results = await asyncio.gather(*tasks) + + # Append to history + history = _load_history() + history.extend(results) + _save_history(history) + + return {"results": list(results)} + + +@router.get("/history") +def migration_history(): + """Return all past migration records.""" + return {"history": _load_history()} diff --git a/web/routers/templates.py b/web/routers/templates.py new file mode 100644 index 0000000..141cae7 --- /dev/null +++ b/web/routers/templates.py @@ -0,0 +1,167 @@ +""" +web/routers/templates.py +------------------------ +Template listing endpoints for Adobe Sign and DocuSign. +Computes per-template migration status for the side-by-side UI. +""" + +from datetime import datetime, timezone +from typing import Optional + +import httpx +from fastapi import APIRouter, Request +from fastapi.responses import JSONResponse + +from web.config import settings +from web.session import get_session + +router = APIRouter() + + +def _require_adobe(session: dict) -> Optional[JSONResponse]: + if not session.get("adobe_access_token"): + return JSONResponse({"error": "not authenticated to Adobe Sign"}, status_code=401) + return None + + +def _require_docusign(session: dict) -> Optional[JSONResponse]: + if not session.get("docusign_access_token"): + return JSONResponse({"error": "not authenticated to DocuSign"}, status_code=401) + return None + + +@router.get("/adobe") +async def list_adobe_templates(request: Request): + """List all Adobe Sign library documents (templates) for the current user.""" + session = get_session(request) + err = _require_adobe(session) + if err: + return err + + async with httpx.AsyncClient() as client: + resp = await client.get( + f"{settings.adobe_sign_base_url}/libraryDocuments", + headers={"Authorization": f"Bearer {session['adobe_access_token']}"}, + params={"pageSize": 100}, + ) + + if not resp.is_success: + return JSONResponse({"error": "Adobe Sign API error", "detail": resp.text}, status_code=502) + + data = resp.json() + templates = [ + { + "id": t.get("id"), + "name": t.get("name"), + "modifiedDate": t.get("modifiedDate"), + "sharingMode": t.get("sharingMode"), + } + for t in data.get("libraryDocumentList", []) + ] + return {"templates": templates} + + +@router.get("/docusign") +async def list_docusign_templates(request: Request): + """List all DocuSign templates for the account.""" + session = get_session(request) + err = _require_docusign(session) + if err: + return err + + async with httpx.AsyncClient() as client: + resp = await client.get( + f"{settings.docusign_base_url}/v2.1/accounts/{settings.docusign_account_id}/templates", + headers={"Authorization": f"Bearer {session['docusign_access_token']}"}, + params={"count": 100}, + ) + + if not resp.is_success: + return JSONResponse({"error": "DocuSign API error", "detail": resp.text}, status_code=502) + + data = resp.json() + raw = data.get("envelopeTemplates") or data.get("templates") or [] + templates = [ + { + "id": t.get("templateId"), + "name": t.get("name"), + "lastModified": t.get("lastModified"), + } + for t in raw + ] + return {"templates": templates} + + +@router.get("/status") +async def template_status(request: Request): + """ + Merged view: each Adobe template tagged with migration status. + + Status values: + not_migrated — no DocuSign template with the same name + migrated — at least one exact name match in DocuSign + needs_update — name match exists but Adobe template is newer + """ + session = get_session(request) + err = _require_adobe(session) or _require_docusign(session) + if err: + return err + + # Fetch both lists concurrently + async with httpx.AsyncClient() as client: + adobe_resp, ds_resp = await asyncio.gather( + client.get( + f"{settings.adobe_sign_base_url}/libraryDocuments", + headers={"Authorization": f"Bearer {session['adobe_access_token']}"}, + params={"pageSize": 100}, + ), + client.get( + f"{settings.docusign_base_url}/v2.1/accounts/{settings.docusign_account_id}/templates", + headers={"Authorization": f"Bearer {session['docusign_access_token']}"}, + params={"count": 100}, + ), + ) + + if not adobe_resp.is_success: + return JSONResponse({"error": "Adobe Sign API error"}, status_code=502) + if not ds_resp.is_success: + return JSONResponse({"error": "DocuSign API error"}, status_code=502) + + adobe_templates = adobe_resp.json().get("libraryDocumentList", []) + ds_raw = ds_resp.json().get("envelopeTemplates") or ds_resp.json().get("templates") or [] + + # Build a name → most-recently-modified DocuSign template lookup + ds_by_name: dict[str, dict] = {} + for t in ds_raw: + name = t.get("name", "") + existing = ds_by_name.get(name) + if not existing or t.get("lastModified", "") > existing.get("lastModified", ""): + ds_by_name[name] = t + + results = [] + for t in adobe_templates: + name = t.get("name", "") + adobe_modified = t.get("modifiedDate", "") + ds_match = ds_by_name.get(name) + + if not ds_match: + status = "not_migrated" + else: + ds_modified = ds_match.get("lastModified", "") + # needs_update if Adobe was modified after the DS template + status = "needs_update" if adobe_modified > ds_modified else "migrated" + + results.append({ + "adobe_id": t.get("id"), + "name": name, + "adobe_modified": adobe_modified, + "docusign_id": ds_match.get("templateId") if ds_match else None, + "docusign_modified": ds_match.get("lastModified") if ds_match else None, + "status": status, + }) + + return {"templates": results} + + +# asyncio needed for gather — import at top of module +import asyncio diff --git a/web/session.py b/web/session.py new file mode 100644 index 0000000..7a55cc4 --- /dev/null +++ b/web/session.py @@ -0,0 +1,45 @@ +""" +web/session.py +-------------- +Session helpers using signed cookies (itsdangerous). +Stores Adobe Sign and DocuSign tokens server-side in the cookie payload. + +Sessions are short-lived (1 hour) and signed but not encrypted. +Do not store sensitive secrets here beyond access tokens. +""" + +from itsdangerous import URLSafeTimedSerializer, BadSignature, SignatureExpired +from fastapi import Request, Response +from web.config import settings + +_serializer = URLSafeTimedSerializer(settings.session_secret_key) +_COOKIE_NAME = "migrator_session" +_MAX_AGE = 3600 # 1 hour + + +def get_session(request: Request) -> dict: + """Read and verify the session cookie. Returns an empty dict if missing or invalid.""" + raw = request.cookies.get(_COOKIE_NAME) + if not raw: + return {} + try: + return _serializer.loads(raw, max_age=_MAX_AGE) + except (BadSignature, SignatureExpired): + return {} + + +def save_session(response: Response, data: dict) -> None: + """Sign and write session data into a cookie on the response.""" + signed = _serializer.dumps(data) + response.set_cookie( + _COOKIE_NAME, + signed, + max_age=_MAX_AGE, + httponly=True, + samesite="lax", + ) + + +def clear_session(response: Response) -> None: + """Delete the session cookie.""" + response.delete_cookie(_COOKIE_NAME) diff --git a/web/static/app.js b/web/static/app.js new file mode 100644 index 0000000..c0040ac --- /dev/null +++ b/web/static/app.js @@ -0,0 +1,221 @@ +// Adobe Sign → DocuSign Migrator — frontend app +// Vanilla JS, no build step. + +const $ = id => document.getElementById(id); + +let adobeTemplates = []; // [{id, name, modifiedDate}] +let dsTemplates = []; // [{id, name, lastModified}] +let statusTemplates = []; // [{adobe_id, name, status, docusign_id, ...}] +let authState = { adobe: false, docusign: false }; + +// ── Init ──────────────────────────────────────────────────────────────────── + +document.addEventListener('DOMContentLoaded', async () => { + await refreshAuth(); + await refreshTemplates(); + await refreshHistory(); + + $('btn-migrate').addEventListener('click', onMigrate); + $('btn-refresh').addEventListener('click', async () => { + await refreshTemplates(); + await refreshHistory(); + }); +}); + +// ── Auth ───────────────────────────────────────────────────────────────────── + +async function refreshAuth() { + const resp = await fetch('/api/auth/status'); + authState = await resp.json(); + renderAuthBar(); +} + +function renderAuthBar() { + renderAuthBadge('badge-adobe', 'Adobe Sign', authState.adobe, '/api/auth/adobe/start', '/api/auth/adobe/disconnect'); + renderAuthBadge('badge-docusign', 'DocuSign', authState.docusign, '/api/auth/docusign/start', '/api/auth/docusign/disconnect'); +} + +function renderAuthBadge(id, label, connected, connectUrl, disconnectUrl) { + const el = $(id); + el.textContent = connected ? `✓ ${label}` : `Connect ${label}`; + el.className = 'auth-badge' + (connected ? ' connected' : ''); + el.onclick = () => { + if (connected) { + fetch(disconnectUrl).then(() => { authState[id.replace('badge-','')] = false; renderAuthBar(); refreshTemplates(); }); + } else { + window.location.href = connectUrl; + } + }; +} + +// ── Templates ──────────────────────────────────────────────────────────────── + +async function refreshTemplates() { + renderAdobeList([]); + renderDsList([]); + + if (!authState.adobe || !authState.docusign) { + setStatus(authState.adobe || authState.docusign + ? 'Connect both platforms to see migration status.' + : 'Connect Adobe Sign and DocuSign to get started.'); + $('btn-migrate').disabled = true; + return; + } + + setStatus('Loading templates…'); + + try { + const [statusResp, dsResp] = await Promise.all([ + fetch('/api/templates/status'), + fetch('/api/templates/docusign'), + ]); + statusTemplates = (await statusResp.json()).templates || []; + dsTemplates = ((await dsResp.json()).templates || []); + renderAdobeList(statusTemplates); + renderDsList(dsTemplates); + setStatus(`${statusTemplates.length} Adobe template(s) loaded.`); + } catch (e) { + setStatus('Error loading templates: ' + e.message); + } +} + +function renderAdobeList(items) { + const ul = $('adobe-list'); + if (!items.length) { + ul.innerHTML = '
  • No templates found.
    • '; + return; + } + ul.innerHTML = items.map(t => ` +
  • + + ${escHtml(t.name)} + ${statusLabel(t.status)} + +
    • + `).join(''); + + ul.querySelectorAll('.template-item').forEach(li => { + li.addEventListener('click', e => { + if (e.target.type === 'checkbox') return; + const cb = li.querySelector('input[type=checkbox]'); + cb.checked = !cb.checked; + li.classList.toggle('selected', cb.checked); + updateMigrateButton(); + }); + li.querySelector('input').addEventListener('change', () => { + li.classList.toggle('selected', li.querySelector('input').checked); + updateMigrateButton(); + }); + }); +} + +function renderDsList(items) { + const ul = $('ds-list'); + if (!items.length) { + ul.innerHTML = '
  • No templates found.
    • '; + return; + } + ul.innerHTML = items.map(t => ` +
  • + ${escHtml(t.name)} + ${(t.lastModified || '').slice(0, 10)} +
    • + `).join(''); +} + +function updateMigrateButton() { + const checked = document.querySelectorAll('#adobe-list input[type=checkbox]:checked'); + $('btn-migrate').disabled = checked.length === 0; +} + +// ── Migration ───────────────────────────────────────────────────────────────── + +async function onMigrate() { + const checked = [...document.querySelectorAll('#adobe-list input[type=checkbox]:checked')]; + const ids = checked.map(cb => cb.dataset.id); + if (!ids.length) return; + + $('btn-migrate').disabled = true; + setStatus(`Migrating ${ids.length} template(s)…`); + + // Show spinners + ids.forEach(id => { + const spin = $('spin-' + id); + if (spin) spin.textContent = '⏳'; + }); + + try { + const resp = await fetch('/api/migrate', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ adobe_template_ids: ids }), + }); + const data = await resp.json(); + + let successCount = 0; + (data.results || []).forEach(r => { + const spin = $('spin-' + r.adobe_template_id); + if (r.status === 'success') { + successCount++; + if (spin) spin.textContent = r.action === 'updated' ? '✏️' : '✅'; + } else { + if (spin) spin.textContent = '❌'; + } + }); + + setStatus(`Done: ${successCount}/${ids.length} succeeded.`); + await refreshTemplates(); + await refreshHistory(); + } catch (e) { + setStatus('Migration error: ' + e.message); + } +} + +// ── History ─────────────────────────────────────────────────────────────────── + +async function refreshHistory() { + try { + const resp = await fetch('/api/migrate/history'); + const { history } = await resp.json(); + renderHistory(history || []); + } catch { + renderHistory([]); + } +} + +function renderHistory(records) { + const tbody = $('history-tbody'); + if (!records.length) { + tbody.innerHTML = 'No migrations yet.'; + return; + } + tbody.innerHTML = [...records].reverse().slice(0, 50).map(r => ` + + ${(r.timestamp || '').replace('T', ' ').slice(0, 19)} + ${escHtml(r.adobe_template_name || r.adobe_template_id || '')} + ${escHtml(r.docusign_template_id || '—')} + ${escHtml(r.action || '—')} + + + ${r.status} + + + + `).join(''); +} + +// ── Utilities ───────────────────────────────────────────────────────────────── + +function setStatus(msg) { $('status-msg').textContent = msg; } + +function statusLabel(s) { + return { not_migrated: 'Not Migrated', migrated: 'Migrated', needs_update: 'Needs Update' }[s] || s; +} + +function escHtml(str) { + return String(str) + .replace(/&/g, '&') + .replace(//g, '>') + .replace(/"/g, '"'); +} diff --git a/web/static/index.html b/web/static/index.html new file mode 100644 index 0000000..dbcb4c1 --- /dev/null +++ b/web/static/index.html @@ -0,0 +1,79 @@ + + + + + + Adobe Sign → DocuSign Migrator + + + + +
    +

    Adobe Sign → DocuSign Migrator

    +
    + Connect Adobe Sign + Connect DocuSign +
    +
    + +
    + + +
    + + + Loading… +
    + + +
    + +
    +
    + Adobe Sign Templates + Select to migrate → +
    +
    +
      +
    • Loading…
      • +
    +
    +
    + +
    +
    + DocuSign Templates +
    +
    +
      +
    • Loading…
      • +
    +
    +
    + +
    + + +
    +
    Migration History
    + + + + + + + + + + + + + +
    TimeAdobe TemplateDocuSign Template IDActionStatus
    No migrations yet.
    +
    + +
    + + + + diff --git a/web/static/style.css b/web/static/style.css new file mode 100644 index 0000000..28e940b --- /dev/null +++ b/web/static/style.css @@ -0,0 +1,153 @@ +* { box-sizing: border-box; margin: 0; padding: 0; } + +body { + font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; + background: #f5f5f5; + color: #222; + font-size: 14px; +} + +/* ── Header ── */ +header { + background: #1a3c5e; + color: #fff; + padding: 14px 24px; + display: flex; + align-items: center; + justify-content: space-between; +} +header h1 { font-size: 18px; font-weight: 600; } +#auth-bar { display: flex; gap: 12px; align-items: center; font-size: 13px; } +.auth-badge { + padding: 4px 10px; + border-radius: 12px; + border: 1px solid rgba(255,255,255,0.4); + cursor: pointer; + transition: background 0.15s; +} +.auth-badge.connected { background: #28a745; border-color: #28a745; } +.auth-badge:not(.connected):hover { background: rgba(255,255,255,0.15); } + +/* ── Main layout ── */ +main { padding: 20px 24px; } + +.panel-row { + display: grid; + grid-template-columns: 1fr 1fr; + gap: 16px; + margin-bottom: 20px; +} + +.panel { + background: #fff; + border: 1px solid #ddd; + border-radius: 6px; + overflow: hidden; +} + +.panel-header { + padding: 12px 16px; + background: #f8f9fa; + border-bottom: 1px solid #ddd; + display: flex; + justify-content: space-between; + align-items: center; + font-weight: 600; + font-size: 13px; + color: #555; + text-transform: uppercase; + letter-spacing: 0.04em; +} + +.panel-body { padding: 0; } + +/* ── Template list ── */ +.template-list { list-style: none; } + +.template-item { + display: flex; + align-items: center; + gap: 10px; + padding: 10px 16px; + border-bottom: 1px solid #f0f0f0; + cursor: pointer; + transition: background 0.1s; +} +.template-item:last-child { border-bottom: none; } +.template-item:hover { background: #f9f9f9; } +.template-item.selected { background: #eef4ff; } + +.template-item input[type=checkbox] { flex-shrink: 0; } + +.template-name { flex: 1; font-size: 13px; } + +/* ── Status badges ── */ +.badge { + font-size: 11px; + font-weight: 600; + padding: 2px 8px; + border-radius: 10px; + white-space: nowrap; +} +.badge-migrated { background: #d4edda; color: #155724; } +.badge-needs_update { background: #fff3cd; color: #856404; } +.badge-not_migrated { background: #f8d7da; color: #721c24; } + +.template-spinner { font-size: 12px; color: #888; } + +/* ── Action bar ── */ +.action-bar { + display: flex; + align-items: center; + gap: 12px; + margin-bottom: 20px; +} + +button { + padding: 8px 18px; + border: none; + border-radius: 5px; + cursor: pointer; + font-size: 13px; + font-weight: 600; + transition: opacity 0.15s; +} +button:disabled { opacity: 0.45; cursor: not-allowed; } + +#btn-migrate { background: #1a3c5e; color: #fff; } +#btn-migrate:not(:disabled):hover { background: #235080; } + +#btn-refresh { background: #e9ecef; color: #333; } +#btn-refresh:hover { background: #dee2e6; } + +#status-msg { font-size: 13px; color: #555; } + +/* ── History ── */ +.history-section { background: #fff; border: 1px solid #ddd; border-radius: 6px; } +.history-section .panel-header { background: #f8f9fa; } + +.history-table { + width: 100%; + border-collapse: collapse; + font-size: 13px; +} +.history-table th { + text-align: left; + padding: 8px 14px; + background: #f8f9fa; + border-bottom: 1px solid #ddd; + font-weight: 600; + color: #555; +} +.history-table td { + padding: 8px 14px; + border-bottom: 1px solid #f0f0f0; +} +.history-table tr:last-child td { border-bottom: none; } + +.empty-msg { padding: 20px; text-align: center; color: #999; font-size: 13px; } + +/* ── Responsive ── */ +@media (max-width: 700px) { + .panel-row { grid-template-columns: 1fr; } +}