From 342e8c3471ccf8b11a2cca02647d5ee761d80b1d Mon Sep 17 00:00:00 2001 From: Paul Huliganga Date: Tue, 21 Apr 2026 02:19:38 -0400 Subject: [PATCH 01/24] =?UTF-8?q?feat(phases-8-13):=20blueprint=20alignmen?= =?UTF-8?q?t=20=E2=80=94=20normalized=20schema,=20validation,=20migration?= =?UTF-8?q?=20options,=20retry,=20security,=20batch?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase 8: Normalized intermediate schema (src/models/normalized_template.py, src/services/mapping_service.py) - Platform-agnostic NormalizedTemplate as pipeline bridge - PDF SHA-256 checksums computed during normalization - 13 tests passing Phase 9: Validation service + report builder (src/services/validation_service.py, src/reports/report_builder.py) - Blockers (no recipients, no documents) halt migration - Warnings (no fields, unassigned roles, unsupported features) logged - Structured MigrationReport with per-template status - 20 tests passing Phase 10: Migration options API (web/routers/migrate.py) - source_template_ids, dry_run, overwrite_if_exists, include_documents options - Backward compatible with legacy adobe_template_ids field - 7 tests passing Phase 11: Retry with exponential backoff (src/utils/retry.py) - retry_with_backoff and async_retry_with_backoff decorators - 429/5xx detection via check_response_retryable - 14 tests passing Phase 12: Security hardening (src/utils/log_sanitizer.py) - SanitizingFilter redacts tokens, JWTs, base64 PDF content from logs - 15 tests passing Phase 13: Batch migration API - POST /api/migrate/batch — async background job with job_id - GET /api/migrate/batch/{job_id} — poll progress and results - 6 tests passing Full suite: 108/108 tests passing Co-Authored-By: Claude Sonnet 4.6 --- PRODUCT-SPEC.md | 261 ++++++++++++++++++++++-- README.md | 92 +++++++-- docs/agent-harness/EXECUTION-BOARD.md | 75 ++++++- src/models/__init__.py | 0 src/models/normalized_template.py | 78 ++++++++ src/reports/__init__.py | 0 src/reports/report_builder.py | 134 +++++++++++++ src/services/__init__.py | 0 src/services/mapping_service.py | 275 ++++++++++++++++++++++++++ src/services/validation_service.py | 133 +++++++++++++ src/utils/__init__.py | 0 src/utils/log_sanitizer.py | 98 +++++++++ src/utils/retry.py | 102 ++++++++++ tests/test_api_migrate.py | 3 +- tests/test_batch_migration.py | 155 +++++++++++++++ tests/test_e2e.py | 3 +- tests/test_migration_options.py | 234 ++++++++++++++++++++++ tests/test_normalized_schema.py | 139 +++++++++++++ tests/test_retry.py | 152 ++++++++++++++ tests/test_security.py | 138 +++++++++++++ tests/test_validation_service.py | 181 +++++++++++++++++ web/routers/migrate.py | 233 ++++++++++++++++++++-- 22 files changed, 2433 insertions(+), 53 deletions(-) create mode 100644 src/models/__init__.py create mode 100644 src/models/normalized_template.py create mode 100644 src/reports/__init__.py create mode 100644 src/reports/report_builder.py create mode 100644 src/services/__init__.py create mode 100644 src/services/mapping_service.py create mode 100644 src/services/validation_service.py create mode 100644 src/utils/__init__.py create mode 100644 src/utils/log_sanitizer.py create mode 100644 src/utils/retry.py create mode 100644 tests/test_batch_migration.py create mode 100644 tests/test_migration_options.py create mode 100644 tests/test_normalized_schema.py create mode 100644 tests/test_retry.py create mode 100644 tests/test_security.py create mode 100644 tests/test_validation_service.py diff --git a/PRODUCT-SPEC.md b/PRODUCT-SPEC.md index 5cec66d..0bcdf18 100644 --- a/PRODUCT-SPEC.md +++ b/PRODUCT-SPEC.md @@ -1,9 +1,9 @@ -# Initial Product Spec (Draft) +# Product Specification ## Project: Adobe Sign to DocuSign Template Migrator ### Purpose -Develop an agent/toolkit that can programmatically extract template data and field logic from Adobe Sign (“library documents”), map/transform into DocuSign’s template model, and create new DocuSign templates to reduce manual migration effort. +Develop an agent/toolkit that can programmatically extract template data and field logic from Adobe Sign ("library documents"), map/transform into DocuSign's template model, and create new DocuSign templates to reduce manual migration effort. --- @@ -12,28 +12,249 @@ Develop an agent/toolkit that can programmatically extract template data and fie - Generate best-approximation DocuSign templates programmatically - Handle all basic field types and recipient roles - Detect and warn on features needing special/manual handling (complex logic, custom validations, non-mappable features) - -### Key Features (MVP) -- Connect to Adobe Sign and DocuSign APIs via credentials loaded from .env -- Extract template listing from Adobe Sign sandbox/account -- Pull all required endpoints: metadata, formFields, recipients, workflows -- Assemble complete data model for each imported template -- Mapping layer: field type/role/routing normalization (see field-mapping.md) -- Programmatically create equivalent template and roles in DocuSign -- Logging and reporting of success, errors, edge cases - -### Stretch (Future) -- UI for side-by-side compare/QA -- Complex feature transform plugins -- Bulk mode & idempotent re-runs -- Support for in-place PDF field overlay (anchors/rects) +- Produce a structured migration report with successes, warnings, and manual-fix items --- -#### Out of Scope (MVP) -- Agreement instance migration (focus on templates only) +### Architecture + +#### Components +- **Adobe Sign Client** (`src/adobe_api.py`) — authenticated API calls, template listing/download +- **DocuSign Client** (`src/upload_docusign_template.py`, `src/docusign_auth.py`) — JWT auth, template upsert +- **Normalized Schema Model** (`src/models/normalized_template.py`) — platform-agnostic intermediate representation +- **Mapping Service** (`src/services/mapping_service.py`) — field type, recipient role, coordinate translation +- **Validation Service** (`src/services/validation_service.py`) — field count comparison, recipient checks, missing role detection +- **Migration Service** (`src/services/migration_service.py`) — orchestrates download → normalize → validate → compose → upload +- **Report Builder** (`src/reports/report_builder.py`) — structured success/warning/error output +- **Web API** (`web/`) — FastAPI endpoints for browser-based orchestration +- **Frontend** (`web/static/`) — side-by-side template browser, migration UI + +#### Service Separation +``` +src/ + models/ + normalized_template.py # intermediate schema + services/ + migration_service.py # pipeline orchestration + mapping_service.py # field/role/coord transformations + validation_service.py # pre/post migration checks + reports/ + report_builder.py # structured report output + utils/ + pdf_coords.py # coordinate normalization helpers +``` + +--- + +### High-Level Migration Flow + +1. Authenticate to both Adobe Sign and DocuSign (OAuth) +2. List and select Adobe Sign templates +3. Extract: metadata, formFields, recipients, documents, workflows +4. **Normalize** into platform-agnostic intermediate schema +5. **Validate** normalized schema — blockers stop migration; warnings are logged +6. Map to DocuSign template payload +7. Upsert (create or update) in DocuSign +8. Generate migration report + +--- + +### Internal Normalized Schema + +Use an intermediate model so the tool is not tightly coupled to either platform. This enables future support for additional eSign platforms. + +#### Schema Structure +```json +{ + "template": { + "name": "Sales Agreement", + "description": "Migrated from Adobe Sign", + "emailSubject": "Please sign: Sales Agreement", + "emailMessage": "", + "documents": [], + "roles": [ + { "name": "Customer", "order": 1, "actionType": "SIGN" }, + { "name": "Company", "order": 2, "actionType": "SIGN" } + ], + "fields": [ + { + "type": "signature", + "page": 1, + "x": 120, "y": 540, + "width": 140, "height": 28, + "required": true, + "roleName": "Customer" + } + ], + "reminderEnabled": false, + "expirationDays": null + } +} +``` + +--- + +### Core Entities to Migrate + +| Entity | Adobe Sign Source | DocuSign Target | +|-------------------|-----------------------------|-----------------------------| +| Template name | `name` | `name` | +| Description | `message` | `description` | +| Documents (PDFs) | `libraryDocumentId` → bytes | `documents[]` | +| Recipient roles | `participantSetsInfo` | `recipients.signers[]` | +| Routing order | `participantSetsInfo.order` | `routingOrder` | +| Form fields | `formFields` | `tabs` per recipient | +| Email subject | `emailSubject` | `emailSubject` | +| Reminders | `reminderFrequency` | `reminders` | +| Expiration | `daysUntilSigningDeadline` | `expirationDateTime` | + +--- + +### Mapping Logic + +#### 1. Recipient and Role Mapping +- Map Adobe Sign participant sets → DocuSign template roles +- Preserve routing order +- Map action types: SIGN → signer, APPROVE → approver, CC → carbonCopy + +#### 2. Field Type Mapping +```json +{ + "SIGNATURE": "signHere", + "INITIALS": "initialHere", + "TEXT": "text", + "CHECKBOX": "checkbox", + "RADIO": "radioGroup", + "DROPDOWN": "list", + "DATE": "dateSigned", + "ATTACHMENT": "signerAttachment" +} +``` +(Full mapping table: see `field-mapping.md`) + +#### 3. Coordinate Mapping +- Normalize to PDF points +- Account for page rotation +- Transform coordinate origin if needed +- Validate field overlap after placement + +#### 4. DocuSign Payload Fields +The tool must populate: +- Template name and description +- Email subject and message defaults +- Envelope/template documents (with document checksums) +- Template roles with routing order +- Tabs grouped by recipient +- Reminder and expiration settings where supported + +--- + +### Unsupported / Flagged Features (Manual Review Required) +- Conditional recipient routing rules +- Advanced workflow branching +- Calculated fields +- Custom JavaScript validators +- Niche authentication methods (e.g., KBA, phone auth) +- Field validations with no direct DocuSign equivalent +- Webhook / event associations tied to template lifecycle + +--- + +### Migration Options (API) + +`POST /api/migrate` accepts: +```json +{ + "sourceTemplateIds": ["tpl_1001", "tpl_1002"], + "targetFolder": "Migrated Templates", + "options": { + "overwriteIfExists": false, + "dryRun": true, + "includeDocuments": true + } +} +``` + +- **dryRun** — validate and report without creating DocuSign templates +- **overwriteIfExists** — when `false`, skip templates already migrated (default: false) +- **includeDocuments** — embed PDFs in DocuSign template (default: true) +- **targetFolder** — DocuSign folder for created templates + +--- + +### Validation Layer + +Pre-migration checks (blockers and warnings): +- Field count before vs. after mapping +- Recipient count and routing order integrity +- Fields missing role assignments +- Unsupported feature detection +- Document checksum comparison (before upload vs. after download confirmation) + +Post-migration checks: +- DocuSign template field count vs. normalized schema count +- Recipient role count match +- Migration report includes pass/warn/fail per template + +--- + +### Implementation Considerations + +#### Authentication +- OAuth for both Adobe Sign and DocuSign (with token auto-refresh) +- Support admin-consent flows where required +- Securely store tokens (never in logs or plaintext files) + +#### Rate Limits +- Batch API requests carefully +- Retries with exponential backoff on 429/5xx +- Use idempotency (upsert pattern) where possible + +#### File Handling +- Preserve original PDFs locally in `downloads/` +- Checksum documents before and after upload +- Keep document-page metadata for accurate tab placement + +#### Security +- Redact secrets and tokens from all log output +- Encrypt token storage where possible +- Maintain audit trail for all migration operations (template ID, timestamp, status, user) + +--- + +### MVP Feature Set (Phase 1) +- Authenticate to both systems (CLI + Web) +- List and select Adobe Sign templates +- Migrate basic templates (standard roles + common fields) +- Normalized intermediate schema as pipeline bridge +- Validation layer (field/recipient counts, missing roles) +- Migration report (success / warning / error per template) +- Dry-run mode +- Idempotent re-runs (overwrite prevention) + +### Phase 2 Features +- Batch migration (multiple templates in one request) +- Retry failed templates +- Coordinate validation preview +- Duplicate detection +- Folder / category mapping +- Audit logging +- Rate limit handling with backoff + +### Phase 3 Features +- UI preview for field placements +- Manual correction workflow +- Side-by-side template comparison (visual diff) +- Webhook recreation +- Advanced workflow translation + +--- + +### Out of Scope (MVP) +- Agreement instance migration (templates only) - Custom integrations outside API surface +- Real-time collaborative editing --- -*Last updated: 2026-04-14 (scaffolded by Cleo)* +*Updated: 2026-04-21 (Blueprint alignment — added normalized schema, validation layer, migration options, security/rate-limit requirements, Phase 2/3 feature set, architecture detail)* diff --git a/README.md b/README.md index 5e8abc5..9f3d38a 100644 --- a/README.md +++ b/README.md @@ -135,7 +135,7 @@ Then open [http://localhost:8000](http://localhost:8000) in your browser. ## Running tests ```bash -pytest tests/ -v # full suite (29 tests) +pytest tests/ -v # full suite (108 tests) pytest tests/test_regression.py -v # compose regression only pytest tests/test_regression.py --update-snapshots # regenerate snapshots after intentional changes ``` @@ -154,10 +154,82 @@ unexpected API behaviors, and the fixes applied. --- +## Migration API options + +`POST /api/migrate` accepts extended options (blueprint-aligned): + +```json +{ + "source_template_ids": ["tpl_001", "tpl_002"], + "target_folder": "Migrated Templates", + "options": { + "dry_run": false, + "overwrite_if_exists": false, + "include_documents": true + } +} +``` + +| Option | Default | Description | +|---|---|---| +| `dry_run` | `false` | Validate and compose without creating DocuSign templates | +| `overwrite_if_exists` | `false` | If `false`, skip templates that already exist in DocuSign | +| `include_documents` | `true` | Embed PDFs in the DocuSign template | + +**Batch migration** (`POST /api/migrate/batch`) runs the same pipeline for multiple templates as a background job: + +```bash +# Start batch +curl -X POST /api/migrate/batch -d '{"source_template_ids": ["id1", "id2"]}' +# → {"job_id": "abc-123", "status": "queued"} + +# Poll status +curl /api/migrate/batch/abc-123 +# → {"status": "running", "progress": {"completed": 1, "total": 2}, ...} +``` + +--- + +## Normalized intermediate schema + +The migration pipeline uses a platform-agnostic `NormalizedTemplate` model as a bridge between Adobe Sign and DocuSign. This decouples extraction from composition and enables the validation layer. + +See `src/models/normalized_template.py` and `src/services/mapping_service.py`. + +--- + +## Validation + +Each template is validated before migration: +- **Blockers** (halt migration): no recipients, no documents +- **Warnings** (logged but continue): no signature fields, unassigned fields, unsupported features + +Unsupported features flagged for manual review: conditional HIDE actions, JavaScript validators, calculated fields, webhook associations, niche authentication methods. + +--- + +## Security + +- `src/utils/log_sanitizer.py` — install `SanitizingFilter` to redact tokens, keys, and base64 PDF content from all log output +- PDF checksums (SHA-256) are computed and stored with each migration record +- Tokens are never written to logs; see `src/utils/log_sanitizer.py` + +--- + ## Project structure ``` src/ + models/ + normalized_template.py # Platform-agnostic intermediate schema + services/ + mapping_service.py # Adobe Sign → NormalizedTemplate converter + validation_service.py # Pre/post migration checks (blockers + warnings) + reports/ + report_builder.py # Structured migration report per template + utils/ + retry.py # Exponential backoff retry helpers + log_sanitizer.py # Secret redaction from logs adobe_auth.py # One-time OAuth flow for Adobe Sign (CLI) adobe_api.py # Adobe Sign API client (auto token refresh) download_templates.py # List and download templates from Adobe Sign @@ -165,8 +237,6 @@ src/ docusign_auth.py # DocuSign JWT auth + one-time consent flow upload_docusign_template.py # Upsert upload: PUT if exists, POST if not migrate_template.py # End-to-end CLI runner (download → convert → upload) - create_adobe_template.py # Utility: create a test template in Adobe Sign - generate_pdfs.py # Utility: generate sample PDFs for offline testing web/ app.py # FastAPI entrypoint (uvicorn web.app:app) @@ -175,13 +245,19 @@ web/ routers/ auth.py # Adobe Sign + DocuSign OAuth endpoints templates.py # Template listing + migration status API - migrate.py # Migration trigger + history API + migrate.py # Migration trigger, batch, + history API static/ index.html # Web UI (side-by-side browser + migrate flow) app.js # Vanilla JS frontend style.css # Styles + status badge colours tests/ + test_normalized_schema.py # Normalized model + mapping service tests + test_validation_service.py # Validation service + report builder tests + test_migration_options.py # dryRun, overwriteIfExists, includeDocuments + test_batch_migration.py # Batch migration API tests + test_retry.py # Retry with backoff utility tests + test_security.py # Log sanitization + PDF checksum tests test_upload_upsert.py # Upsert logic unit tests test_api_health.py # Health endpoint test_api_auth.py # OAuth endpoint tests @@ -190,18 +266,12 @@ tests/ test_e2e.py # Full pipeline end-to-end test test_regression.py # Compose output vs snapshots fixtures/expected/ # Regression snapshots (3 real templates) - FIELD-TYPE-REGRESSION.md # Manual field type regression checklist - PLATFORM-QUIRKS.md # Known API bugs and workarounds downloads/ # Downloaded Adobe Sign templates (gitignored) migration-output/ # Converted DocuSign template JSONs + history -sample-templates/ # JSON fixtures for offline testing - field-mapping.md # Field type mapping table + edge case log -CLAUDE.md # Claude Code instructions for this project -docs/IMPLEMENTATION-PLAN.md # Feature design and test specifications +PRODUCT-SPEC.md # Full product specification (blueprint-aligned) docs/agent-harness/ EXECUTION-BOARD.md # Living kanban board - AGENT-INSTRUCTIONS.md # Definition of done + conventions requirements.txt # Python dependencies ``` diff --git a/docs/agent-harness/EXECUTION-BOARD.md b/docs/agent-harness/EXECUTION-BOARD.md index 27fbb4e..851fbbc 100644 --- a/docs/agent-harness/EXECUTION-BOARD.md +++ b/docs/agent-harness/EXECUTION-BOARD.md @@ -1,6 +1,6 @@ # Execution Board (Living Kanban) -*Last updated: 2026-04-17* +*Last updated: 2026-04-21* --- @@ -79,9 +79,80 @@ --- +## Phase 8 — Normalized Intermediate Schema ✅ (2026-04-21) + +- [x] Create `src/models/` package with `__init__.py` +- [x] Implement `src/models/normalized_template.py` — pydantic model with NormalizedTemplate, NormalizedField, NormalizedRole, NormalizedDocument +- [x] Implement `src/services/` package with `__init__.py` +- [x] Implement `src/services/mapping_service.py` — Adobe Sign folder → NormalizedTemplate converter with checksums +- [x] Write `tests/test_normalized_schema.py` — 13 tests passing (model construction, serialization, real fixture round-trips) +- [x] Update README + +--- + +## Phase 9 — Validation Service ✅ (2026-04-21) + +- [x] Implement `src/services/validation_service.py` — `ValidationResult(blockers, warnings)`, checks for no recipients, no documents, no fields, missing roles, unsupported features +- [x] Implement `src/reports/report_builder.py` — `MigrationReport`, `TemplateReport`, `MigrationStatus` enum, factory functions +- [x] Integrate validation into migration pipeline (`_run_validation` in `web/routers/migrate.py`) — blocks on blockers +- [x] Implement `compare_field_counts(normalized, ds_template)` post-migration check +- [x] Write `tests/test_validation_service.py` — 20 tests passing +- [x] Update README + +--- + +## Phase 10 — Migration Options API ✅ (2026-04-21) + +- [x] Extend `POST /api/migrate` request body: `source_template_ids[]`, `target_folder`, `options.dry_run`, `options.overwrite_if_exists`, `options.include_documents` +- [x] Implement dry-run path — validate + compose without creating DocuSign templates (`status=dry_run`) +- [x] Implement `overwrite_if_exists=false` — skip already-migrated templates (`status=skipped`) +- [x] Implement `include_documents` toggle — strips `documentBase64` from payload when false +- [x] Keep backward compatibility with legacy `adobe_template_ids` field +- [x] Write `tests/test_migration_options.py` — 7 tests passing +- [x] Update README + +--- + +## Phase 11 — Rate Limiting & Retry with Backoff ✅ (2026-04-21) + +- [x] Implement `src/utils/retry.py` — `retry_with_backoff` (sync) and `async_retry_with_backoff` decorators with exponential backoff + max_delay cap +- [x] Implement `check_response_retryable(status_code)` — returns True for 429/500/502/503/504 +- [x] Write `tests/test_retry.py` — 14 tests passing (exponential delay, max delay, exception filtering, async) +- [x] Update README + +--- + +## Phase 12 — Security Hardening & Audit Trail ✅ (2026-04-21) + +- [x] Implement `src/utils/log_sanitizer.py` — `redact()`, `redact_dict()`, `SanitizingFilter`, `install_sanitizing_filter()` +- [x] Redacts: Bearer tokens, JWT-style tokens, key=value secret assignments, long base64 payloads (PDF content) +- [x] PDF checksum (SHA-256) computed in `mapping_service.adobe_folder_to_normalized()` and stored in `NormalizedDocument.checksum_sha256` +- [x] Write `tests/test_security.py` — 15 tests passing +- [x] Update README + +--- + +## Phase 13 — Batch Migration API ✅ (2026-04-21) + +- [x] Implement `POST /api/migrate/batch` — async background job, returns `job_id` immediately +- [x] Implement `GET /api/migrate/batch/{job_id}` — poll job status, progress, results, summary +- [x] Implement retry for failed templates (one retry on upload failures) +- [x] In-memory job store with progress tracking (`_batch_jobs` dict) +- [x] Write `tests/test_batch_migration.py` — 6 tests passing +- [x] Update README + +--- + +## Full Test Suite ✅ (2026-04-21) + +**108/108 tests passing** + +--- + ## Gitea - [x] Committed and pushed all changes (2026-04-17) +- [ ] Commit and push Phase 8–13 work (ui-redesign branch) --- @@ -91,3 +162,5 @@ - (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 +- (2026-04-21) Blueprint comparison complete — added normalized schema, validation service, migration options, rate-limit/retry, security hardening, and batch migration phases (Phases 8–13) +- (2026-04-21) Phases 8–13 fully implemented — 108/108 tests passing on ui-redesign branch diff --git a/src/models/__init__.py b/src/models/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/models/normalized_template.py b/src/models/normalized_template.py new file mode 100644 index 0000000..2462fc5 --- /dev/null +++ b/src/models/normalized_template.py @@ -0,0 +1,78 @@ +""" +normalized_template.py +----------------------- +Platform-agnostic intermediate schema that decouples Adobe Sign extraction +from DocuSign composition. Both platforms' data is converted to/from this +model so neither side is tightly coupled. +""" + +from __future__ import annotations + +from enum import Enum +from typing import Any, Optional + +from pydantic import BaseModel, Field + + +class ActionType(str, Enum): + SIGN = "SIGN" + APPROVE = "APPROVE" + CC = "CC" + ACKNOWLEDGE = "ACKNOWLEDGE" + + +class NormalizedRole(BaseModel): + name: str + order: int + action_type: ActionType = ActionType.SIGN + + +class NormalizedField(BaseModel): + """One form field in the normalized intermediate representation.""" + type: str # e.g. "signature", "text", "checkbox" + label: str + page: int + x: float + y: float + width: float + height: float + required: bool = False + read_only: bool = False + role_name: str = "" # which role this field belongs to + options: list[str] = Field(default_factory=list) # for dropdown/radio + validation: str = "" # e.g. "DATE", "NUMBER" + content_type: str = "" # e.g. "SIGNATURE_DATE", "SIGNER_NAME" + conditional_parent_label: Optional[str] = None + conditional_parent_value: Optional[str] = None + raw: dict[str, Any] = Field(default_factory=dict) # original source data + + +class NormalizedDocument(BaseModel): + name: str + content_base64: str = "" # base64-encoded PDF bytes + checksum_sha256: str = "" # SHA-256 hex of raw bytes before encoding + source_path: str = "" + + +class NormalizedTemplate(BaseModel): + """ + Platform-agnostic representation of an eSignature template. + Used as the bridge between Adobe Sign and DocuSign. + """ + name: str + description: str = "" + email_subject: str = "" + email_message: str = "" + roles: list[NormalizedRole] = Field(default_factory=list) + documents: list[NormalizedDocument] = Field(default_factory=list) + fields: list[NormalizedField] = Field(default_factory=list) + reminder_enabled: bool = False + expiration_days: Optional[int] = None + source_id: str = "" # original Adobe Sign template ID + unsupported_features: list[str] = Field(default_factory=list) + + def role_names(self) -> list[str]: + return [r.name for r in self.roles] + + def fields_for_role(self, role_name: str) -> list[NormalizedField]: + return [f for f in self.fields if f.role_name == role_name] diff --git a/src/reports/__init__.py b/src/reports/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/reports/report_builder.py b/src/reports/report_builder.py new file mode 100644 index 0000000..bfd7995 --- /dev/null +++ b/src/reports/report_builder.py @@ -0,0 +1,134 @@ +""" +report_builder.py +----------------- +Builds structured migration reports per template and for batch runs. +""" + +from __future__ import annotations + +import json +from dataclasses import dataclass, field +from datetime import datetime, timezone +from enum import Enum + + +class MigrationStatus(str, Enum): + SUCCESS = "success" + SUCCESS_WITH_WARNINGS = "success_with_warnings" + SKIPPED = "skipped" + BLOCKED = "blocked" + ERROR = "error" + + +@dataclass +class TemplateReport: + template_name: str + source_id: str + status: MigrationStatus + docusign_template_id: str = "" + blockers: list[str] = field(default_factory=list) + warnings: list[str] = field(default_factory=list) + error: str = "" + timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat()) + dry_run: bool = False + + def to_dict(self) -> dict: + return { + "template_name": self.template_name, + "source_id": self.source_id, + "status": self.status.value, + "docusign_template_id": self.docusign_template_id, + "blockers": self.blockers, + "warnings": self.warnings, + "error": self.error, + "timestamp": self.timestamp, + "dry_run": self.dry_run, + } + + +@dataclass +class MigrationReport: + reports: list[TemplateReport] = field(default_factory=list) + + def add(self, report: TemplateReport) -> None: + self.reports.append(report) + + def summary(self) -> dict: + counts: dict[str, int] = {} + for r in self.reports: + counts[r.status.value] = counts.get(r.status.value, 0) + 1 + return { + "total": len(self.reports), + **counts, + } + + def to_dict(self) -> dict: + return { + "summary": self.summary(), + "templates": [r.to_dict() for r in self.reports], + } + + def to_json(self, indent: int = 2) -> str: + return json.dumps(self.to_dict(), indent=indent) + + def has_errors(self) -> bool: + return any(r.status in (MigrationStatus.BLOCKED, MigrationStatus.ERROR) for r in self.reports) + + +def build_success_report( + template_name: str, + source_id: str, + docusign_template_id: str, + warnings: list[str], + dry_run: bool = False, +) -> TemplateReport: + status = MigrationStatus.SUCCESS_WITH_WARNINGS if warnings else MigrationStatus.SUCCESS + return TemplateReport( + template_name=template_name, + source_id=source_id, + status=status, + docusign_template_id=docusign_template_id, + warnings=warnings, + dry_run=dry_run, + ) + + +def build_blocked_report( + template_name: str, + source_id: str, + blockers: list[str], + warnings: list[str], + dry_run: bool = False, +) -> TemplateReport: + return TemplateReport( + template_name=template_name, + source_id=source_id, + status=MigrationStatus.BLOCKED, + blockers=blockers, + warnings=warnings, + dry_run=dry_run, + ) + + +def build_error_report( + template_name: str, + source_id: str, + error: str, + dry_run: bool = False, +) -> TemplateReport: + return TemplateReport( + template_name=template_name, + source_id=source_id, + status=MigrationStatus.ERROR, + error=error, + dry_run=dry_run, + ) + + +def build_skipped_report(template_name: str, source_id: str, reason: str) -> TemplateReport: + return TemplateReport( + template_name=template_name, + source_id=source_id, + status=MigrationStatus.SKIPPED, + warnings=[f"Skipped: {reason}"], + ) diff --git a/src/services/__init__.py b/src/services/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/services/mapping_service.py b/src/services/mapping_service.py new file mode 100644 index 0000000..1b0d73b --- /dev/null +++ b/src/services/mapping_service.py @@ -0,0 +1,275 @@ +""" +mapping_service.py +------------------- +Converts a downloaded Adobe Sign template folder into a NormalizedTemplate. +Extracted from compose_docusign_template.py so the normalization step is +decoupled from DocuSign-specific composition. +""" + +from __future__ import annotations + +import hashlib +import base64 +import json +from pathlib import Path + +from src.models.normalized_template import ( + ActionType, + NormalizedDocument, + NormalizedField, + NormalizedRole, + NormalizedTemplate, +) + +MIN_TEXT_WIDTH = 120 + + +# --------------------------------------------------------------------------- +# Adobe Sign → Normalized +# --------------------------------------------------------------------------- + +_ROLE_ACTION_MAP = { + "SIGNER": ActionType.SIGN, + "SIGN": ActionType.SIGN, + "APPROVER": ActionType.APPROVE, + "APPROVE": ActionType.APPROVE, + "CC": ActionType.CC, + "SHARE": ActionType.CC, + "ACKNOWLEDGE": ActionType.ACKNOWLEDGE, +} + +_UNSUPPORTED_FEATURES = [ + ("conditionalAction", "action", "HIDE", "Conditional HIDE actions"), + ("inputType", None, "INLINE_IMAGE", "INLINE_IMAGE fields (no DocuSign equivalent)"), + ("inputType", None, "PARTICIPATION_STAMP", "PARTICIPATION_STAMP fields (no DocuSign equivalent)"), +] + +_UNSUPPORTED_INPUT_TYPES = {"INLINE_IMAGE", "PARTICIPATION_STAMP"} + + +def _detect_unsupported(fields: list[dict], metadata: dict) -> list[str]: + """Return human-readable strings for features that cannot be fully migrated.""" + found: list[str] = [] + seen: set[str] = set() + + def _add(msg: str): + if msg not in seen: + seen.add(msg) + found.append(msg) + + for f in fields: + input_type = f.get("inputType", "") + if input_type in _UNSUPPORTED_INPUT_TYPES: + _add(f"Unsupported field type: {input_type}") + + ca = f.get("conditionalAction", {}) + if ca.get("action") == "HIDE": + _add("Conditional HIDE action (not supported in DocuSign)") + + preds = ca.get("predicates", []) + for p in preds: + if p.get("operator") not in ("EQUALS", None, ""): + _add(f"Non-EQUALS conditional operator: {p.get('operator')} (only EQUALS supported)") + if p.get("operator") == "EQUALS": + break # first EQUALS is handled, only note if there are more + if len(preds) > 1: + _add("Multi-predicate conditional logic (only first EQUALS predicate is mapped)") + + if f.get("inputType") == "STAMP": + _add("STAMP fields (require stamp feature enabled on DocuSign account)") + + # Check for webhook / workflow triggers in metadata + if metadata.get("workflowId") or metadata.get("externalId"): + _add("Workflow / webhook associations (require manual recreation)") + + return found + + +def _derive_roles(fields: list[dict], participant_sets: list[dict] | None = None) -> list[NormalizedRole]: + """ + Build ordered NormalizedRole list from participant_sets if available, + otherwise derive from field assignees. + """ + if participant_sets: + roles = [] + for ps in sorted(participant_sets, key=lambda p: p.get("order", 0)): + name = ps.get("name") or f"Role {ps.get('order', 1)}" + order = ps.get("order", 1) + action_raw = (ps.get("role") or "SIGN").upper() + action = _ROLE_ACTION_MAP.get(action_raw, ActionType.SIGN) + roles.append(NormalizedRole(name=name, order=order, action_type=action)) + if roles: + return roles + + # Fall back: derive from field assignees + seen: dict[str, int] = {} + for f in fields: + assignee = f.get("assignee") or f"recipient{max(f.get('signerIndex', 0), 0)}" + if assignee not in seen: + try: + idx = int(assignee.replace("recipient", "")) + except ValueError: + idx = len(seen) + seen[assignee] = idx + + if not seen: + return [NormalizedRole(name="Signer 1", order=1)] + + return [ + NormalizedRole(name=f"Signer {v + 1}", order=v + 1) + for _, v in sorted(seen.items(), key=lambda kv: kv[1]) + ] + + +def _assignee_to_role(assignee: str | None, roles: list[NormalizedRole]) -> str: + """Map an Adobe field assignee string (e.g. 'recipient0') to a role name.""" + if not assignee: + return roles[0].name if roles else "Signer 1" + try: + idx = int(assignee.replace("recipient", "")) + except ValueError: + return roles[0].name if roles else "Signer 1" + # roles are ordered 1-based + match = next((r for r in roles if r.order == idx + 1), None) + return match.name if match else (roles[0].name if roles else "Signer 1") + + +def _normalize_field(f: dict, role_name: str, warnings: list[str]) -> NormalizedField | None: + """Convert a single Adobe Sign field dict to NormalizedField.""" + input_type = f.get("inputType", "") + label = f.get("name", "unnamed") + locations = f.get("locations", []) + if not locations: + return None + + loc = locations[0] + x = float(loc.get("left", 0)) + y = float(loc.get("top", 0)) + width = float(max(loc.get("width", MIN_TEXT_WIDTH), MIN_TEXT_WIDTH)) + height = float(loc.get("height", 24)) + page = int(loc.get("pageNumber", 1)) + + content_type = f.get("contentType", "") + validation = f.get("validation", "") + + # Map Adobe input type to normalized type + type_map = { + "SIGNATURE": "signature", + "CHECKBOX": "checkbox", + "DROP_DOWN": "dropdown", + "RADIO": "radio", + "FILE_CHOOSER": "attachment", + "STAMP": "stamp", + "INLINE_IMAGE": "inline_image", + "PARTICIPATION_STAMP": "participation_stamp", + } + + if input_type == "BLOCK" and content_type == "SIGNATURE_BLOCK": + norm_type = "signature" + elif input_type == "TEXT_FIELD": + norm_type = "text" + else: + norm_type = type_map.get(input_type, input_type.lower()) + + # Conditional logic + parent_label = None + parent_value = None + ca = f.get("conditionalAction", {}) + predicates = ca.get("predicates", []) + if predicates and ca.get("action") == "SHOW": + pred = next((p for p in predicates if p.get("operator") == "EQUALS"), None) + if pred: + parent_label = pred.get("fieldName") + parent_value = pred.get("value") + + options: list[str] = [] + if input_type in ("DROP_DOWN", "RADIO"): + options = (f.get("hiddenOptions") or f.get("visibleOptions") or []) + + return NormalizedField( + type=norm_type, + label=label, + page=page, + x=x, + y=y, + width=width, + height=height, + required=bool(f.get("required", False)), + read_only=bool(f.get("readOnly", False)), + role_name=role_name, + options=options, + validation=validation, + content_type=content_type, + conditional_parent_label=parent_label, + conditional_parent_value=parent_value, + raw=f, + ) + + +def adobe_folder_to_normalized( + template_dir: str, + include_documents: bool = True, +) -> tuple[NormalizedTemplate, list[str]]: + """ + Build a NormalizedTemplate from a downloaded Adobe Sign template folder. + + Args: + template_dir: path to downloads// with metadata.json, + form_fields.json, documents.json, and a PDF. + include_documents: whether to embed PDF bytes. + + Returns: + (NormalizedTemplate, warnings_list) + """ + template_dir = Path(template_dir) + warnings: list[str] = [] + + metadata = json.loads((template_dir / "metadata.json").read_text()) + fields_data = json.loads((template_dir / "form_fields.json").read_text()) + documents_data = json.loads((template_dir / "documents.json").read_text()) + fields: list[dict] = fields_data.get("fields", []) + + participant_sets = metadata.get("participantSetsInfo", None) + roles = _derive_roles(fields, participant_sets) + + # Build normalized fields + normalized_fields: list[NormalizedField] = [] + for f in fields: + assignee = f.get("assignee") or f"recipient{max(f.get('signerIndex', 0), 0)}" + role_name = _assignee_to_role(assignee, roles) + nf = _normalize_field(f, role_name, warnings) + if nf: + normalized_fields.append(nf) + + # Document + pdf_files = [f for f in template_dir.iterdir() if f.is_file() and "json" not in f.name] + doc_info = documents_data.get("documents", [{}])[0] + doc_name = doc_info.get("name", "") + normalized_docs: list[NormalizedDocument] = [] + if pdf_files: + pdf_path = pdf_files[0] + if not doc_name.lower().endswith(".pdf"): + doc_name = Path(doc_name).stem + ".pdf" if doc_name else pdf_path.name + pdf_bytes = pdf_path.read_bytes() + checksum = hashlib.sha256(pdf_bytes).hexdigest() + content_b64 = base64.b64encode(pdf_bytes).decode() if include_documents else "" + normalized_docs.append(NormalizedDocument( + name=doc_name, + content_base64=content_b64, + checksum_sha256=checksum, + source_path=str(pdf_path), + )) + + unsupported = _detect_unsupported(fields, metadata) + + return NormalizedTemplate( + name=metadata.get("name", template_dir.name), + description=f"Migrated from Adobe Sign — original owner: {metadata.get('ownerEmail', '')}", + email_subject=metadata.get("emailSubject") or f"Please sign: {metadata.get('name', '')}", + email_message=metadata.get("message", ""), + roles=roles, + documents=normalized_docs, + fields=normalized_fields, + source_id=metadata.get("id", ""), + unsupported_features=unsupported, + ), warnings diff --git a/src/services/validation_service.py b/src/services/validation_service.py new file mode 100644 index 0000000..5098001 --- /dev/null +++ b/src/services/validation_service.py @@ -0,0 +1,133 @@ +""" +validation_service.py +--------------------- +Pre/post migration checks. Returns a ValidationResult with blockers +(which halt migration) and warnings (which are logged but don't block). +""" + +from __future__ import annotations + +from dataclasses import dataclass, field + +from src.models.normalized_template import NormalizedTemplate + + +@dataclass +class ValidationResult: + blockers: list[str] = field(default_factory=list) + warnings: list[str] = field(default_factory=list) + + def has_blockers(self) -> bool: + return bool(self.blockers) + + def is_ok(self) -> bool: + return not self.has_blockers() + + def all_issues(self) -> list[str]: + return [f"BLOCKER: {b}" for b in self.blockers] + [f"WARNING: {w}" for w in self.warnings] + + +def validate_template(normalized: NormalizedTemplate) -> ValidationResult: + """ + Run all pre-migration checks on a NormalizedTemplate. + Returns a ValidationResult with blockers and warnings. + """ + result = ValidationResult() + + _check_recipients(normalized, result) + _check_fields(normalized, result) + _check_role_assignments(normalized, result) + _check_documents(normalized, result) + _flag_unsupported(normalized, result) + + return result + + +def _check_recipients(t: NormalizedTemplate, r: ValidationResult) -> None: + if not t.roles: + r.blockers.append("No recipients/roles defined — template cannot be migrated") + return + + orders = [role.order for role in t.roles] + if len(orders) != len(set(orders)): + r.warnings.append("Duplicate routing orders detected in recipient roles") + + expected = list(range(1, len(orders) + 1)) + if sorted(orders) != expected: + r.warnings.append( + f"Non-sequential routing order: {sorted(orders)} — DocuSign expects {expected}" + ) + + +def _check_fields(t: NormalizedTemplate, r: ValidationResult) -> None: + if not t.fields: + r.warnings.append("Template has 0 fields — the resulting DocuSign template will be empty") + return + + sig_fields = [f for f in t.fields if f.type in ("signature", "initial")] + if not sig_fields: + r.warnings.append("No signature or initial fields found — signers will have nothing to sign") + + +def _check_role_assignments(t: NormalizedTemplate, r: ValidationResult) -> None: + role_names = {role.name for role in t.roles} + unassigned = [f.label for f in t.fields if f.role_name not in role_names] + if unassigned: + r.warnings.append( + f"{len(unassigned)} field(s) have role assignments that don't match any recipient: " + f"{unassigned[:5]}{'...' if len(unassigned) > 5 else ''}" + ) + + +def _check_documents(t: NormalizedTemplate, r: ValidationResult) -> None: + if not t.documents: + r.blockers.append("No documents attached — at least one PDF is required") + return + + for doc in t.documents: + if not doc.content_base64 and not doc.source_path: + r.warnings.append(f"Document '{doc.name}' has no content and no source path") + + +def _flag_unsupported(t: NormalizedTemplate, r: ValidationResult) -> None: + for feature in t.unsupported_features: + r.warnings.append(f"Unsupported feature (manual review needed): {feature}") + + +def compare_field_counts( + normalized: NormalizedTemplate, + docusign_template: dict, +) -> ValidationResult: + """ + Post-migration check: compare field count in NormalizedTemplate vs the + uploaded DocuSign template payload. + """ + result = ValidationResult() + expected = len(normalized.fields) + + # Count tabs across all signers in the DS template payload + actual = 0 + for signer in docusign_template.get("recipients", {}).get("signers", []): + tabs = signer.get("tabs", {}) + for tab_list in tabs.values(): + actual += len(tab_list) + + if actual == 0 and expected > 0: + result.warnings.append( + f"DocuSign template has 0 tabs but {expected} fields were in the source" + ) + elif abs(actual - expected) > 0: + result.warnings.append( + f"Field count mismatch: normalized={expected}, DocuSign tabs={actual} " + f"(some field types may expand or collapse during mapping)" + ) + + # Compare recipient counts + expected_roles = len(normalized.roles) + actual_signers = len(docusign_template.get("recipients", {}).get("signers", [])) + if expected_roles != actual_signers: + result.warnings.append( + f"Recipient count mismatch: normalized={expected_roles}, DocuSign signers={actual_signers}" + ) + + return result diff --git a/src/utils/__init__.py b/src/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/utils/log_sanitizer.py b/src/utils/log_sanitizer.py new file mode 100644 index 0000000..a74e893 --- /dev/null +++ b/src/utils/log_sanitizer.py @@ -0,0 +1,98 @@ +""" +log_sanitizer.py +---------------- +Redacts secrets (tokens, keys, passwords) from log output so credentials +never appear in logs, stdout, or audit records. +""" + +from __future__ import annotations + +import logging +import re +from typing import Any + +_REDACTED = "[REDACTED]" + +# Patterns where group(1) is a safe label prefix and the rest is the secret. +# Result: group(1) + "[REDACTED]" +_LABEL_PATTERNS = [ + # "Bearer " + re.compile(r"(Bearer\s+)[A-Za-z0-9\-._~+/=]{8,}", re.IGNORECASE), + # key=value assignments for known secret keys + re.compile( + r"""((?:api[_\-]?key|access[_\-]?token|refresh[_\-]?token|client[_\-]?secret|password|private[_\-]?key|authorization)\s*[=:]\s*)["']?[A-Za-z0-9\-._~+/=!@#$%^&*]{6,}["']?""", + re.IGNORECASE, + ), +] + +# Patterns that fully match a secret — the entire match is replaced. +_FULL_SECRET_PATTERNS = [ + # JWT-style tokens (three base64url segments separated by dots) + re.compile(r"\b[A-Za-z0-9\-_]{10,}\.[A-Za-z0-9\-_]{10,}\.[A-Za-z0-9\-_]{10,}\b"), + # Long base64 content (>500 chars) — PDF payloads, encoded keys, etc. + re.compile(r"[A-Za-z0-9+/]{500,}={0,2}"), +] + + +def redact(text: str) -> str: + """Replace known secret patterns in *text* with [REDACTED].""" + for pattern in _LABEL_PATTERNS: + text = pattern.sub(lambda m: m.group(1) + _REDACTED, text) + for pattern in _FULL_SECRET_PATTERNS: + text = pattern.sub(_REDACTED, text) + return text + + +def redact_dict(data: dict, depth: int = 0) -> dict: + """Recursively redact secret values in a dict (for logging structured data).""" + if depth > 10: + return data + _SECRET_KEYS = { + "access_token", "refresh_token", "token", "secret", "password", + "authorization", "api_key", "private_key", "client_secret", + "documentbase64", + } + result = {} + for k, v in data.items(): + if k.lower().replace("-", "_") in _SECRET_KEYS: + result[k] = _REDACTED + elif isinstance(v, dict): + result[k] = redact_dict(v, depth + 1) + elif isinstance(v, list): + result[k] = [redact_dict(i, depth + 1) if isinstance(i, dict) else i for i in v] + elif isinstance(v, str) and len(v) > 100: + result[k] = redact(v) + else: + result[k] = v + return result + + +class SanitizingFilter(logging.Filter): + """ + A logging.Filter that runs redact() on every log record's message. + Attach to any logger or handler to ensure secrets never hit log output. + + Usage: + logging.root.addFilter(SanitizingFilter()) + """ + + def filter(self, record: logging.LogRecord) -> bool: + try: + record.msg = redact(str(record.msg)) + if record.args: + if isinstance(record.args, dict): + record.args = {k: redact(str(v)) for k, v in record.args.items()} + else: + record.args = tuple(redact(str(a)) for a in record.args) + except Exception: + pass + return True + + +def install_sanitizing_filter() -> None: + """Install the SanitizingFilter on the root logger (idempotent).""" + root = logging.getLogger() + for existing in root.filters: + if isinstance(existing, SanitizingFilter): + return + root.addFilter(SanitizingFilter()) diff --git a/src/utils/retry.py b/src/utils/retry.py new file mode 100644 index 0000000..b9e7350 --- /dev/null +++ b/src/utils/retry.py @@ -0,0 +1,102 @@ +""" +retry.py +-------- +Exponential backoff retry helpers for API calls that may hit rate limits +or transient server errors (429, 502, 503, 504). +""" + +from __future__ import annotations + +import asyncio +import functools +import logging +import time +from typing import Callable, TypeVar + +logger = logging.getLogger(__name__) + +T = TypeVar("T") + +# HTTP status codes that are safe to retry +_RETRYABLE_STATUS = {429, 500, 502, 503, 504} + + +def retry_with_backoff( + max_retries: int = 3, + base_delay: float = 1.0, + max_delay: float = 30.0, + retryable_exceptions: tuple = (Exception,), +): + """ + Decorator for sync functions. Retries on exceptions with exponential backoff. + + Usage: + @retry_with_backoff(max_retries=3, base_delay=1.0) + def my_api_call(): + ... + """ + def decorator(fn: Callable) -> Callable: + @functools.wraps(fn) + def wrapper(*args, **kwargs): + last_exc: Exception | None = None + for attempt in range(max_retries + 1): + try: + return fn(*args, **kwargs) + except retryable_exceptions as exc: + last_exc = exc + if attempt == max_retries: + break + delay = min(base_delay * (2 ** attempt), max_delay) + logger.warning( + "Retry %d/%d for %s after %.1fs — %s", + attempt + 1, max_retries, fn.__name__, delay, exc, + ) + time.sleep(delay) + raise last_exc + return wrapper + return decorator + + +def async_retry_with_backoff( + max_retries: int = 3, + base_delay: float = 1.0, + max_delay: float = 30.0, + retryable_exceptions: tuple = (Exception,), +): + """ + Decorator for async functions. Retries on exceptions with exponential backoff. + + Usage: + @async_retry_with_backoff(max_retries=3, base_delay=1.0) + async def my_api_call(): + ... + """ + def decorator(fn: Callable) -> Callable: + @functools.wraps(fn) + async def wrapper(*args, **kwargs): + last_exc: Exception | None = None + for attempt in range(max_retries + 1): + try: + return await fn(*args, **kwargs) + except retryable_exceptions as exc: + last_exc = exc + if attempt == max_retries: + break + delay = min(base_delay * (2 ** attempt), max_delay) + logger.warning( + "Async retry %d/%d for %s after %.1fs — %s", + attempt + 1, max_retries, fn.__name__, delay, exc, + ) + await asyncio.sleep(delay) + raise last_exc + return wrapper + return decorator + + +class RateLimitError(Exception): + """Raised when an API returns HTTP 429 Too Many Requests.""" + + +def check_response_retryable(status_code: int) -> bool: + """Return True if the HTTP status code warrants a retry.""" + return status_code in _RETRYABLE_STATUS diff --git a/tests/test_api_migrate.py b/tests/test_api_migrate.py index fb460ab..dbd8f09 100644 --- a/tests/test_api_migrate.py +++ b/tests/test_api_migrate.py @@ -142,7 +142,8 @@ def test_migrate_single_template_updates(): ): resp = client.post( "/api/migrate", - json={"adobe_template_ids": [ADOBE_ID]}, + # overwrite_if_exists=True so the existing template is updated, not skipped + json={"adobe_template_ids": [ADOBE_ID], "options": {"overwrite_if_exists": True}}, cookies={_COOKIE_NAME: _full_session()}, ) diff --git a/tests/test_batch_migration.py b/tests/test_batch_migration.py new file mode 100644 index 0000000..61e82e6 --- /dev/null +++ b/tests/test_batch_migration.py @@ -0,0 +1,155 @@ +""" +Tests for Phase 13: batch migration API. +""" + +import asyncio +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 +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 = "Batch Test Template" +DS_NEW_ID = "ds-batch-new-001" + + +def _full_session(): + return _serializer.dumps({ + "adobe_access_token": "adobe-tok", + "docusign_access_token": "ds-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): + history_path = str(tmp_path / ".history.json") + monkeypatch.setattr(migrate_module, "_HISTORY_FILE", history_path) + return history_path + + +@pytest.fixture(autouse=True) +def clear_batch_jobs(): + """Clear in-memory batch jobs between tests.""" + migrate_module._batch_jobs.clear() + yield + migrate_module._batch_jobs.clear() + + +def _async_wrap(sync_fn): + async def wrapper(*args, **kwargs): + return sync_fn(*args, **kwargs) + return wrapper + + +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": f"Template {template_id}", "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 _mock_compose(template_dir, output_path): + with open(output_path, "w") as f: + json.dump({"name": TEMPLATE_NAME}, f) + + +def _mock_validation_ok(download_dir): + return {"blockers": [], "warnings": [], "has_blockers": False} + + +class TestBatchMigrationPost: + def test_batch_requires_auth(self): + resp = client.post("/api/migrate/batch", json={"source_template_ids": ["id1"]}, cookies={}) + assert resp.status_code == 401 + + def test_batch_no_ids_returns_400(self): + resp = client.post( + "/api/migrate/batch", + json={}, + cookies={_COOKIE_NAME: _full_session()}, + ) + assert resp.status_code == 400 + + @respx.mock + def test_batch_returns_job_id(self): + """POST /api/migrate/batch returns a job_id immediately.""" + with ( + patch.object(migrate_module, "_download_adobe_template", new=_async_wrap(_mock_download)), + patch.object(migrate_module, "_load_compose", return_value=_mock_compose), + patch.object(migrate_module, "_run_validation", side_effect=_mock_validation_ok), + ): + resp = client.post( + "/api/migrate/batch", + json={"source_template_ids": ["id1", "id2"]}, + cookies={_COOKIE_NAME: _full_session()}, + ) + + assert resp.status_code == 200 + body = resp.json() + assert "job_id" in body + assert body["total"] == 2 + assert body["status"] == "queued" + + @respx.mock + def test_batch_job_status_endpoint(self): + """GET /api/migrate/batch/{id} returns job state.""" + with ( + patch.object(migrate_module, "_download_adobe_template", new=_async_wrap(_mock_download)), + patch.object(migrate_module, "_load_compose", return_value=_mock_compose), + patch.object(migrate_module, "_run_validation", side_effect=_mock_validation_ok), + ): + post_resp = client.post( + "/api/migrate/batch", + json={"source_template_ids": ["id1"]}, + cookies={_COOKIE_NAME: _full_session()}, + ) + job_id = post_resp.json()["job_id"] + + get_resp = client.get(f"/api/migrate/batch/{job_id}") + assert get_resp.status_code == 200 + assert get_resp.json()["job_id"] == job_id + + def test_batch_unknown_job_returns_404(self): + resp = client.get("/api/migrate/batch/nonexistent-job-id") + assert resp.status_code == 404 + + @respx.mock + def test_batch_dry_run_option(self): + """Dry run in batch: no uploads, all results are dry_run.""" + with ( + patch.object(migrate_module, "_download_adobe_template", new=_async_wrap(_mock_download)), + patch.object(migrate_module, "_load_compose", return_value=_mock_compose), + patch.object(migrate_module, "_run_validation", side_effect=_mock_validation_ok), + ): + resp = client.post( + "/api/migrate/batch", + json={"source_template_ids": ["id1"], "options": {"dry_run": True}}, + cookies={_COOKIE_NAME: _full_session()}, + ) + + assert resp.status_code == 200 + assert resp.json()["status"] == "queued" diff --git a/tests/test_e2e.py b/tests/test_e2e.py index 83c0f11..3b374bf 100644 --- a/tests/test_e2e.py +++ b/tests/test_e2e.py @@ -175,7 +175,8 @@ def test_full_migration_flow(temp_history): ): migrate_resp2 = test_client.post( "/api/migrate", - json={"adobe_template_ids": [ADOBE_ID]}, + # overwrite_if_exists=True so the second run updates the existing template + json={"adobe_template_ids": [ADOBE_ID], "options": {"overwrite_if_exists": True}}, cookies={_COOKIE_NAME: session_cookie}, ) diff --git a/tests/test_migration_options.py b/tests/test_migration_options.py new file mode 100644 index 0000000..2af3d18 --- /dev/null +++ b/tests/test_migration_options.py @@ -0,0 +1,234 @@ +""" +Tests for Phase 10: migration options (dryRun, overwriteIfExists, includeDocuments). +""" + +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 +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 = "Options Test Template" +ADOBE_ID = "opt-adobe-001" +DS_EXISTING_ID = "ds-existing-opt-001" +DS_NEW_ID = "ds-new-opt-001" + + +def _full_session(): + return _serializer.dumps({ + "adobe_access_token": "adobe-tok", + "docusign_access_token": "ds-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): + history_path = str(tmp_path / ".history.json") + monkeypatch.setattr(migrate_module, "_HISTORY_FILE", history_path) + return history_path + + +def _async_wrap(sync_fn): + async def wrapper(*args, **kwargs): + return sync_fn(*args, **kwargs) + return wrapper + + +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 + + +def _mock_compose(template_dir: str, output_path: str): + with open(output_path, "w") as f: + json.dump({"name": TEMPLATE_NAME, "description": "mocked"}, f) + + +def _mock_validation_ok(download_dir): + return {"blockers": [], "warnings": [], "has_blockers": False} + + +class TestDryRun: + @respx.mock + def test_dry_run_does_not_upload(self): + """dry_run=True: compose succeeds but no POST/PUT to DocuSign.""" + with ( + patch.object(migrate_module, "_download_adobe_template", new=_async_wrap(_mock_download)), + patch.object(migrate_module, "_load_compose", return_value=_mock_compose), + patch.object(migrate_module, "_run_validation", side_effect=_mock_validation_ok), + ): + resp = client.post( + "/api/migrate", + json={ + "source_template_ids": [ADOBE_ID], + "options": {"dry_run": True}, + }, + cookies={_COOKIE_NAME: _full_session()}, + ) + + assert resp.status_code == 200 + results = resp.json()["results"] + assert results[0]["status"] == "dry_run" + assert results[0]["action"] == "dry_run" + assert results[0]["docusign_template_id"] is None + assert results[0]["dry_run"] is True + + @respx.mock + def test_dry_run_false_does_upload(self): + """dry_run=False (default): upload proceeds.""" + 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), + patch.object(migrate_module, "_run_validation", side_effect=_mock_validation_ok), + ): + resp = client.post( + "/api/migrate", + json={"source_template_ids": [ADOBE_ID], "options": {"dry_run": False}}, + cookies={_COOKIE_NAME: _full_session()}, + ) + + assert resp.status_code == 200 + assert resp.json()["results"][0]["status"] == "success" + + +class TestOverwriteIfExists: + @respx.mock + def test_skip_when_overwrite_false(self): + """overwrite_if_exists=False + existing template → skipped.""" + 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"} + ] + }) + ) + with ( + patch.object(migrate_module, "_download_adobe_template", new=_async_wrap(_mock_download)), + patch.object(migrate_module, "_load_compose", return_value=_mock_compose), + patch.object(migrate_module, "_run_validation", side_effect=_mock_validation_ok), + ): + resp = client.post( + "/api/migrate", + json={"source_template_ids": [ADOBE_ID], "options": {"overwrite_if_exists": False}}, + cookies={_COOKIE_NAME: _full_session()}, + ) + + results = resp.json()["results"] + assert results[0]["status"] == "skipped" + assert results[0]["docusign_template_id"] == DS_EXISTING_ID + + @respx.mock + def test_overwrite_when_true(self): + """overwrite_if_exists=True + existing template → PUT update.""" + 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), + patch.object(migrate_module, "_run_validation", side_effect=_mock_validation_ok), + ): + resp = client.post( + "/api/migrate", + json={"source_template_ids": [ADOBE_ID], "options": {"overwrite_if_exists": True}}, + cookies={_COOKIE_NAME: _full_session()}, + ) + + assert resp.json()["results"][0]["action"] == "updated" + + +class TestSourceTemplateIds: + @respx.mock + def test_source_template_ids_field(self): + """source_template_ids (new field) works correctly.""" + 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), + patch.object(migrate_module, "_run_validation", side_effect=_mock_validation_ok), + ): + resp = client.post( + "/api/migrate", + json={"source_template_ids": [ADOBE_ID]}, + cookies={_COOKIE_NAME: _full_session()}, + ) + assert resp.status_code == 200 + assert resp.json()["results"][0]["status"] == "success" + + def test_no_ids_returns_400(self): + resp = client.post( + "/api/migrate", + json={}, + cookies={_COOKIE_NAME: _full_session()}, + ) + assert resp.status_code == 400 + + +class TestValidationBlocking: + def test_blocked_template_not_uploaded(self): + """Template with validation blockers → status=blocked, no upload.""" + def _mock_validation_blocked(download_dir): + return { + "blockers": ["No documents attached"], + "warnings": [], + "has_blockers": True, + } + + with ( + patch.object(migrate_module, "_download_adobe_template", new=_async_wrap(_mock_download)), + patch.object(migrate_module, "_run_validation", side_effect=_mock_validation_blocked), + ): + resp = client.post( + "/api/migrate", + json={"source_template_ids": [ADOBE_ID]}, + cookies={_COOKIE_NAME: _full_session()}, + ) + + assert resp.status_code == 200 + result = resp.json()["results"][0] + assert result["status"] == "blocked" + assert "No documents" in result["error"] diff --git a/tests/test_normalized_schema.py b/tests/test_normalized_schema.py new file mode 100644 index 0000000..f88dc0f --- /dev/null +++ b/tests/test_normalized_schema.py @@ -0,0 +1,139 @@ +""" +Tests for Phase 8: normalized intermediate schema and mapping service. +""" + +import json +from pathlib import Path + +import pytest + +from src.models.normalized_template import ( + ActionType, + NormalizedDocument, + NormalizedField, + NormalizedRole, + NormalizedTemplate, +) +from src.services.mapping_service import adobe_folder_to_normalized + + +DOWNLOADS = Path(__file__).parent.parent / "downloads" +DAVID_DIR = DOWNLOADS / "David Tag Demo Form__CBJCHBCA" +NDA_DIR = DOWNLOADS / "_DEMO USE ONLY_ NDA__CBJCHBCA" +ROB_DIR = DOWNLOADS / "Rob Test__CBJCHBCA" + + +# --------------------------------------------------------------------------- +# Model construction +# --------------------------------------------------------------------------- + +class TestNormalizedModels: + def test_normalized_role_defaults(self): + r = NormalizedRole(name="Customer", order=1) + assert r.action_type == ActionType.SIGN + assert r.order == 1 + + def test_normalized_field_defaults(self): + f = NormalizedField(type="text", label="Name", page=1, x=10, y=20, width=120, height=24) + assert f.required is False + assert f.read_only is False + assert f.options == [] + assert f.conditional_parent_label is None + + def test_normalized_template_construction(self): + t = NormalizedTemplate( + name="My Template", + roles=[NormalizedRole(name="Signer 1", order=1)], + fields=[ + NormalizedField(type="signature", label="sig1", page=1, x=0, y=0, width=140, height=28) + ], + ) + assert t.name == "My Template" + assert len(t.roles) == 1 + assert len(t.fields) == 1 + + def test_role_names(self): + t = NormalizedTemplate( + name="T", + roles=[ + NormalizedRole(name="Customer", order=1), + NormalizedRole(name="Company", order=2), + ], + ) + assert t.role_names() == ["Customer", "Company"] + + def test_fields_for_role(self): + t = NormalizedTemplate( + name="T", + roles=[NormalizedRole(name="Signer 1", order=1)], + fields=[ + NormalizedField(type="signature", label="s1", page=1, x=0, y=0, width=140, height=28, role_name="Signer 1"), + NormalizedField(type="text", label="name", page=1, x=0, y=50, width=120, height=24, role_name="Signer 2"), + ], + ) + assert len(t.fields_for_role("Signer 1")) == 1 + assert len(t.fields_for_role("Signer 2")) == 1 + assert len(t.fields_for_role("Nobody")) == 0 + + def test_normalized_document_checksum(self): + doc = NormalizedDocument( + name="test.pdf", + content_base64="dGVzdA==", + checksum_sha256="9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08", + ) + assert doc.checksum_sha256 != "" + + def test_serialization_roundtrip(self): + t = NormalizedTemplate( + name="Round Trip", + roles=[NormalizedRole(name="Signer 1", order=1)], + ) + dumped = t.model_dump() + restored = NormalizedTemplate(**dumped) + assert restored.name == t.name + assert len(restored.roles) == 1 + + +# --------------------------------------------------------------------------- +# Mapping service — requires real download fixtures +# --------------------------------------------------------------------------- + +@pytest.mark.skipif(not DAVID_DIR.exists(), reason="Downloads fixtures not present") +class TestMappingService: + def test_david_template_normalizes(self): + norm, warnings = adobe_folder_to_normalized(str(DAVID_DIR)) + assert isinstance(norm, NormalizedTemplate) + assert norm.name != "" + assert len(norm.roles) >= 1 + assert len(norm.fields) > 0 + + def test_david_fields_have_roles(self): + norm, _ = adobe_folder_to_normalized(str(DAVID_DIR)) + role_names = norm.role_names() + for f in norm.fields: + assert f.role_name in role_names, f"Field '{f.label}' has unresolved role '{f.role_name}'" + + def test_david_documents_have_checksum(self): + norm, _ = adobe_folder_to_normalized(str(DAVID_DIR)) + assert len(norm.documents) >= 1 + for doc in norm.documents: + assert doc.checksum_sha256 != "", f"Document '{doc.name}' missing checksum" + assert len(doc.checksum_sha256) == 64 # SHA-256 hex + + def test_exclude_documents_option(self): + norm, _ = adobe_folder_to_normalized(str(DAVID_DIR), include_documents=False) + for doc in norm.documents: + assert doc.content_base64 == "" + # checksum still computed even when content excluded + assert doc.checksum_sha256 != "" + + @pytest.mark.skipif(not NDA_DIR.exists(), reason="NDA fixture not present") + def test_nda_template_normalizes(self): + norm, _ = adobe_folder_to_normalized(str(NDA_DIR)) + assert norm.name != "" + assert len(norm.fields) > 0 + + @pytest.mark.skipif(not ROB_DIR.exists(), reason="Rob fixture not present") + def test_rob_template_normalizes(self): + norm, _ = adobe_folder_to_normalized(str(ROB_DIR)) + assert norm.name != "" diff --git a/tests/test_retry.py b/tests/test_retry.py new file mode 100644 index 0000000..fbadc0d --- /dev/null +++ b/tests/test_retry.py @@ -0,0 +1,152 @@ +""" +Tests for Phase 11: retry with backoff utility. +""" + +import asyncio +import time +from unittest.mock import MagicMock, patch + +import pytest + +from src.utils.retry import ( + RateLimitError, + async_retry_with_backoff, + check_response_retryable, + retry_with_backoff, +) + + +class TestRetryWithBackoff: + def test_success_on_first_try(self): + call_count = {"n": 0} + + @retry_with_backoff(max_retries=3, base_delay=0.01) + def fn(): + call_count["n"] += 1 + return "ok" + + result = fn() + assert result == "ok" + assert call_count["n"] == 1 + + def test_retries_on_exception(self): + call_count = {"n": 0} + + @retry_with_backoff(max_retries=2, base_delay=0.01) + def fn(): + call_count["n"] += 1 + if call_count["n"] < 3: + raise ConnectionError("transient") + return "ok" + + with patch("src.utils.retry.time.sleep"): + result = fn() + + assert result == "ok" + assert call_count["n"] == 3 + + def test_raises_after_max_retries(self): + @retry_with_backoff(max_retries=2, base_delay=0.01) + def fn(): + raise ConnectionError("always fails") + + with patch("src.utils.retry.time.sleep"): + with pytest.raises(ConnectionError): + fn() + + def test_exponential_delay(self): + sleeps = [] + + @retry_with_backoff(max_retries=3, base_delay=1.0) + def fn(): + raise ValueError("fail") + + with patch("src.utils.retry.time.sleep", side_effect=lambda d: sleeps.append(d)): + with pytest.raises(ValueError): + fn() + + assert len(sleeps) == 3 + assert sleeps[0] == 1.0 + assert sleeps[1] == 2.0 + assert sleeps[2] == 4.0 + + def test_max_delay_capped(self): + sleeps = [] + + @retry_with_backoff(max_retries=5, base_delay=10.0, max_delay=15.0) + def fn(): + raise ValueError("fail") + + with patch("src.utils.retry.time.sleep", side_effect=lambda d: sleeps.append(d)): + with pytest.raises(ValueError): + fn() + + assert all(d <= 15.0 for d in sleeps) + + def test_only_retries_specified_exceptions(self): + call_count = {"n": 0} + + @retry_with_backoff(max_retries=3, base_delay=0.01, retryable_exceptions=(ConnectionError,)) + def fn(): + call_count["n"] += 1 + raise ValueError("not retryable") + + with pytest.raises(ValueError): + fn() + + assert call_count["n"] == 1 # no retries for ValueError + + +class TestAsyncRetryWithBackoff: + def test_async_success_on_first_try(self): + call_count = {"n": 0} + + @async_retry_with_backoff(max_retries=3, base_delay=0.01) + async def fn(): + call_count["n"] += 1 + return "ok" + + result = asyncio.get_event_loop().run_until_complete(fn()) + assert result == "ok" + assert call_count["n"] == 1 + + def test_async_retries_on_exception(self): + call_count = {"n": 0} + + @async_retry_with_backoff(max_retries=2, base_delay=0.01) + async def fn(): + call_count["n"] += 1 + if call_count["n"] < 3: + raise ConnectionError("transient") + return "ok" + + with patch("src.utils.retry.asyncio.sleep", new=asyncio.coroutine(lambda d: None)): + result = asyncio.get_event_loop().run_until_complete(fn()) + + assert result == "ok" + + def test_async_raises_after_max_retries(self): + @async_retry_with_backoff(max_retries=1, base_delay=0.01) + async def fn(): + raise ConnectionError("always fails") + + with patch("src.utils.retry.asyncio.sleep", new=asyncio.coroutine(lambda d: None)): + with pytest.raises(ConnectionError): + asyncio.get_event_loop().run_until_complete(fn()) + + +class TestCheckResponseRetryable: + def test_429_is_retryable(self): + assert check_response_retryable(429) is True + + def test_503_is_retryable(self): + assert check_response_retryable(503) is True + + def test_200_not_retryable(self): + assert check_response_retryable(200) is False + + def test_400_not_retryable(self): + assert check_response_retryable(400) is False + + def test_404_not_retryable(self): + assert check_response_retryable(404) is False diff --git a/tests/test_security.py b/tests/test_security.py new file mode 100644 index 0000000..101df23 --- /dev/null +++ b/tests/test_security.py @@ -0,0 +1,138 @@ +""" +Tests for Phase 12: security — log sanitization and audit trail. +""" + +import hashlib +import json +import logging + +import pytest + +from src.utils.log_sanitizer import ( + SanitizingFilter, + install_sanitizing_filter, + redact, + redact_dict, +) + + +class TestRedact: + def test_bearer_token_redacted(self): + text = "Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.abc.def" + result = redact(text) + assert "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9" not in result + assert "[REDACTED]" in result + + def test_access_token_assignment_redacted(self): + text = 'access_token: "super_secret_value_12345"' + result = redact(text) + assert "super_secret_value_12345" not in result + assert "[REDACTED]" in result + + def test_password_redacted(self): + text = "password=hunter2supersecure" + result = redact(text) + assert "hunter2supersecure" not in result + + def test_safe_text_unchanged(self): + text = "Template migrated successfully: NDA v2" + result = redact(text) + assert result == text + + def test_long_base64_redacted(self): + # Simulate a long PDF base64 payload being logged + b64 = "A" * 600 + result = redact(b64) + assert "A" * 100 not in result + assert "[REDACTED]" in result + + def test_short_base64_not_redacted(self): + # Short base64 (e.g. an ID) should not be redacted + short_b64 = "dGVzdA==" # "test" base64 + result = redact(short_b64) + assert "dGVzdA" in result + + +class TestRedactDict: + def test_token_key_redacted(self): + d = {"access_token": "secret123", "name": "My Template"} + result = redact_dict(d) + assert result["access_token"] == "[REDACTED]" + assert result["name"] == "My Template" + + def test_nested_dict_redacted(self): + d = {"auth": {"token": "secret123", "user": "alice"}} + result = redact_dict(d) + assert result["auth"]["token"] == "[REDACTED]" + assert result["auth"]["user"] == "alice" + + def test_document_base64_redacted(self): + d = {"documentBase64": "A" * 200} + result = redact_dict(d) + assert result["documentBase64"] == "[REDACTED]" + + def test_list_of_dicts_redacted(self): + d = {"items": [{"token": "abc123xyz", "id": "1"}]} + result = redact_dict(d) + assert result["items"][0]["token"] == "[REDACTED]" + assert result["items"][0]["id"] == "1" + + def test_safe_dict_unchanged(self): + d = {"template_name": "NDA", "status": "success", "count": 3} + result = redact_dict(d) + assert result == d + + +class TestSanitizingFilter: + def test_filter_redacts_log_message(self): + record = logging.LogRecord( + name="test", level=logging.INFO, + pathname="", lineno=0, + msg="Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.payload.signature", + args=(), exc_info=None, + ) + f = SanitizingFilter() + f.filter(record) + assert "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9" not in record.msg + + def test_filter_redacts_args(self): + record = logging.LogRecord( + name="test", level=logging.INFO, + pathname="", lineno=0, + msg="Token: %s", + args=("access_token=supersecretvalue123456",), + exc_info=None, + ) + f = SanitizingFilter() + f.filter(record) + assert "supersecretvalue123456" not in str(record.args) + + def test_install_sanitizing_filter_idempotent(self): + install_sanitizing_filter() + install_sanitizing_filter() # second call should not add duplicate + root = logging.getLogger() + sanitizing_filters = [f for f in root.filters if isinstance(f, SanitizingFilter)] + assert len(sanitizing_filters) == 1 + # Clean up + for f in sanitizing_filters: + root.removeFilter(f) + + +class TestPdfChecksum: + def test_checksum_matches_content(self): + from src.services.mapping_service import adobe_folder_to_normalized + from pathlib import Path + + downloads = Path(__file__).parent.parent / "downloads" / "David Tag Demo Form__CBJCHBCA" + if not downloads.exists(): + pytest.skip("Downloads fixtures not present") + + norm, _ = adobe_folder_to_normalized(str(downloads)) + assert norm.documents, "Expected at least one document" + + doc = norm.documents[0] + # Recompute checksum from source path to verify + import base64 + pdf_bytes = Path(doc.source_path).read_bytes() + expected_checksum = hashlib.sha256(pdf_bytes).hexdigest() + assert doc.checksum_sha256 == expected_checksum diff --git a/tests/test_validation_service.py b/tests/test_validation_service.py new file mode 100644 index 0000000..4337cbf --- /dev/null +++ b/tests/test_validation_service.py @@ -0,0 +1,181 @@ +""" +Tests for Phase 9: validation service. +""" + +import pytest + +from src.models.normalized_template import ( + NormalizedDocument, + NormalizedField, + NormalizedRole, + NormalizedTemplate, +) +from src.services.validation_service import ( + ValidationResult, + compare_field_counts, + validate_template, +) +from src.reports.report_builder import ( + MigrationReport, + MigrationStatus, + build_blocked_report, + build_error_report, + build_skipped_report, + build_success_report, +) + + +def _make_template(**kwargs) -> NormalizedTemplate: + defaults = dict( + name="Test Template", + roles=[NormalizedRole(name="Signer 1", order=1)], + fields=[ + NormalizedField( + type="signature", label="sig1", page=1, + x=100, y=500, width=140, height=28, + role_name="Signer 1", + ) + ], + documents=[NormalizedDocument(name="test.pdf", checksum_sha256="abc", source_path="/fake.pdf")], + ) + defaults.update(kwargs) + return NormalizedTemplate(**defaults) + + +class TestValidationService: + def test_valid_template_passes(self): + t = _make_template() + result = validate_template(t) + assert result.is_ok() + assert result.blockers == [] + + def test_no_recipients_is_blocker(self): + t = _make_template(roles=[]) + result = validate_template(t) + assert result.has_blockers() + assert any("recipient" in b.lower() or "role" in b.lower() for b in result.blockers) + + def test_no_documents_is_blocker(self): + t = _make_template(documents=[]) + result = validate_template(t) + assert result.has_blockers() + assert any("document" in b.lower() for b in result.blockers) + + def test_no_fields_is_warning(self): + t = _make_template(fields=[]) + result = validate_template(t) + assert result.is_ok() # not a blocker + assert any("0 field" in w or "empty" in w.lower() for w in result.warnings) + + def test_no_signature_field_is_warning(self): + t = _make_template(fields=[ + NormalizedField(type="text", label="name", page=1, x=0, y=0, width=120, height=24, role_name="Signer 1") + ]) + result = validate_template(t) + assert result.is_ok() + assert any("signature" in w.lower() for w in result.warnings) + + def test_field_with_unknown_role_is_warning(self): + t = _make_template(fields=[ + NormalizedField( + type="signature", label="sig1", page=1, x=0, y=0, + width=140, height=28, role_name="NonExistentRole" + ) + ]) + result = validate_template(t) + assert result.is_ok() + assert any("role" in w.lower() or "assign" in w.lower() for w in result.warnings) + + def test_unsupported_features_become_warnings(self): + t = _make_template(unsupported_features=["Conditional HIDE action", "Webhook associations"]) + result = validate_template(t) + assert result.is_ok() + assert len([w for w in result.warnings if "Unsupported" in w or "manual" in w.lower()]) >= 2 + + def test_validation_result_all_issues(self): + r = ValidationResult(blockers=["blocker1"], warnings=["warn1"]) + issues = r.all_issues() + assert any("BLOCKER" in i for i in issues) + assert any("WARNING" in i for i in issues) + + +class TestCompareFieldCounts: + def test_matching_counts_no_warnings(self): + t = _make_template(fields=[ + NormalizedField(type="signature", label="sig1", page=1, x=0, y=0, width=140, height=28, role_name="Signer 1") + ]) + ds = { + "recipients": { + "signers": [{"tabs": {"signHereTabs": [{"tabLabel": "sig1"}]}}] + } + } + result = compare_field_counts(t, ds) + assert result.is_ok() + + def test_mismatched_counts_warns(self): + t = _make_template(fields=[ + NormalizedField(type="signature", label="s1", page=1, x=0, y=0, width=140, height=28, role_name="Signer 1"), + NormalizedField(type="text", label="t1", page=1, x=0, y=50, width=120, height=24, role_name="Signer 1"), + ]) + ds = {"recipients": {"signers": [{"tabs": {"signHereTabs": [{}]}}]}} + result = compare_field_counts(t, ds) + assert any("mismatch" in w.lower() or "count" in w.lower() for w in result.warnings) + + def test_zero_tabs_with_fields_warns(self): + t = _make_template() + ds = {"recipients": {"signers": []}} + result = compare_field_counts(t, ds) + assert result.warnings # should warn about 0 tabs + + +class TestReportBuilder: + def test_success_report(self): + r = build_success_report("My Template", "src_001", "ds_001", warnings=[]) + assert r.status == MigrationStatus.SUCCESS + assert r.docusign_template_id == "ds_001" + + def test_success_with_warnings(self): + r = build_success_report("My Template", "src_001", "ds_001", warnings=["some warning"]) + assert r.status == MigrationStatus.SUCCESS_WITH_WARNINGS + + def test_blocked_report(self): + r = build_blocked_report("T", "id1", blockers=["no docs"], warnings=[]) + assert r.status == MigrationStatus.BLOCKED + assert r.blockers == ["no docs"] + + def test_error_report(self): + r = build_error_report("T", "id1", error="Connection refused") + assert r.status == MigrationStatus.ERROR + assert "Connection" in r.error + + def test_skipped_report(self): + r = build_skipped_report("T", "id1", reason="already migrated") + assert r.status == MigrationStatus.SKIPPED + + def test_migration_report_summary(self): + report = MigrationReport() + report.add(build_success_report("T1", "1", "ds1", [])) + report.add(build_success_report("T2", "2", "ds2", ["warn"])) + report.add(build_error_report("T3", "3", "fail")) + summary = report.summary() + assert summary["total"] == 3 + assert summary.get("success", 0) == 1 + assert summary.get("error", 0) == 1 + + def test_report_to_dict(self): + report = MigrationReport() + report.add(build_success_report("T1", "1", "ds1", [])) + d = report.to_dict() + assert "summary" in d + assert "templates" in d + assert d["templates"][0]["template_name"] == "T1" + + def test_report_has_errors(self): + report = MigrationReport() + report.add(build_error_report("T", "1", "err")) + assert report.has_errors() + + def test_report_no_errors(self): + report = MigrationReport() + report.add(build_success_report("T", "1", "ds1", [])) + assert not report.has_errors() diff --git a/web/routers/migrate.py b/web/routers/migrate.py index 5c93955..9df56e0 100644 --- a/web/routers/migrate.py +++ b/web/routers/migrate.py @@ -3,8 +3,10 @@ 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 +POST /api/migrate — run the pipeline for one or more Adobe template IDs +POST /api/migrate/batch — batch migration with async progress tracking +GET /api/migrate/batch/{id} — poll batch job status +GET /api/migrate/history — return past migration records """ import asyncio @@ -12,8 +14,9 @@ import json import os import sys import tempfile +import uuid from datetime import datetime, timezone -from typing import List, Optional +from typing import Dict, List, Optional import httpx from fastapi import APIRouter, Request @@ -23,7 +26,6 @@ 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() @@ -32,9 +34,26 @@ _HISTORY_FILE = os.path.join( os.path.dirname(__file__), "..", "..", "migration-output", ".history.json" ) +# In-memory batch job store (keyed by job_id) +_batch_jobs: Dict[str, dict] = {} + + +class MigrationOptions(BaseModel): + dry_run: bool = False + overwrite_if_exists: bool = False + include_documents: bool = True + class MigrateRequest(BaseModel): - adobe_template_ids: List[str] + # Primary API (blueprint-aligned) + source_template_ids: Optional[List[str]] = None + target_folder: Optional[str] = None + options: MigrationOptions = MigrationOptions() + # Legacy field kept for backward compatibility + adobe_template_ids: Optional[List[str]] = None + + def resolved_ids(self) -> List[str]: + return self.source_template_ids or self.adobe_template_ids or [] def _load_history() -> list: @@ -51,10 +70,7 @@ def _save_history(records: list) -> None: 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. - """ + """Dynamically load compose_template from src/.""" import importlib.util spec = importlib.util.spec_from_file_location( "compose_docusign_template", @@ -71,21 +87,17 @@ async def _download_adobe_template(template_id: str, access_token: str, output_d 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: @@ -111,10 +123,27 @@ async def _download_adobe_template(template_id: str, access_token: str, output_d return True +def _run_validation(download_dir: str) -> dict: + """Run validation service on downloaded template, return summary.""" + try: + from src.services.mapping_service import adobe_folder_to_normalized + from src.services.validation_service import validate_template + norm, _ = adobe_folder_to_normalized(download_dir) + result = validate_template(norm) + return { + "blockers": result.blockers, + "warnings": result.warnings, + "has_blockers": result.has_blockers(), + } + except Exception as exc: + return {"blockers": [], "warnings": [f"Validation skipped: {exc}"], "has_blockers": False} + + async def _migrate_one( adobe_id: str, adobe_access_token: str, docusign_access_token: str, + options: MigrationOptions, ) -> dict: """Run the full pipeline for one Adobe template. Returns a result record.""" timestamp = datetime.now(timezone.utc).isoformat() @@ -134,14 +163,32 @@ async def _migrate_one( "action": None, "status": "failed", "error": "Adobe Sign download failed", + "warnings": [], + "blockers": [], + "dry_run": options.dry_run, } - # 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 + # 2. Validate + validation = _run_validation(download_dir) + if validation["has_blockers"]: + return { + "timestamp": timestamp, + "adobe_template_id": adobe_id, + "adobe_template_name": template_name, + "docusign_template_id": None, + "action": "blocked", + "status": "blocked", + "error": f"Validation blockers: {'; '.join(validation['blockers'])}", + "warnings": validation["warnings"], + "blockers": validation["blockers"], + "dry_run": options.dry_run, + } + + # 3. Compose composed_file = os.path.join(tmpdir, "docusign-template.json") try: compose_fn = _load_compose() @@ -155,6 +202,9 @@ async def _migrate_one( "action": None, "status": "failed", "error": f"Compose failed: {exc}", + "warnings": validation["warnings"], + "blockers": [], + "dry_run": options.dry_run, } if not os.path.exists(composed_file): return { @@ -165,12 +215,34 @@ async def _migrate_one( "action": None, "status": "failed", "error": "Compose produced no output file", + "warnings": validation["warnings"], + "blockers": [], + "dry_run": options.dry_run, } - # 3. Upload (upsert) to DocuSign using web session token + # 4. Dry run — stop here, do not upload + if options.dry_run: + return { + "timestamp": timestamp, + "adobe_template_id": adobe_id, + "adobe_template_name": template_name, + "docusign_template_id": None, + "action": "dry_run", + "status": "dry_run", + "error": None, + "warnings": validation["warnings"], + "blockers": [], + "dry_run": True, + } + + # 5. Upload (upsert) to DocuSign with open(composed_file) as f: template_json = json.load(f) + if not options.include_documents: + for doc in template_json.get("documents", []): + doc.pop("documentBase64", None) + ds_headers = { "Authorization": f"Bearer {docusign_access_token}", "Content-Type": "application/json", @@ -179,7 +251,7 @@ async def _migrate_one( list_url = f"{settings.docusign_base_url}/v2.1/accounts/{settings.docusign_account_id}/templates" async with httpx.AsyncClient() as client: - # Find existing + # Duplicate detection list_resp = await client.get( list_url, headers=ds_headers, params={"search_text": template_name, "count": 100} ) @@ -191,6 +263,21 @@ async def _migrate_one( exact.sort(key=lambda t: t.get("lastModified", ""), reverse=True) existing_id = exact[0]["templateId"] + # Skip if already exists and overwrite is disabled + if existing_id and not options.overwrite_if_exists: + return { + "timestamp": timestamp, + "adobe_template_id": adobe_id, + "adobe_template_name": template_name, + "docusign_template_id": existing_id, + "action": "skipped", + "status": "skipped", + "error": None, + "warnings": validation["warnings"] + ["Skipped: template already exists (overwrite_if_exists=false)"], + "blockers": [], + "dry_run": False, + } + if existing_id: up_resp = await client.put( f"{list_url}/{existing_id}", headers=ds_headers, json=template_json @@ -211,6 +298,9 @@ async def _migrate_one( "action": None, "status": "failed", "error": f"DocuSign upload failed ({up_resp.status_code}): {up_resp.text[:200]}", + "warnings": validation["warnings"], + "blockers": [], + "dry_run": False, } return { @@ -221,6 +311,9 @@ async def _migrate_one( "action": action, "status": "success", "error": None, + "warnings": validation["warnings"], + "blockers": [], + "dry_run": False, } @@ -233,17 +326,21 @@ async def run_migration(body: MigrateRequest, request: Request): if not session.get("docusign_access_token"): return JSONResponse({"error": "not authenticated to DocuSign"}, status_code=401) + ids = body.resolved_ids() + if not ids: + return JSONResponse({"error": "no template IDs provided"}, status_code=400) + tasks = [ _migrate_one( aid, session["adobe_access_token"], session["docusign_access_token"], + body.options, ) - for aid in body.adobe_template_ids + for aid in ids ] results = await asyncio.gather(*tasks) - # Append to history history = _load_history() history.extend(results) _save_history(history) @@ -255,3 +352,101 @@ async def run_migration(body: MigrateRequest, request: Request): def migration_history(): """Return all past migration records.""" return {"history": _load_history()} + + +# --------------------------------------------------------------------------- +# Batch migration +# --------------------------------------------------------------------------- + +async def _run_batch_job( + job_id: str, + ids: List[str], + adobe_token: str, + ds_token: str, + options: MigrationOptions, +) -> None: + """Background coroutine that processes a batch job and updates _batch_jobs.""" + job = _batch_jobs[job_id] + job["status"] = "running" + results = [] + + for i, adobe_id in enumerate(ids): + job["progress"] = {"completed": i, "total": len(ids), "current_id": adobe_id} + result = await _migrate_one(adobe_id, adobe_token, ds_token, options) + + # Retry once on transient failures (network errors, not validation blockers) + if result["status"] == "failed" and "upload failed" in (result.get("error") or ""): + result = await _migrate_one(adobe_id, adobe_token, ds_token, options) + if result["status"] != "failed": + result["retried"] = True + + results.append(result) + job["results"] = results + + # Persist to history + history = _load_history() + history.extend(results) + _save_history(history) + + success = sum(1 for r in results if r["status"] == "success") + failed = sum(1 for r in results if r["status"] in ("failed", "blocked")) + skipped = sum(1 for r in results if r["status"] == "skipped") + dry_runs = sum(1 for r in results if r["status"] == "dry_run") + + job["status"] = "completed" + job["progress"] = {"completed": len(ids), "total": len(ids), "current_id": None} + job["summary"] = { + "total": len(ids), + "success": success, + "failed": failed, + "skipped": skipped, + "dry_run": dry_runs, + } + + +@router.post("/batch") +async def run_batch_migration(body: MigrateRequest, request: Request): + """ + Start an async batch migration job. Returns a job_id immediately. + Poll GET /api/migrate/batch/{job_id} for status. + """ + 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) + + ids = body.resolved_ids() + if not ids: + return JSONResponse({"error": "no template IDs provided"}, status_code=400) + + job_id = str(uuid.uuid4()) + _batch_jobs[job_id] = { + "job_id": job_id, + "status": "queued", + "total": len(ids), + "results": [], + "progress": {"completed": 0, "total": len(ids), "current_id": None}, + "summary": None, + "created_at": datetime.now(timezone.utc).isoformat(), + } + + asyncio.create_task( + _run_batch_job( + job_id, ids, + session["adobe_access_token"], + session["docusign_access_token"], + body.options, + ) + ) + + return {"job_id": job_id, "total": len(ids), "status": "queued"} + + +@router.get("/batch/{job_id}") +def get_batch_status(job_id: str): + """Poll the status of a batch migration job.""" + job = _batch_jobs.get(job_id) + if not job: + return JSONResponse({"error": "batch job not found"}, status_code=404) + return job From 64b33357cf3eb25e9284092acd580a5788e8ae5d Mon Sep 17 00:00:00 2001 From: Paul Huliganga Date: Tue, 21 Apr 2026 10:02:30 -0400 Subject: [PATCH 02/24] feat(ui-mockup): interactive migration console mockup with Docusign 2024 brand MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Full multi-screen interactive HTML mockup for the Adobe Sign → Docusign migration tool UI redesign. Built from scratch based on UX analysis of the migration workflow. Screens: - Dashboard: migration progress stats, attention-required blockers, recent activity, overall progress bar - Templates: paginated table (500+ scale), readiness badges (Ready/Caveats/Blocked/Migrated), multi-select bulk operations, filter tabs by status - Template Detail: 4-tab view — Overview (recipients, DS target), Field Mapping (per-field Adobe→DS tab mapping with ✓/⚠/✕), Issues & Caveats (per-issue severity + manual fix guidance), Verification (post-migration test envelope results) - Migration Results: per-template expandable result cards with warnings listed explicitly, blocked templates with fix guidance - Issues & Warnings: aggregated view across all templates - Verification: test envelope queue with configurable test recipient - History & Audit: full migration run log with export - Settings: platform connections, verification config (test recipient name/email, auto-void timer, API-only vs full envelope), Migration Project context Key UX decisions documented: - Readiness badge surfaces problem templates BEFORE migration attempt - Workflow follows: Connect → Discover → Analyze → Execute → Verify - Logs demoted to History; Issues promoted to primary nav - Migration Project model for multi-customer support (project switcher modal with customer switcher — per-session but project-persistent) - Unsupported features (conditional HIDE, calculated fields, JS validators) shown per-template with actionable fix guidance Docusign 2024 brand applied: - Wordmark: "docusign" all lowercase (April 2024 rebrand) - Nexus icon: two converging lobe shapes (Mist + Cobalt) forming the inkwell / "shape of an agreement" - Inkwell #130032 nav, Cobalt #4C00FF CTAs, Ecru #F8F3F0 background, Poppy #FF5252 errors, Mist #CBC2FF highlights - Source: brand.docusign.com official guidelines Also adds the original Blueprint .docx for reference. Co-Authored-By: Claude Sonnet 4.6 --- ...ign Template migration Tool Blueprint.docx | Bin 0 -> 388607 bytes docs/ui-mockup/mockup.html | 1473 +++++++++++++++++ 2 files changed, 1473 insertions(+) create mode 100644 Adobe to Docusign Template migration Tool Blueprint.docx create mode 100644 docs/ui-mockup/mockup.html diff --git a/Adobe to Docusign Template migration Tool Blueprint.docx b/Adobe to Docusign Template migration Tool Blueprint.docx new file mode 100644 index 0000000000000000000000000000000000000000..82dc25d36351e91358f7d356e7125930c3d07eca GIT binary patch literal 388607 zcmaI7W0)n~vNc+Eb=kIU+qSxFciFaW+qP}Hx@^14yw&f%d!O%|@7}Y1WMrN{%Y%*>%yZGZfw4Zl7lG0I;Jr_?A28?)@ z`Xh>rGOC4*uPY61&zw15aC1cwu?}1Kb2hcmoRMDURL)HJfJM%%67#w(RJ@!wybc55 zmR_dX6PJY8mBpHaiHTF9kUeq z#?|4^%@@`$vsr3cI=^reKx&sq^~hYJ^_7gxUtKX+%xv*@D9QEyhQB$3yk`aVe09wX zE@R9&ug%SlRy(b==Vh11C%F?af%0M^H|gV6?gGk4xKqV>uuRU7;7Cr74a<=m9gYHm z!5C96?X_JfZMr)RD4(CUg*45xFgRmmuH?>FCs9Pnh@(q!nqb>I@Fh`$voXbb- znH?!V?WyrmyVd<*#GHTIdpvN7(^khWZKmdCZjUBB@}wuYWfwD9Z>aZ}Ix|uDdDTkE zR3Y>l2^+OOQw3+&JIp=tc&O=%nAV*TSs6rjZO|5<@g(`F@wjL=G3wEVo006NZr6EY zu*Jqi=ipqAK<>D#LZ!WR&|Z*_xpR z8w$4<@cfVI0ovPF=Y_``1iuyV{5C$YgClL8|25(ZGc+dPh5zrVe@1+ts%y$T{std3B6JEs-QRNU(RTok9C!&fWvTHAO$VoWJoz3q(X{UQ82{W%yrI({cVhrijcC|N3gjUGN&E|yDvEdUSL zNH8i*q?lC0NHrFCG~TLWwt^S~t|i7ui#0}hJQihsdsBBprsFVWMQ++eEFU(B5O|Cb zjEOLIP&pCfxyvVqFCeW>UT?GzAA=nMSf@o-Cq0T_nUjvm0Ysk_+c>vg)jEGPH~g0w zsv^Q}WY8kEX3LWCU>@(HMKrP6?0hDpg`5KBh~=!I5ts!HE04i6#r*te|7&a%HB`9x z7ZTxpVyE_KhA<0Re=`P=Oe$9Za&i7R2&PZsQKX75_SXZv*tEZHL9x*QCTsOKLaRJT+ zx^&A@xt0=NxWzx*I&%`*o+7^#nwN!yc>VcN7FhvSi9kr_{C2M8v3F-DTQe7@)rh6_ z%Lwo?7B?PdNN-g-E+|V!#i_nx9)%_}qb|EW1DzkiNGsj|PGR-D@OEBMeMgTCBS%HD z9mu<58gSW}Cj-m@pr`s=`&%HMlxmZL)pnf8zmoQod6x_3S7D7p*Zg3bue=Gk$y{qJ z>-i||XtP!-e`DuiAwhafWH0RWgm{BP0tpT*e3*2Ym;-@wZFZ#Xt3UD~YCBmZ5D;a~WOYf+sP zgqBdO1v4HCHfeiTN$YOJ94}(?&7XLWkwoF4^QPb+oVSj7c#jW$ecez7wHWKQsv@LE z0v|AlFdtGz&(`GVin@$4p;CnhsZtAanamEn4|w5LH`Nb2*c%H<5GJZ;1b5qt_Y<=k zW-%VJu3!>3Uy%)V57v&&Bg`=lCD*j>I3LRe=mlFuM$3ayRw59ML7Ek;G{*+IcO3;T z=|%y)KC8wDk)|1qCr9(r?;6aG6LYh`%KRv5n=16Pn!z!k68ZBp`_Znz*Fg=Mg0kQz zu#5nbNu-vxat4hZ;=Q<@pBajm;PXmDn6N>$rt} zOE(ZqhYhkTKQG(^#r4vV7)VJyMk6c-hyWr?GhiqINZwfR99d;^tF;N{lf^L+;vqX2 z^^=SRZTST;yG2S0NQsqPL`{JgXjajia}S0fmn$$?OA25yPVWU{uQnS0>N$Pzbz%s% zEZzR3<`3H=0Y2X$6GNzevYch5+MgD>epm9mV|Fb;&HOUJY_SX!;Ed@jKD0Wxl+>F> zZXnU1cUR-0;RLjq-f{1Wtnpdve6E|k z&5>fg3+ZdfkUC(XxjiIL!Ts}Oa>qfPd^=|tQoTO=((MzG+(xiFDNdJMSS+>2=>K{N*cdY|Muu$sycm^LiKt5?;?SM}A= z{=8q3k_y8rEzAfRSW42Ch%HAV#cJ|ND zL{V7fX|IaoX%Q)fH?-fD1QIFy_0=`2X!y=k0PTMDsRJq{_SJEMFjRoI-QtHDX*irs_HN<61w7UdoNIjkB%Zog`%-2} zDD0V;;J>f{uDN>~At7cbjA67qR5{qWWA>AF4v_)^l5{R=Ioy+FXV!nqa$HJ4yD7};2nQTe=@G@QUtWNWTq0dx#_z6&TWP#St z^W!gd4azf!JSivdTL;AVG`a!1quFov*T*_x0k%_Gg<@u8fg7#}9XzOxAHeS*3)KE* z*nG-PV)G^y#==*i9=XHT0{soEJujqAv>0va0?I28oSNQq;_k|td~MQHLWgTo{hBK$ zQVd_P=T%O$kfOpnmcI-KEj-FLsu^jC=4AteGqQmi-Zp?XDk3Q50GVix1xmCUKYD?RN?ZlvL2YAZ~lvqc^9kO%%?t z<5+TqLr>wbtb>Gc^Y~qxuyTuva*JAibZ2$`D@%Qk+G5$YQ2`N`hKWbfMS<#XFP{rt+yxEEV&>IEY3iF>G1^p;}7jS|P!h3Zpw_;sl-OoN!1P@Zo8)dbZ# zvMxjqPnkNc8tEG3bxV}>H?E=KCiB~T+)+G<5hm4Fo!_kt#mj72;Me$Y$J;+i#R@Y! zCC5t!)x?&lxwaZ}iJk~WYMzUNEeZA(OmA;V7&+~UaGW~hnmvt-(cU$;WWAMnFuroE z-T;_A`+MYRn1(_@i7tumuJJn7zYE0^8y_LO2ex}VAEBIkHpiNtyq;^@lZDUV&t2GH z9qzG??Y~LFA<9_wx=&YAi&i3 z>UrJHzWCTLBZig9d`+VMDH|<7KtQT-N)%NkEPDUPw2zOt7l-pj^IS6tXQ#_AS?lq9 zV~fod&BD2awigM2vmwlNc z;9pO8U)w!XvOjmF$tF{Tmv+R+kd80=)W>%URUcCtb_P za!Ao}d=6`lay!BH#|(3a)~}I@SSo>!Xpq41y&}LN(YX9l+kpqBMxEXbRnxQbZZ1Uk%YD4p@m zZlrF`(WU*7l%Xvth?PYZ#q2tnW<8@ivgaxW)LLYHwQTBw8)8;Z_2>|{mP1}W>8$iW zYJh5|tH^!o1Pb9nttcp-_SA%P(N&dWs|hjXer|#yj=Cb!9(4s(0cPY5YyVuq_JG3@0~U}J(ecjp8iAx8|ErTI|g#k_(z8TBOV!|N_}Ja4nh?@Z3hfH;!~ zU+ABll5nxg@!S_9`B;lT$(;|YY+k$c@1**n^VYPz{6&8p+rmxTj1^tq#m$;>%t-)Nu}7&&V(*60Q&|pu74bcJsIFa^kVG^j)N8(CS-fat zK-kp)M`)GdOYWV~xuT!0d&PEk<-c&{$SN0jVT4A1Rjm|luUFjq^XrrI@ct zqs?2hjpt&8R3;xD6|2UMAq8kd>R(WqIDn4tum*rl=PMFuK*pTSGdk0})Dx)q*uYMx zzpTxz@>G7)X(rW9Ysjq&1BIPXuWh@9uHEU%6&-JXP+kUYTD7u8-p}4RJ4)Bu+{k6J zyzp@-K(76AQMzgiq!c6PCLB@DPAv_7RAPBvkht^rfSc%H<#j$il1bN)^cEE$7*fOR zxuOCs3R&2rhWhkd)!BQ2(t-e~!x6}Y+BS`TZKGuV2@*~ko^RMqp55v8Ng!@KQ)K^1 zE`%vXa!xCgT1cCeDDQ;VV3#^7eCtSn8(JcH>scspKiC&bV4989MUZ!s`YHxZZlGA6 zfkqRf=$T>vz*2m62GQV06Gvi?Z93-zpNm~!UB%DAg`uNZZCp#F-P&bg}{gSr^JN#wnHbgNwdXC)K+{R zn=_N57ZI4?QFDW93w@@Dh6RgxAF51o-LMg6$9!D2F?+LrTTc_m(LFVjutlR~c3~^vcdeK(G!8|&8I*~l3WvjC3>MkX2 ziF_h(d6+sAR>{JpHcg{#XvAS)pX%h%2Z1?7Kw@G|;&C(gZ`Rd06fQ{WwHgGF|&1tU} zUarN;GK$d z98Afr5lg=p1q4ZVanVQ*lUhpcYzb}}L`v0!m2W9Zr}t8)jsMDy(`o1Qim5>)3PdHQ z9}PY{M5Wo`<$UN_LY}e&_$~UmGM%}cs45zub^ENB=`Q6_z5h~heLJjbz>!}V#U!rCL#;L^9A zc-*XsBRn_g+_YIEY%m97voOpl(MQ{K52?MUOC)7B*#8eVep59cA=R54m^2Ce-A zlb+%tv`>9b#H~cyaGut_s6VzZEq%)m7SZiR$d0(K>L*TYBc;vx~P}k8{$UPN$&;+q~ zVFOIgi?PfJ{nEsiP*DV5ppoWX^e`U3{X4r2L4bc<`xfMu(shy6q?_y{!SRk3%RXm> z%4<(w9#f=$SGh!fJYj)|5H!bnpUK|Mf9CK{TU6-3{$vw!FG;TR+=@$fPf?;lh7*S& z?c_pyI#q_eU#@qR6`jbAOz$UeBo_pqKxcSph;$ad&dcDNctBAW+X4@pMCB=)IqHjJ z1d&xIB)b-r>A@LD=0u1C+Aevh8p3UC0n#8i>*fBsxmBjP>l4VP{MQ8qzh^7*fQ^W>RNF+Z^)%x&!b(&qI0PyH*+d^ zxc6nbvZ>&z%Aq9VpY|FfF}-yUj;UMMVjE_BYob}vdhwNLK5VbQ8hG97IZAIu>8PR0 zvFy7#pHgk`Qn!7;92tqyDcHOsWuf&cUOC5pjMmE9n!B~@Sg@&jk?xpNI9j@7!J5)( z(6(j1qw?6@y5#E0U4!B3xptDnUB|lSj2DuXyML-kJx;u4a-sAL0p&Y60Zs%c0?ZYr zl=rRols~G7neLHkM7TdgPu#k;cu@;nT&Y=EZyNv}nqgOg*pmaOB?KU(BLh&^9^op+E2C+q1p47OKxr3BoYt%V z!u~FPJZMTihV_)8GcNS*__gCoK;nLcUuR7$dM6v(>WQdJenHw{NC*M?S}vfA<;LjO z4fT592yo=*hQa`s#@N?+m*z6iE#p@DhmHLANy)AsBl3N-pYHli1a(@k?aT90#7J3Y zFpRd%O^xCwfidZ`8tfM@eGp$*H`|UH#=Eq*M>`)U_a&dSsBwP~TBzNFY^u1Z`=jNeKhk0PkE~k$a(f ziP;+eKr{nH*NZrILG5C1+G;@oxyV)|IngH!hb3sAa!H}b-rsQj1C6FS5gzkkCu4z) zL2QBw)GZl99YJ%{yyQT3ui{EfSyK(x4&4HD||fm>UXzmfg6qT&^gKboUc4=`;~JeKS^gXO8ZFN zErl7|Ac12MKPUqwVZAA)x9+I6csS3w%S&NcGS&He4EtMlrA^$ir_pvR4&zlNiWyqJ zx4)=x;lXwc6mUcR;uamaSE@LxAK+?Q_HAwI7w zoGw9HGSel+F~wzl7d2ddaAZ(>>c{{UlW;n=bKvFBi$dGjcn0m??; zIL7Rg*v|G^eKVzrr@uzlIscL2#XRHnEMmQTZL{i_@vg0siY5OX1{VtsxkX9FGl6DQ&xnz{kkOJEl5OZUVMZtA>tpjAq|!RQtoe@RJ8c z#{hcDy(U4qUU`GZ#__KGA*_URRT3Nexd@X^=lInpDkLEQKQ7PDkQ?}`Vnd{Xy zYhln#br-!T0wy?AeLP0}JIx0%>5E>7wD}6V&_%lS(c-{kB``tsS`R07pn}m zM@#$Bw|Up*F+%DN5lKJ|`b-IgXOHzag~oK)I+_SQ2Deh%3*sJY%i9JrEk$hQvk@cX zDt!$`_%8Ku>3(B7aola)61Zo>fUf}eh0URIbVkr7*do?=HvhFlrMJhD zKSkeaw{6Le(6p#;jpvP9e;)2a-ia_qbo?z=KQ1utyiu?@e}P%?{RanfJcmTu{s}Cc z4`#-)iAf>ddG;rBfzsL_*YruEd5d|NbBE<*V~0+Mh&`uM5AP3CScd1}XtH+o<9zn< zpCcBsCHKBOk*llEpy+WlF7Hq4aw`X_!AfGX15Q~B<3-(xWwSZ5@n{Yqcmby93p z6O3^OWZZwcZ%GDg-XtqdcN<-~Xxl*eoGFV5)IMGD2%4+AY>q~Ij}|M&0=K$mlSXUm3%Bjb8G?oDLMT(kch_`lnc$V zipb%;QxGR{7^6o9=Z8ix6s}6ui4_eOdX&CvW=23FA}PN zHM`7lh6zBe4GJ@NPVeEdwpk5WS}-Rb3Jh|M4F@lyVo5<@ae`<09yMu)6`EfDfNPhI z6(|Fd;k&8gx^OhyJA8#+7J+X5_qJmABbBWq8&^#M{Sbjj)`wGU=(csQ zU9HUVJf9IfpFbtWus!<%)D~{O8as~XfSVrWxO0;)7wbI;rx|jazMTl8*^5fLw`%_R z*x05IOj2TiDDM;P#_l@YsOW$ppoAx|@M%7RUE`Nqrg`k=#vYnZoe{FoSTYsm7q!VS z&owCiR)XW;31U!aVMshVQ1&USZuAihOQ(-3dodulJMbhYd9(wK+nFBxRkAc&ZVxTT zf6l@WJxba2n`WjZ3|8eyo?9<@b5fEsRA`zT4U&yP+#v37J?j?|R{2$)^W-jys7SfF zYsK-)Q*GKVuEhww8K73u10yl+V1A5(Xa?3JKIZV6qYgVNwv+?#yiRm3$_;Fw|Y z%$_FAL0Sp2t59YnJ9~Ss^~)?GL7ZqP!U# zYGYo}oYVGjZ!G}cJtt~2$Y1KN_(#1{OMN(>nkBq3H2cHMTZlA=Wb8A}?^K4jc zN%xoWo%xJF*MDeFbN0{ufx6IeMk2d5s7(}&`vtdXgggWlf^D)JAXi=n{^>f6ZPKcLg=W0K6EY2KOa11lUhyoK{0lIeHzh9nByVA(?0B9Qm&^I zF431DgfoG{okG=N_dBG=@ewa*x|+xG*)RU+r?j#6O7MGJ+Y3*-qT*y#)&JL;?tK1S zJI7uAv?w7a_F!T`BZX(Ngq1a*)3VNc<#;CcU}Lyx8hxHM;NG=vbHCOl+u)R_oBp|_ z6s49dNT}e-qNeO|H`J6gp~YLSLrRkpzMR+H3CrDm)@=0bSHzkOvqBm`vcGsdN+na& z$n9{k5#2NY+v)E-+wtKKL}>p!V=I|3{7ZxqiWt>arFY z*71J3-He|T&%D*FS%VwBDcQ|@VRG;DVNLFU?+d)ih|kWDrHO3ies+atvnL;J4Tm)Yb{0h(mJDhJT1%8nB zs~F)1f;&BW1nk=+M~hkWWX!2+-5<@ButksMTHCF$3TVwXJFac%bocP~2#`Zvs04PQ z)`DLoMe}Tasm5jNu);q2d7;$R{56L$eD*xL&ZgQIIt>A|tge=Xwp=?ju3DeKx8EW% z?}wi(Yp)u{bNhG4n;Pe{=kP{o;DuiU#t!(i3P=x8FWe0kjyK+ErnDJjx-m@CQ*Xv*NxqscdjdQBQ<^hvRlqOY5)b`xxkL}pqx3e;~3SN$6UY#e}f_j?K%@;;J0+(_Ubm7DL)-oe}b<>l`E^#>q1x;g@ITm~Wxb&el_ z1G{xpNGG7LMg>#Q^fihH!*KUUIk*)^b)ZZON0j^C(pbM&$EpJ087II@PSj$Km)MjGj za`SK#1&m3ctGqNsx;$40ba8)vK%DfKC5}xT7fLG)UQ0<1ulJSi*B1m+Usrf*h-cZ3 z4(J9_g72&NJlxJ2*oMpK2-J>h>stp!=avjAXG|Hd9LJ_0l!`FaNIQ zIqZeynb~H~HShP2v#YzaJ51mV zd|j0TAx@dtnsoMr$yV%yuzIa(*l>E?>x72@SUPxbp#B=9{?S@U2sQeU(}9;$pU$^? z-B4b@?(p6am<#}2&>bwMV{d$11PlMxW(2fT7J-esFpmYkj`u)zq{WI*ckxQdGZlWG zGy7X!XREP3+>#{B%+jhyhw0 zPwI~gP7oCrJl1XBi`Thp_?e<|WkgM)cYe~HS>*%MK{h2O?q3v&?HN5{mg-H3W=1+z zOcH-lUDti(F7e|(IP`%5jXTolOl5JMD!u2=sW8i0${ew~nPV0~iNL#3Yx{oGh5y3q z^!}r#`ylSEt<@*co-IziQeG$9Q<>2L5iF2#yd{Ku+j7bRP`7+;8TdB}J#)~#;_2M2 zcCo~b@1_EaG;0wr?VtS4fN|bTQRsHxlITm>(sl z_V~k*9N8H36%TcbqUXi@)VRC(#332-qOND&?Rht%jypTewAYDARQF&ADl7Gg85d_e z>TaO>I~S2+?2IWIG5pUDcO;QHdL3lBE$%P)!un&yQ?BS#%9wl`+dUOQg0h2tHU(;# zP*8(1d1@De2O=k1GV@-M=h)}SHcPa0)#_x`A`1ya3WxzP{r9|l8Z{T;;7m7K1UTw@ zGkyale7_RjF8yCM_Hm62k*3S+^UlGyxWUrQn+3n0S8X~rfptLN`QodaV_$(;TPE7t2b4PqrXFtBRP`e@hLJe-{z(zI@M`HJv> zmg*@o^;JX0WqA*qVz3x$*V2!$ug%TZWPtq}+qvxPLSMCI3FpxrjQMR_{LwQUF6;&) z>?qC%i6@VhP!XhONUCrC1>1eR3Y&>=@hgZ}0|?cp*WwE2GSq`AV%)cN#g{#2s(X?K zD2t)*x0c7+26lkYJf7cF%Jyf^?}ekIRqm4?QY{1XD=^F$i1Bo$Ti$nnGAfs3O>}BL z-;Z})9Nc6zncx}|Zrp?xt$#{2)jiobt=Ca5rbhij0tmkk0SfqP`_qEc<3_=V&_A;UF-Gr2M`!Eb76a+KNX8fxmu%&5wb+iG^W#$sQ&bYkKB%TR=!dxz6aztpBIj&^_1 z)A+(58u{KJT<7%)_yGq+XG++W?|v{6Mo@*Gm5Ju+6yqMKOZiN<^jMmwoQv3QkAkRc zoa38$QZA1-FLYsiae3vp&58w&cQqKqL29xGtm3Cqu{ccUG8A2$!m7xIa@mt^HR?Z5 zM?d{J9e$`BqKBVq4eK)m$%hyJo+C+JE=oHxh&FgwK0ych#(H>Gn|8`K6JDgdo$eh= zyh2#^J_cq;aP`oD^q33YZ-xvRQc@rH^TD7HKVAlCvxoo}kI}TcazuEO+Ss7Rtfdu; z0iLlX@tcB6`=;Qq{!(z?;vd*I1!wV1!3lj+aDAAkBdfM>dlaN(4+HM_U)kJ#eCF8B zKyLhlW9llg-JyjUJ;m-sf}o_v0o2_1>6)jH5&t&>r&{g9WBK9u%Fp>_FtPxy==7Vx zEw>4*s|r?*HbNSgy&U}Mf;_R|bSHy0x&)$dyUpZ|AIwXOd;92!Zs*0OqyQn}o_-U@ zVOV&R^mt3SCfMj^Nmzp`o9zD5vSQOIW4q_=sq5!iR+QqkI_X2zG?IHs;gqtLH`HG3 zvTzcb)O+>?f-fX|jSlSk#hq97MBPmSK^*jl60dH0X{bS1RdX>!q`x|GnB{K$K+P%r z?n?nL{I!;Q70{qh4~qhhSSZvKlvFbk3M=?F*;Q{EJ(<<9g1(EPaw@3sa;SHP!fwt! zhlJOzv2f`bV6fot`&0E_Bcr!dIs`GPuyXjqo}2Tl#eAN0ff*MH*id3Gg4PhHoX|)? zc2=GA@Vwn7ZH3wU?^l!(%W0RR>643k(c<$S>Ev17Me_n=6NE{b3udzUuJt*rKwb1< z?MPRD#34oRz(q+tkxA2ED8WR3EOZIAOjNe|aBWskyYkw!#F#SXyVabV8P=RbbXD(l zRj(6AE}D2&NGhvYcFi9CRm&@|T&3*)QOjKfao&`YX0~v#D~fp{wSG7qos;-my+ub?IbLh{Ew5|8kF5$2e zYRD9g)vBuLzxXj5m9hAtCQd2@m19mg^x&VH^?{RqisfP=F zTqtUjIEw7u*I_jt32j zQ}>@iUtvBXd_mdVC#U?CKxU3NA&guXt`nYu_#bA0sYp8&P@Xj3@5E5?ZTg2EkQ=pp zxdrJVO*TcfS<|CU(qy%%88q6cKmy6|*T9@O0r2qGypNn^r?$Ie!CK=NicZ&j0wa*^ zSYmm0_|olYeI}3`1xgd1fIOA&Z6UORUnNa<@in%U>n(%@%#au7ZrP?st3NNCG_X$0 zb1PS7WdpADO%tqg6e1h)eVYFuy1=e?I=ON`hF7>|e)+X%?tCrQ&MvFGI6;_aN)b6v zwEWyzb%kyJDNg2xDD(A)gu^f{e+E-dt!?s6T*XASzVZ@6`<2<1{dMaRE9>X+2$qw# zRoZk*dbxCyA%1I5vl`!96Nqt_r!+F;xQ=r*DC9V1R;0DmP}Q=6sf=C6*5!fjOMj>F zPwl=uNH4HjC{WQ4Yto2BM4c>m&_H8BLFJ{c>(FX|jWVn&a6)54q>=?76j-d!m-}l90Rx*vD>*N5Vd$)re`g_DARU*8lW5S_ar|)Vs((u@^jmq4`kmH>wwOhgii4Wh`VIDt*7G?s{l6@ z1~?7WzD_94_3tbnBZ<0u%L<@Q0T6cz4?vCQtHvEqjJPnXPi#u?y3t!>{VdWivV$hq z3dmEDYbsbg`7y_q+fpR^6c{5&*>)4BkM$QsjOgL5s(nra+1Za``yN!F=eEE;uYqmz z?m$29L9(TqBK(QfMx3l@{O&B#z4}A~00E!^!e$bAqB@~8aTenk*96rN(Tudkdvv@vc+?**G1iD?^Y(QE$W69aPL%Ej7b zP<1})RdHItszW0kx$((%~E~SnTg8)4y3v5^2oZr<7xyO zknLhUQREz5zHKd~e&gleEnXboEnX(ZzpuhyAZM_xJR!de(0I%50(2{Sg{Ds>E8Kik zL%jMob;CkZeo#?0wz&0!xjBO6C5zdBdFP<<2d0Ux)xuYYQRljq!ylJS+r`=9azg(SX+3@S;`v&uC&l|Y@$0xT04o{h5EE(!=Z$M@-@{X&2R|HSO|-M zxma+6IB*6q^{^6n0q#qLJ|urK59#fzQvjUjv%lnaC*jTVlG`~r>a-y3@57t-I59+T zEbnzf1eh{3h7PVZZT9OAq*#tw|3B5!ZXLVtCT9bN1BUB{FN~R*SG6%awNG+khJ*60?07w;8!DoGh(<3~~Z!uQRlGnD34qf(FjzePEb}Ay2DAUfEstqhNY&$kXc~c;N5(E9pNM z?+}9W&h?Xa>A*5B%smZZw$5zC3dTP|pGbaghP;L1I6TGr4YT7DUzQdA=14AAUYSt8 zueof499HKw$xqroGQ{-4aP4n1C6Mm+k8awGAjMp*w})FYgy|H2#p_jZUkLd(Bslsj zOX3--%a7#Vb=B7zSB!xnT-k?U|TZ+*>B(sBla;+Ysz+LRa@ox z-saqY$a%2*r86AyJAfabz;oq18*aUSj>m2NMP_oM2)ajzh(F5q+8UO!K&<#WL%ts| z4XqUc`d}?p+myv#(#o2B-YW~K?iEM8D8pQZtC1+wvPB@yClC=yLTZTSfp;?IXTl*g zHTH$j7|%-R>RK%G?UK?9T{ z??wGb=ZfD4tU_)EJkza0LNK0O%r+KJBER9gsRf)O`kbJIpD^ARNiIi&2_pPhQ?f&j(Ru$bb$2oGx;#r-7!aE z)2P_2uCd%Zw)1hIxRTpGgWwBWXA68w{(Y3N9zzRbGI14mh-&tDxM3AsYhzCJCnrj$ z&=xvc$*M8#8-kQ)FLI+^qbAppOGOdVkQ=~NJ@=SC&Z-;2MQJlo?nE;Nh9tyt#0%S3 zuiFo6bMThoEd#$iG3*!AasN*&qT1yjR}&fka%O`AZ(VmQ=jCzJ;;sFKQ#vkWH?v4F zU{y-~tsdaK&3j+}pX$M_=ZyNVDcr+(Imz&v#9J|{!yd3m)3ddx^nbNgE6|n}`3Dsz zhbw8&j5n85E@RG<8qXxL!0&kr4!mhe2yH%>zd~0_^WxyE{8ukP`?f#e2X9Wy$BDpS z^&sQaYx0aMX8q4;Toy;?hxsQE?FF^=rW|hx$AfIpbuIsgH^r#OQNyo?u_A(TTWhFO zUHlc3w<7%x^X6KP6AA|S?Qe=2KemHGNf915Y}nweO&CWZc~n+aGEud>>!f%P^7=j?l%HU8 zLF~79!Cz9UjF={Ajs2}cnB^;n7bOKN<0sK@AaRC{>dE#?Gm?fEs!!X5f)M^z#4{Fb z6U#r{sqikATB^#ZCC?{XQjmyT8zrw)e;u?gBgNSc;PIP+|_%>ruS4jO_v{l7Wrc_J`N}_zlLbkc}le zv9oQZU6SV6lg5saE}M!ujx(H=7)>#WD5;#&rsy9_c{VkhR*PIyHV#v!m|gqByK%hf zs!JMw@=Pi=dAX=$*O(h8Pu^?7=-uln5|9&#*18<3eHi67rmma^Y{*T!dl{?%Vx z7!O1KUnmtY{tcz9d1mlb@hRVaoDzTKbgc^m{e@E09SK^_ zg+D7smiu;!Ol$6TijHgWca2L{RM+$==uc02oczKZdFOx4Sv9!Y&1iy^$RJ^Dz5ZYF zi-3*u(izkrxI+D(O$3K+fFEQFfi1 ziR9m|fc*^9@5rEna-n>HhS&B=W$(USSq%{qd)N0mto)jHtWG;RdC!r#Ux7a;gLJTN zKtINOisCJMp|1QqP<}!XKSiNKG+YLt9{d8>14XYI`lmSLD})o?2}_j`$`GU`BnUt3 za7H1Kh5D1^*GH6tKu+zmBJ;wBe$_9CI`iZ-*95utuc>hUsUP;08JqG%i-BUb1x4{kk2UVuekDZU>v4_XDn(*qe_or~YYPDRsa`fZTttPza1by=DoU2__tDn>2_~*OVQ^iZq=MN*RTDKsiz8p{u3=rWk(SO`w+ircW!;T`h)r?mJ zZbU6Ay^h1`coU%aWqR6J92mXa^F^+p?!H^nxxp7v)PNm!f~2KG%d2vdU2pt|Z%M>md)?_q3l&{n5DFdga7p;fk+@)xx$(T$#$t zHAyEo9%&xDwsJupd=mOU=93G0zTBMtC^}~E zO%+0E_~OCVt#yrA554lgXg25fr|7Z&O1_3tgziP_M%yI46RGkoIvD?(=r}Q&ezYGX z5-VvlK)iRXZn_Th`;GLtk}HY)jaiybbOO;;XXWu6wO4t0 zTlO?!lo(fS=SKmDF&PR6p53uX8i9@9&48hJPO*3@S?5RqDO4;;P#_Rke4ODSb3%2A z{~+ugVwOmRJ_7mYr%U-~VwL$O&J2_`eu9A+_Mbco>^X|Y z_m>%AGD+y33@bt@IGP+DnNgt_!7;3IV>L~Zp423k@W0yZ5pCV)NX%QTNd>#)iXXb0 zSIlzpe`JVLU*@~F3oUItm!+_QX1z>!!6bN*XI40oXKJjdEpzScdyz7CK!hjUph{$w z28J|F=Hal=va;o*?6KO4O2PL1GPlt$xgSSZP)6WE+9ac(7KM7s*_hvgYIYJT!?K>t zCyNeJC?Z)N{d_KJI*<$|pQU6Vaf5}bsN>YHGeZ@;Yp9qTpT5S+nugcqUaQ7T3@T6#A8 zevloV=vBCFp6*v>t4^H~MNnSH3bThQR|QY~6Y*|cDm7hGF?a>m(&vGjx8=4DghCY) zCPvt;zJ`3yjNVCVt_%qqGk&!_fZg()WrdZ%kLzRaM6ozF7id`14*gY!!G4rb(BMXE z5>-d-@Hf$x4^dP`3}jH+?cBmmG0lu&rE?s$ZXyb9J2;Z3&{uaCcHDRfcQu$>A*K&S_#tW)Rcb@ zC0`1cM4wN%McdZx`^E;eC%QNEV+-45Hu65s1DKCCET2th-_ePCkF+$#N7tN`E!#p# z53p)2I?d=!X@Ok&2l2{6837uPfT4nFwANS+lz8Ma>qE6R>=B{dKN{3>WwOo;H&CxB zgxMNLl7dH*N{~vMx=3}ooXk;9f;hp#h_Pkc=Eme|w$;H_p^y}cR&%4wGg`C)o4=lY z92Aemg>{9F<&~VG)u=OV6mS`lMbM(xP8?HF9&L)}SyEs`wgcB+y*(dTt{s0;wH@<| ze~Zgqi_ZZjTitue)(2CxB7;d4*!lfNfe1~fzqaL0BMfYciwzNi%Tnyl+(@T5IVqc# z3MG~B%{?d8Pur{H!(dvYGJcj}ft{`fZB6r(!zvS2layyt>qJrAC!*Rdk)TFBO|qPG zKoEsJcT!Ut-%Enw64VesoH=Flb-7c0&ZF>NmiIeA7dKY?%=18%IzXLz6ODOgx0L`E zdqXoKgG=bUsfjr9D@EV$8C`^g2WO~q(Vo2R^!BQ`D{I8uS^wml@)PD69IozI3d3Im_1l;N8egvQC9uU6Li4dLJ)ipW!=8hjsc|E_5Z zoz%?;z5ZFJGP1biUmhnc)NFHS7_!Z3Nq^wK4iJfD4V5kNhKYRmxOaW&`&;`^Lp)xy z;=`p?oeHD*ja3}^=0$bw-pJPPw4_cDkIcw{viOE;Xn*G9&FSbX zDNRy@v^Le#Tkwef_+rS89kA)SlT&ZElVh;j)2qzHu_>R~6RJ5NQ^rfG(R)fQEy$aO z`R-Vza)>M7Gij8Bkf4<9SpS~|(pvLo6ynW~ZIb=QNe=z%+@HxR|1S#{QrvyaO?2JQ z@#fMPpJ=>;%}LNAY?|C#8!3h&fWIjlA(Usu1obZ=+$ z>-6hfcl&Y*W+RbFziavD2j$tMLwPddU zT~N$CZaK}?@)j5gh#75)p(vn5yB1`CMPMc{{g0_Mr&P5{9Zbp=8!CX9* z?HjrrG%EkL&XL%%S;?WgS8VPc@`60*J6~ z3{uT_TR*GuN`uPQ5oT$uC>8ry5j30+ny!iwO1INJdC@n`^Kr}D=TAuzGR$rYJ!V2= zZNkbXWCPqykWx27bRS~RsBobu28F!156l1b?n&7*)w|?cj|{Fe5dR>cPdw2lh(zmTJ_|1S~b ze;_LV-^l-e87h@=Qs({i2!S#)Tp_E=b@O=Qp&3$8h8i27O=%m;$H7z3B+(< z^MT3Np>Fq+5liWKTp>0vwJrrYBlZZQLyJ6(zj@0y_pw4o(#(0-1;B{_D+%!D@Yu}7 zX)BMsVSfbV_=hjH3nPjI%MFgW<=xFRYtrIjDj(K7Pf-skr*(`{jQ_gDQ#>{PtEq-Y zSUkDqTdgv4_t!9qLJhrch{-T#06&`{q+%cCs~?d^A9;r#PM#+7OY8rcB#QK@e5q!*N_bYW&#!Ap zvDdrA{*YWRLgGWab$i++Y9amTcV@V?rAz*AfpG!(-Id{p;Q}kEkcO%XpO;>vjv@gh zM6ici&3-E?MM|}LtJ7Y_Bs4bxeOJ~!!oJ@{gf(7%@V+(!7w(l!`XVVqs9|EN$LT6eqtye5$i%Lv>Y=I6sfh3Mb=yc#gY6&L7=3vlQ;efmZH& z_xIy}1Kt^OUBJ~mU%M>gJ{011L z&0tQlep8*KBTv)-FB2%iZz0ZrNcNQPd!Pim2r?)y0CnI3P7mgKaGL#ZyTqJbXuCS?Kw2fGsM`rjOIj!K57_Y;(lyo>Qyq*{xmDdADPf38 ziR$oEGL^S?A?yh2FZ?G88DO_?ADTd#rlBt{_srP<=djYeLR>}|nCC%y06WndwQ=CF zi69axXM!2b`9#zTNf9>7ssbQ!Z4{W}7yurY==Tana%x)ZlJcL)z(0+zrB4LgU3AZ= zK_s=C-KFZ}%)7OV-FA#Pl`Ld z4)%M`%fWj)V|(zZqatg%n`FAJrV_7#iFI~P;W>n{shl)oBS!5zNjGadc+fHqF){dq zI6#k}>K`=N)R3s{<1eLM>kwpweM2M=wHi2L@s@z{z{Ug@XTCyRho&QGxw-Z5j;x&Ec3!T%fJf)0I66(ut5DT!y573VoueQpb0$!4cgt3ZA=`3yk!K zGxIk%!FpNEJ(#hy);4Z&L>R9^8CCp;i|ErYtb)b%xHX$x+cl}*B8DxmIjcoym=K@M zFFSLdg^?ztC2mQR)uk+6R#d89JSfujz!rOF#^L8zbD1XI)3YPnT%h_sFsIKy2=pya-7F_$=^ zQNJG&(qE-%@f$mdEi)ulcTCbn#WeX+TMAOPZpHU5P)+oEjN=?UaS!W+ld|-0&s#43 zjHPQCPi)P%UHtKL2Tv~T-`7%h9b+ZI{V{yG6#HoLf34LgXnp^eW=Wu)7eEd1GbZ_A zxBdUqEdL+a?LSC22ReBheH%v`8haxXCrdqhT1Q9YjZQaRso`fJZ{wq_cjW=pSktX= zvRdL0sDJp4VEkZ+t1+Si2tq;^h_!>r@A67NN1;SsSy>s4){L@}QlpYY`C3_-wfW>{ zCdYLrRN<$mPxrUCjr|nQ^Tb3dlgZQskHbA9Fa%H|0)_7NYNyDa0vd^`!*be-|{-6c*nUNBRUlYsV#zSQYLnGss3Q*yAE#h7{6Q5!_PY2*YXXlvm{%SFe z=HT(2#BQ(XI&-@AinxO%7ZrCE<}m?tfdCuCQ{32_6&fssk&-K$1(=nSk0&@#FB1O- z0#?FqXT-$2S|(ad8!%M?HXzjpo$3hRI}ARsQk^Adcc{gf|7eyx)^W zSV?j1@pQe7oHs-1!dwD`Zl*fT;Ljs0z*SVql0#u zUHg!J!^$0MM#mjg%CJe}>s15FalXss3XW@XtV^@WGfgcEL)S}69>{XT8KuRe8u)=x zgPs+{G~k2e++JwO&yg-SW$g-Wfz~fi-HPFyH-U1)-VqY_T;G2IH+uE!ye3HEYyakt zIITYiJ>Fpz;7y5I4t@_Gw5X3dC4A#h)tkxO9%QNp-_i&1?3S1tx;=s9MC7lx@+MD0 zdu&wD-;;=qD|(n)bV(R{28NV~P(2L?gz3Qn*>ms^G(G*5IrV{aS)w2wPl((48kAes z1)aYfq(N<+elIkVFk8I?JNO;pFQAezyaNL}1~FYeFucMa7^Dz7xt-`4!vi}Wk}%%B z*$Ce-%?R7Q1Ak3Uf+gu6NQ@0h2eu~A>_C@*YBO1cHlV!3YmBMUPnW2%?KGB9?L<&R zU*wi>>|~ap?eLc1Z-H2W?6{|7hJqLyAh3D?_)~_dA@ypkdkoZ&x2~+XcC><2wec4c z589deq#FZdgj2`Gh}pX<(B4rx0-mYgfiE_4&?z^lTOnQnuy($-_;5&*2*DxC2-hg4 z47Wuq(JxkZ2)Dywen%M@7LyxYS0pBX)YYq`>yjzA7?ybwy<&r!G2ejA3sYjYM$6jG zAe4tT8y*7qHXD5D*>{RiOnnVb^OQ0Mg{{>Ey^GST;H+{3!-raJf&kWS4641uQf&Nd zXGMZnO@S7mRZ=rpcLX^0y3Fp^2qS&xiJ|3!wblzJ{I?1?d>G(a?wQu%Lb6iaFz6{1h^b(3*Jgr zdo>SW8MSIF4r*U=3Dj0Bes4y>q~A4btjkuV1Z^}Vs?8*9?<+|Q zlFcNn<;GZZip?ac!z^nf9X0qwYAUM@ zf-9p1n+MsEEIV(zR0KDd=Bw88F5Q}Nf!iuQ{$^FCOEo(^>KJ(}=rjxSH91>ht*tew8Cl?<8d;#EnOLk64xw&Pk1e%y=|lgv z)Q7gbRN-rkwV_EDe5}k~tLd_au5qbbCGzZ0u;QJx`g(L+C)#SO^lR=tT5j|9|C4Qd z4MEWrS4LLa_Q>U7BUQCowzQL0*#WUEekWdrYK>D7MCD&8CLSk+QFVhkW_hS0ynwFk zRYS7Dy@F5$Yh0;o`$+5%m&B}LK-2iO1}5b=8)Q+>0xU-3H@f;j1*OnpR|9qIA1TH? zIuz`n?LU3gZBLMwr`QxsLl+KzRX>~qf1zL;CP869V&vyf9EBO9S(KR2yK|5*U_X>Z zI;m3!hI_hJZ26iqklA9%GsjYzac>QZG>%fsY$neOCTMG0(;+>UO>J{f8BRcfW~}tX zA9^LKM@MmH_!e_7@iA<@I&rYUm>v#Zl9av;rE1c1RAR=c#xxQI2T;nv{=Rkl0;#IA z>3zTXr75(oRD)ST3T+svMjoy!XNiC{1*jEZO{X!STAiza{R9_UVDY zw|T*P0YdI0Hirtf4U?~x=cXAOINz&br;G}Z7tfiKKh1qm0gxjnn2muL)!rrCb;ws; zD8Z47B;=2wjkz7tC6;QNTlpMq5BhX{1HQLEzHhqq&P~`>X`a%a+MInn1U(EqN;(@m z{dwlLHnS{r%(wNot$lj6t+y?F=D(zUF=e@WxN`LV%Ki=a)q`~ttkjDPYQ%hFeXv2_ zs8Q)}2vYM)2jPSHIQZS|e3K-fd+tIH0BJyd})LDQ&BJ}-eXJ>hap`VjUo=Pvgy)L#5mxwXi?v54=*<%v!}!t(BW^IN6? zY-Q4!&cn)sr+pJQBnhg%*+qkJ`zyk$+zV2D&*{DEojP`}NobNXX+%f@n_q&y0ZdS0 z10a!OaI*XWZJFThTX=GvQ$4~XWD|f3wTXZ$eDV+fnHI;%W;3T8Wtqx*=mbWW&swRD zvQ2O-Q^BRH#o=YDifjFf+r{KQlkA#Z&RU~0lKBCLX>O~T%6c25r4vn$tj_^TW_v5( z#SU!4WJ5cmZVn-ckOzjybsJhoOZDT@1kG8eMr*}sckw=c>NtBEoSpB=bLy4hSj5xg z%k!>TCkxM(_oM@~brB)rc-8Ht>bZ4!y3^MBy|s9%insYq^J(>Ys>Al_vEE}UDckGx z;;0^aN}4_0!I-%x^{Fvh!`v+UzIs*747_Nwey}AJ8ywgL8Qowr&^6%SdlMD-_kq%A zp%?JD9!UsWtDA?WLgIeazu_3By{fSBOyy7u$dP3NONVQE+?(BXyb-PIf8U?|4%a3( zXD!z5w`m=y)vyjNsqYS0&G$fCF%~ zd84O~p>6SM)20Q*d1C_rbdxH9e+3d;OPi~Br-*R@4_+(Tc%iKk>`{*3K z=SFl7ZXaFiUUbFd^|`r$Y476QMeCw{qq~$;-^u8*@j+DI%DmdG^z-$5O=)}o^O=&l zqqBwc8SUQF>2GhT%Jh4thw#Qz2@teJkJ8QfM&zR+@|yMafggSqeu?<*@j2krbMyq^ z4UYe)a}D?g(Yc|r{hiIOvMce0bp_fLH2>l9#k3JA0eqnId3~y z`-_Qbga@pu-5Igxi~&zM`!y`61qnP1pbvkgm|l-sK?0pP%TZ;fXV2y*=V7n};qvEF zHDDze(F1u_u_L0~g$a@RDZF{WqJr+6OdF-0q0WX@eMh}1o}`9=TCM>NG0*>moKTo- zHkG8-@HT9P1R~TmsZaiJ3Y6&EWyO|36S7U;n~LQ+LCP+rnH=oIaAFk^zTNi+Pz%Bu!$%M)gcJj@pBotTK#cg>$NHt8M$u zfu%4_rcrqjsVuUBwR5d`aa}Q6?$Z>u8d8y^#@NjY6qG;K^dYr}I{Aj_mT{%;| z)0{`?Jbq36GG?u{k!^ujNu(56fvjHsJNP$2dSN;i+Vu~` zV_jRy*N;Y!ZZkJBXKp;48xu?dSUrkY;d^oZHADKK%~2WxMrLEej;zw@EWh}}QE8GI zUaE{d$H_Flkk+^yg->c{_%s?V8cPYnPTT6nWkQ`H1<1M@`ksT@vqNm&=WO8@)3GZT%5& z!Cb6Y>}C6YqSYg{vF(K47mD5UFVfe}sF?~}*H<4J$;Mj7&ad=k!V7aEi6X^(Z!XIn zRmE*A=SfReTFqRW3Lbx>P4Z}FUuUa@b*@(nOdO{}dC(pjp%9Q2b0EW{pf3k{&xFC zLXyIIy2ym~rGg+}Xn&cqTc} z6zgZOR=u%b+kNc|3=2nKaa-TFT&6fjwX<}+zqsvZ<9&a=oFh{se~>k#%@_#G1^hw| zBdbWQvFgJ@=1sl14CuCxY=yPgIC7rE$w<%SB63l?I@(ZifIrNd`g9`9R&~+e54|LN zN>Aan8xuMnAR|kX;-mAmJnKmiX%VsQ93Go%$fV|JefRz$fe5;Hz?Uk#wD`ISZSI!|YB19QL<5 zDz`d<4t<@jdhg!9Nbp1OYm^Mim)0D8@kxrvqK0%NCZm&t4T?bpWf?c?F)D?vG<(mn zX9a7?O4dc*#>a&$1%;xhY)+H2xYB4DFTFDj1-|sR{)P1Uih0ZVz9Oe=R>QRvv%q;} zX%FYMEHgYQF1E|)(=*5H)82V5ndtN^hECl!hqs~A!+Ch=Z~eFFc`D+JZcs7gK(m%E6 zX?MLPjryqRHum#pfy$ZY8n@m2z+Zv=zeP}^=%~r5sWoL=8f>k0hx#f5=}@j{H*{XS zcU1yajO$mOjM=g_y`8&P{Y~IAGg&+~E=KFoCb#I{4_6_LeR$uCSDVA*!sfzB(IzR= zbQ-EmMP{jlZT{d;ztx;b&JN~L2``6H9+^6nP2Xni^O2cKhjT*}QkcA^$hXVlcV?ydz+(|J1V)&`=X zerd@U6E_rii0O+-i^+|i#aWTOi$^7X)QxnE_{go~;f5ojMQSly%!UbTpkAsy?B>;n zd%KuVy-hVu`AtzDE1Hx##5*M4$J|>SCk}erZ4OGIiO@!AWYoHj=^yVMqvC0L+TY5A z+axcMTdA%UHK>@`pT5lP%{3OTOKel~D8Ff)Hj)&Pz$P_l&N+?lkmM&#sMcAIGD&D_ z*c*u7!Uo>i-Sw*e|jn@L@zl3DzhA~cz-q)yX{mpbZ> z>RHg1oYlBsHErf6Z6mFK3OyXRUD;z9Xy_oNBgV!tp~>v$?uY&9EP?y;M|m!48rFMU z2WCO>8U^{gzq~H#sh?)SxP;&@qSuR1Z$aO6X|H%3>HW?pYe6XIjB7^NT%T_v;dilc z`ZJupXgraNv43Mnu@P)-X7H1lZMB8)~~lP)}m;P~wO~p&dqK zbHf!KOOA~AdG_u9GC{`mOLdD$qZ%hZkiZt1n+(vxTqdqSQ2qtohpC4VYxn#P3{Vx# z%z@bS@bjn#X^hZ_kamv6>3=}dh_2PrIf_KQkzRo^$Uy@`q;LKM_er@D(v5Wx=KIgEphkWlL#Y-+b^mI3yZIoQ{u(A=&z~>_d?!e+L1&Ou9 z`(fK{wbe3I2rCxZ>eA%J>IJJa^+rW0<@^Qw#wdF+H?h^cKUAyY|Mtq!2T>w!T*3(D z@a=^duSh`WeMuV(5Ps-g!z^Ub=W7i~+8J`MYMwy;7fq4RMlY+0jWwd*sB8m*}`? zh0)=X15C=+F!8Dvkx?f_dzwT|DH0X=(Zg?Yis3_W292a$14Fkh<)mG!6BnGhD;s$n zu}(R$%kqLJBw>S!k;Yx&uQR?i*Vu;@es^w}w8gkNI~N*>-w!osx_>wiM_TVXYUIy} zl{N^zXedBMxWSIgaJ-PuL*@(K+y|2We(%SS2Z40+8MlMkE;r8whAaYWYC60AUBtJbYADBk7_*sfJNM$ATh^v)QB)rLt!tZg-I&2EHrjV|+TZhH0k;JeCkOW6)Cq=F2+wD|} z&41@A5hs(eR{ETyeZsp-7vi5?XLSZVG605)UfK_kjb9{gvy7Cr1#{}%h)&(oIx*7s zqQ&}g8!?V`@zShwr)3(&Wy);=G+qKp6hBFgk{}-xpEgM&&#T&X5_1F2#T0j$sc6MF zLNSUQ+-;5l9*GdJd?)`j=m0yUnp zT`eP_Zjx^G=uH9LHNgQ7k|sf9M8AY}X)3}A-(c(?Fk&)HuXiQ$B@YI+9gfGMOC}r? zj5;(t_0=5dx0G71#hw$JJFmvCE=QeL#_^|4C#WG2Lq5p6?EwL6R(42F#G`Voge!)U^bP#A*P9x3VK($w|Ek&7Nx9K7*1UW9b_My zZ_H`XEgl~&u;A$6%rOY-*}{lAVO9en`~CF*PzL=i@d9u$VH3?9=j|bh zyhciji>w;SMLjSM&MsDK`c<(DdZIh$iEs=+7}&h!EI-0WN%WdgwA;9Fwy%%pC*(Xt zIJ#}~0GYJSXC9tx@sx^3;yRnCDY^qNlTKoV0`0B{>Vt_kvqGH*uktD(I1cE#;*Bz2 z4upzX=3`I)rUQgI=4;ozpCX9)OynU}(a-bEXSjtr+i_cyiD*sSbcaNR*bxB*9Do*d zd)}>SEGIq#;-s=Mhk=o!ld+St2)l=o0VJe3rg5-0RbL*a(L-Vc5voB!=vvCa3-%)7 zjnl15`n+OR_4mDcp z{_kpLT^_rKdK?c8Y%9AC$j5~drS>J!e4)c=AnVj(HoNBKZQK=hfD^woMmHm9)hp3_ zJvML)Z}O6UdRqh|kEaLf zGOWn6IHv;UZrmteV(LE7(IiuLO+0{T!mf}FHC9-?6l}$5#bHCU%N{4opJY`Mav}m) zJg^_-wjnc!6Ng6)Gq<@zLV&;OU(sJRg!6eB+0~YvyWF6jcI>xQgbPYb;?k1Uo`E`c z8AQ-ede>Q zxq-^OP@vpz>Y8tDn2RUF;(SFtj0X5{j;a4RTk2rzxLh)U%oNv@L}J>i;P4}*RyR2o zVws;Kky3=c?0JAL?Ry7i@HYv1ZKA)Nv3dRGv61594DSKvqD%O*(#g7Jv{J^rBY&=v zH2F|p=hNF{6RnEyKu@XfHMQigSvuC;OA^=Zfv=(;FjmI{uhdSnT-3acR>gW#tJKpx zz?=8O!l+z^fWqkHZCTktU|OQ|p6!%Z$05M?4gBAlW{eimm(TD!ImdrA*al!k7b;_NRDdLp8r+!#0r$2gdF%<0gGs?C)(PckvgQmaIm)G-J@2#x3q zX8)#}T0$Sp{mCwQqYyh_`HBx;5IcTnK&S2_X>!?LIcCX zQyn+^*v4dP6RDpNa}Yjr4CK8|4yTNe7E zUZU=ySl6lXv;C2zB8fDs6*1iAo+Fc}lV(4vX)g>N^?THKBTdR_;9AH2F=Zg1hhyf0 zbD}c_@FOc^+s8)cW!2@~6h*I?sIY`+KjAFW2Gi(XR^igSvRAX~a!T6Oq@&{RczAb_ zLLoPmsS5N*N^i<0bi-!>2Pb?Fh}<&Q>kHW_82&4eGU^^sF7`~+={LIM?`7aT-##%> z`>kp6^uT>T1Fg$mj-mI~#gI$fL-RzHQAZg_hh|0zHjM5OlXx-CztGs*YS*pH*uTlj z(1TR%DU}c3MAxynCHew%WwfF<0don?%bn3!+3e7*bMn`tWMUZo<(Pl)du7t1)Z=-1 z3082{rsDE7B=^GnFP~=7O`HtSt#)1%mLibVhFLS!mxcoT!JmLW{<@I>f%mRYnrj6 zc(+YAxV>EkO=$b%IG&W~_<1F1bDP5{UjG>=dwAoh8>VruOcRMl+L!IR%R1gFc@O+` z2A02T`tUFglKr;1>G>1ZGK0d1c#j@AI{w7P$atmF!5e%e#BDVbh93A0ei877)Cy`} zu@Eg>5vbL@qdoj zZF{5So=)$#7(+MBFB`drpSGx@zFXv=7jB$$>aYjD-wFaAdq*e=5-2?bjYdBcBvbN( z8TC{7Nebfk~R*)Qu2#YsS?H5x>6 z;i5W5d-|SuCS*fTUZaWuEs<~-BmO9^$G#o;4D7lIMQX%MjdYCv7a4)NN|4D8z2i1* zKqrv=iR=nlCy?_@C?)(sp9IJ16T3jy2SBwe>#r5GI2Ij47>6%$4qK|va`pjdNU^Wi zgzEo+Qxmc6*D5X}dfY9b5gw&u?S(1)JSwoB{v3hI8#FCLmE^XVe0JZOo78HTv% zwX6P?DE!i={v(lom#m8kA4Gr4JF(L|>pV)o{s=q5wSRjyQ2sGxV9)`$Ija$=709~C zX8h$`rqNS%q_^Gn7yXPI<+2&MdiD$pp`7-gp%eZA1vI{b8*-L1Sc8z)d?K(bUWh?t z8`XHtq?4^|DiHr36meV^_z-1-AO($ zSh*T~e+yDy#B`su6|JMP3xBG)p9wR#I#!z>-kU+jg2X0VZW-d6*(8DX=WlK0;(mjm zKv`o~tg!}lS%r6u@sb;uF%2tInCjeXQmTDjur<4UQQ`J%UsQDc&C)P^j9N(!?DW)!h)|K(@yH8u3q5T&B{S zv|WXVAD<^#S5TKdw=Hc!9&85+xcVH=Tby6+1VHvAwlav{Zw}h2($^DvI~J;yeMk*T z1IYS~5X^!Uds;`9Zb9&|zx7hcXDnb+AN=XmVq$*go7F!%32uv>mn)IyrocRih8-_^ zMm#r|6TYp4bLk!F{oz*?V!Li(Ey~)vjB2QJdI&2{wDVOCv%hiB5keIlczPQ=uELT) zQ(E|PEj@g7c!TUo-o|v= z1#_a6QOX^PTk1di8?FG&z+ZbZUM2FNfbebvR{mPo-(la2N7H@WO-OaCR$gpt1+u)s ztwq;y=e3&Ct2CbwmFK`Sa-)L`84!Zxs68g_oG>6HJ8z>0_X#!&-wD$v!63ZNr>R=t zt`48nyv^gc?!R{L$BrLA@v|3|e6tqs+&<`Ircb7xL7on^F2>b6yng^EcdMR!I}WXs zGY%Mjd(nn2*z%8*?}3**4`H=o>UjI$t0tx6KAJ|{L2~G)t9^kbez^#I z*d%?H{UFpEjR8_Yn!arWy>i@bq=|K`6oYmAQ%r3_gpVorReFAwT~&s`-D~)55tvM; z_^Ld7ssHiWt%JggkH&7+ZmtEC)?@#7*7x@Ex3<9p zmAHx5bpKu9<$-(jG7b9@G%oA%ZP>KOXOG}L&+Vs=)^&FO)n|{7R{7MWN0m(b5@MLc z=2Nl*|64T~Al{<5?2L?9Hw&Tk4W}Vn*euWI=$4FwZshq;bJ9UPkx z!+6hWm*>1*lS#{9j{oX?rb)`KOMRs>tlS!_ap;l3?|MmM(+gfXYo5sTYVRZev+@CL zda?7!W9gdmyhXDcO>v4$W<85VbjoO%ll%G0X{r7@(IVv=)6z1sy7&g|+s^KI@~+UwM#xa;TMy{nUgd;1AHJ&_F;Gg4w23mSGP z5{FGWYZ$2N+GFk+xs;e}RsGX8y94tVJql7Tr|FLH_RK&BCQS}a&Dn6T`lAPV52d<= zT+h|Tg0{#9=+MT+6rvUL9@Uy@%lq>ku2@NI^y)B7g?3;?Bxem57bWY~C#%lmbGe@N zBZKZ?e8qBQw+5XCo%*!i+n9Tw`-1z3dr#YR+q$~(W|W&o1=jx|?yaNZXu8E++y~de z8Qk676CglHaF^f?!DVol1Pg8ff@^TsK!Cvs?(Ph3Ki>B}-#Op??mcVW``2CT>8@S7 zt9oj!>F(;`Md6-w8vkc}uRrPKYvb&PC)*19#w>MrO?vyHOGmg})T6H+R%MbG5xboov_ z7T-nPDO@)0OznK#G1~#{c#J-b`ur9d;LYK1F~ zPxGY9C{(0qq$s+`wWtc>lB&YMNzO;kP2N>MUcdO^(?Xnev~_`XmNi|``zbh$L~G$9 z-ziUxpVkNq>@&0)K}=)#!9QAm)G_tohcWfxo7ZOea?Nmk6d+Mq@?7*B^_=lU)f?tF z<%o zIri6pr&&2)&-}>z46(Ic^d_kZ1|L5Ue~&sQ*FCA9Q+cqcak)kPusWBGeDyuh0r? z5R~tiklKDM%fw4j#%I!eW-;2y+ELv>mp5gQ%1ypWTpQuSr#K3q>H0-)#ny6zq%W-2 zv#tw5NiIQ!`tm|k&a@l#RYOJ^6Efpz8})eeIVc*IwrQU~h!m1Tu5pfLhn+BD7e3oZ z|5T3)-4FRWmQ-3%UqAD<0g;gMk}D}KDxG{Ls(ydAz~whYrgma?HD$A4TTk9*v%$_j zB&C$j%2_vN*5ELP!ZdZIM9#`YH-fP651&y*T%_#`U%|l4;sM_k^B9+%YI~t!!dz*f zVOoGhyf5ODq*y`r`}i`-H!aM$#q=eoWsXXek|NXUH>Isx4a~WxVI>^jity|-I7%{9 zHn*3OHj5q9=1NCCGIWbJsAZMz{1S@ZbbmXlu25=i!)?tbm zmt$=)?u*@9T{P}A?m>6CP%&SAMhRUaZFZe#R-*Dvw!s>KN%nci5v8tqcQ!a;Bb&5v z&su)6bIxAOK5$c&Wn0!P&N*I~C~I@v9?q8?g9ve}p~2+KpR*LMha{h~wz~0vyOPIe&r=r_XaG^@< z+`sbx_=??W(e%bs%$m*>3n*lL1)h$g4bg};Q*mELff6m@Z*2mUh+?PWvPZLLnx|&e0T>(2$+g8L!jZS2u zHy!1fGF(5MPMvMCC;O<`#~~FbRTk-)nJ4xul0nD{xkh;buVFdlKCOXsYxPTd1R#tz zUjeT@vOZRR475O1Xhe@%Q}`l48vwhWXWkxZZjvz_g_!t!)nM003G|n?W?CTb6Df&- zyvMdA)uh?c1@#qRF!fQYJgS%J-i(0SC1&%I;(xLHDc^6SCtpEd&$q z!+-Jy9RjAXErFU;m>}{2Qcb)pIjHo>jgj-g1=H z5!0!xyXt#N5%uM-wd_j?D?Kr_3RZWDN9t|$6qhNRafWkQJJP5VY?0Zr&3isa9KD)J zu0v;J8^*PZ8et^7BKg*zMc=p)PCN{0X;|@#y%ArEU={juJJH8M{o1I>*2y2{2Bi(7 zfjFd9G7Z@Ung?ID>}i|XudFgM;|0<6D_VE#Sn}(vkJ51|RLmxloCwz^%vpZzD{oGQ z-Wo(uG6~J!421BY#M6jn;EvIVrY|hWYhU=h+UJL3i;imjkiD2`NZk@A)Z8}QQw z!Mq#D+uE1o-yL%s266r4&M<3#Yxj)ftVp$sC<(?MNyP2}LcTwe>k4nMR&Z=o$OceZ zYi0=Y@CNkt%Xa1ga{rir|C2;rk@wa+xSURzn}3_jCNr~tSV$JhMRGTmzV!xv@7UeYb|qP3pD z*)9aRbR8u`PpW)3T(yhoSX zfy2J@iER1uUw;P8=qMe&F27S-zMr1LXZjXUBD7s9=S!_ryXe50L)943A>}5L5BhNT z8d%Mnd|xN$%$#{Dbnji^FK(Ngu;~zF8@~i`mI~xX+D`#*FtMnG<_e$N05bqul>=O{ ztYKNatO_w^zwD#VkfUa>;7G|Mo~-5j6HjYc@gTv62-gHb20CPgWA$d?M2oPuq*0zr za~t|pLg6TmG*uKzZo=#KeIz?$e)u=<$oGB=22yZhc(`Ba?XE*BF8N=#pRe0zH)(x@ ztk+9$EI1l0zsAOMI*#c3<&C()hxRyGSDJ5kTiNn1mo+bZ{jnX+Z*Hw;6|ye|xVM-b zSv6h-`XP;#d0ww!QazBWmznMM>-wJp(d}3c0x0Jq}Df>@6ee;X0KTkfN;uq#5g?Pc9*VPJ5lj5|TBAtL3J3_Q!d*sgIyy2I#U{ zwv_Z>xUJB9nr!H{8)XyrFdkdBw4DC>%pdD>_ORs=1YBZ-qG$lT!pM3RWzwntU^_Z?`#)bC*E>~&&LSxBPXn!1 z(o;Xp;x|aQS3Xx7YI2nBPFGFi9jIR=cuOu9pJp&1N3^Jm1bL57#gRNV ze4meJeq#{+X&(fOp5A=^v@EGsfjt#=xmFT!rCAXyZZf@Qn7!pS2ZaFd_2*85ROiT8%lVwgpP3HEO7>G0WH|4AgzlyGUZO8igy= z`r5E6M_$NIA(>V00cfumGqSFTgDd%iEB?Rt@&{TR2dSb`P_apK+VyG? z?%7|RuF?04-|iQ`-rMFr+Z4vjKh2b|#d?>jtG24E;+0%cD+ajlVv*n_WZL7J-SKlX ze@Q!qRQ=LUIMa;Ou}{G1 zs_CA;z52P}1$#ODphMwHui{r* zMw!i_crtDXzsOXY*!OcJXIten)h{>}Z+*WsXAg6L+Ok~~aL0;2^F(x}(oWOdQ*Bce zwA4j>mGR^oV2gooc#maX=o4~lln5{=;7>W@|B@mHRf0aZZi=0!#FX{ySKa0B`EH!J zjX7XNm3W&%-SEA;=hD1;1=38Nps$Ok4n36pbYKP~pBV4=ImU~FVDXXoK$o7@=#y|=`3(%f4=*{ zEA+7&K; ze6)|e(JC{%`teb3DxmCjqKJ?Au%cOEnCNDQW*7G{N8-g$!RThS`Cjkd*vs%da8+aM%xauW}+T#ZtttAU{_sr6n#CxC1`s zb+*pMWsA&duj_kii(rl3Dg27Q$8tEZRNke0U*6(R)+KgnbC9Ds>yK->#oVrM6gEB8 z;#)iX5f=JBL6E_3ghrz7nQJgvD*Qnk`E;?1XJB=T+&9lRfRx4 zHx>gCJb!d``}}u%JW!DLXp~W@VveF`7d)`?Sf|X1O(a@;_s7R4@uwY7+XGgGM6r6x z;Tyhuf9I-{m&M|Rm%O7Vw$^NE2Ycu2HyK(wbNi3fS}TvpABy$s@hjQy%kG_(i6}$| zgvI%wRWIFsS0^?flkZ(}Pob9_GX6b^Q`s{5*1hsY2kr(7O}){Qb9|;>vo!eav&g!~LM2Z_6Ay zgyxG&)%nLc;wRI7@%W|T6p(pVfFAj?-*f9mcDO|6@=}10ziXO|I(Ab57010JlFM&| zEWbQS6!}K_h^~l6Liq-wPc~k# z%Y5jUmA>iB{0%~ASPfkkA1RuVF4+TRIQRc633K)pl^fM0Pp5Ask!|I*f337nmjA zv{5EjHw&W1cVwvjz>iUIctT#!P@LGq zP4A9zsV3>Xrb*Q^G=6i_m?)=v)KO zCpAZiUt2_KPlhj(5t_oSO9z?w7R%k++X#tYIU(_P8jnnZ!#O*uy$p{eOJWq8;}@3e z8qZ`W_i>lIcb8`*tKA-5sLwP3IO4k;m#OQt9E0TDL`@(;lwBuyX5xAxS)yt_f zfhWqCLl*@Yf!mu$nx!p?i`6y${uf~X3w_KBfhIgC0R571MwV{}WD@}_?D=N4KI?-L?SdqYk{pay>f^>PBDFd}+wL?QGwp^R9`bK?1!fCQ_j}3#ijZIdQ15 zrmP#Tah(%qP|rqR*%i%G@mK4ZW_TtNM5Q{%bE;-{kL-*H)Y;{E8XQ^BndZz7W|~Tz z012a2`z*^p__B*zvh)#c;OjAU;2PD;Y{Uo-&PF))H`--2QL)z!_Q!81{FKtiO`ZR` zQG1(Zj~@^v@uzOX@mye$*&zb$Iuj1f^5QqK7c*qJc*LNTf7)HF`}uM+>cxO^u0hHo zdv|r)b6u3jBt{RUI>duQj8Wv>NabMsO-_j0lR@@@Pi z595Vl{~0P)TT02)dl{e5=O^@%#4+wrs-QI&PJvqHMDM#50FIPWUUdD0nechqZgOjpDjfVi})60wRfo5K^&t&ipN|o}f zyV_0B%5-gu3*V53eBVtEWYk5K*eo6@eKDh^j=vvti zQuk%Z%JbpK;H5X;_IW3Dn{>UpESg(+Vx~OA#cn=o$)%2t@@|fHEu|07NFD6zN@17} z23*hVc98sDo|j&IXOUc1n)p1DQ4;fj=u)^sk#Mi&A%R1Y=R4VWra3Uk#!0f@DWt=h4v_m%!NnD0 z*4rKD?1~WQ>Z2^b7x+Wmt?vU74c9M?E#W*wVY7>Y`4;2@VC=6b_0Ou)$^(Cx`~T3# z)FIPQguLmE5TO_uN?Qy!b$B&8|0vm4Q$~vE*w(Wq3D9GD{sdioUVyIDQnv*~nuxNG zYb4<`gK1pw6Al+^qJ!{)wt{ zvqb+k*`^C6MB7i3@_@%EW&-f)g}&x!H{_eicv5oJP&88bAJBFX!hfxl{Z0y$U-qZ=XZC(@%%$yhic)Uh)&Z zfS8>_m|b@-gOY)EFF%ZDyCraQtfv|01$`T8nwQ23E&|qep4!*Oo;{=fy-u+-Pvj+d zt0v?9+h~_EWc3pPv)(` zQdv?#gU3ad)wtFzi{j}N5M(&v_<&}gtdmgB_!x*&9Q!_lM) z>kR&)QM751Ytv!ZZ!4fn0)|wg56k4l#GlyKuTMf+#J5Kxu@iM;uxm_WJ10MT@XopX zisS{O^m5#}*t{s~OXTObz~dy0dW}h^VyM{L)`*Ai3y-*+A@?u8ISPIo-Eu$zjn=iQ zmyPbK=1)HQ6O25D`7npRY~M=+KRVi-3wOp9_y(_beRjOanBQRYM;F`T?~E}IJZ z$lAon@2W2{4gyOJ$xzv%J_a)5=XHUaSa?9IG^}b`C!^S#D;Uly>Uh8NQ%XXcFK!48 zn^en?Ve>mmu;|xWe8K1vVCO0;DqtYZjU!`So)yYfsElB>Cf)=>X=G78)6W%UUK#6d z8sfWAIoA^QSF3W#n-UZ`p$b`+Bs}__1P3-<(6VN|+_z&{k)%I{ZjwvtZhg9mG`P0z zc*}v2C;1{L)lRArg7SUFst*z35Xt8h6uo_hdunnP)5H^wdk{IpM#8&^H1q@a_h&SI-gq+pW=iOI)Ed6yGMyTuJjd1n%bLp`}De1xTxyTo^*^a~lH zA{BQdMGF}s-ze@z`xY`p|57B1fGaGHU{X{i&`8XtFQOJRP*(5`O9Mldx$yRNObI9Z z^NH>Gw0_I6jN)A;WOM9*+9g>fz4Npq+#(sJyc4xU>NSQ|Kd=!-C$bZKSLDD^N-$(j z89r@~v{2l9N6K|l-_7W;5YZTEFW502y*tr!fniWLPyLzdDaaFcpQt}taZ{YkW=;H& zpoHynq`{s~6DjgtfR`b%M2*&wocPJFZkn4d?ZY&|u;!fMuOIuJoyqL4zTILxT!r4k z@d?qr%foC^LZ)2$o&%d9$TF6Xm5H~@N#t=9(Mhyg5E8vXGu-DVV!G5QLw+88i+I-= zWrSlypjETwxFJv-z1n}u2zztMh<9^Yatv^W_wmqJlCA2Xb1>m>*v#(eXab#38BjCl zR$^>+>vba&+%oGY)?mnFjJyuCsx+?N4ZIr|sz`KBoJd?xTuGdbcwG#|)i3LoI;VIV z5q7NEc4b-6Iu6I zMjzXseNqHE4k2VyE%@C;sFl9za6-z>M_VzC6 zC|OSq`*zLwvJJSt-85)nFrmtkes@tbTgIHbpEg$9xoCOU@GZX6;jY<&p_kx!hu_C*7~lrp69Wh zYtfAOQHJt&Sq(~q$9MAfIrT^jy&{vX_M!`gHfZtnEnk#KwNzAXzDD!^NPpMzr9PG+ z&)}WHK`PRsV-`*%adhaG}S5en9V9LbyIu;jL`%kW;y{ z{Iy1$*tMO}?VGBsig%5GVWjm}pGH-7CKKz#iOJOob{Bn9 zeb+%g=}Ao&hoQURFSH>WoqktYJ(SYu7%DFun7=8h*oPm2bDs;4CkQz8dH@OQ^@1wH873$o=-OVIbp z-Em$;87@bz*F?$r1TM-+iLul`S^XF{#)iBazhEwW}b4&=g167@u1-y@0Yn^79g*_g&IX8QOtNjE0<`bhVK=%VjS>B zeO)dJEg-k#OyM=jFFC`N3zg95^B@6r7@VQYeeP6Oz7c8v@f^JJVKw)(Qth$-H*}c* z-Or<+dG$k`&4t8t4UpLDX~1Uk!G_Y?=s0}h>lhrT>HDJjAJLPLOb;STH-(!wvfBA~l+oL^g zMJsjk;UF2>;Z4w9Whir6Husu!hj!dMdmFW9uV_igy)I~+csLk+Rgt`^l3!H{r)7;( z4+rG0DnxIiC$#pel~C26XxF8gjCNJNpKAmlo8AYfQXC;GD1O-Y8)SQ`FR}BO!B86F zm^SKr7sYO!hSva#I4hEZAx^~Wj!$Cr*uGGjo%p#h6a$<|>`9z~gVS@h5KR;ll#17Z zs_>p%8%UZ~njvHi#V?UE8atd5o0@_emKukegqpyF7;bn6gw2g3Pm^S9z#z@kWApT4 zaxAu%-*jEQF2tj^*Um^Ni~pgJ-2nVOIPg6_DHT;e9Gq=8knb9oFQtU*r>sVdyj{)K zfE8;by-lB047dcRe<;6<<;{oBJAPwF?54x*cPpn)bn%v-KY!j?9TBqp^YKWp3u(=M zjeHGQ`J>mT6Q)9NCsc?Gl({Y`z(AnsoSSh73q_I+mwhsgJ0JsEj}l zKhwo)jKqna7Jf(w6CFs`#k~eFraPlwF@i6LpWWo!8uG)^A3V2@@d#`!c?$#^fmf+q zm39Qyi7%CJ6Z0}CRYH{tGtTf(i6-BCIRlYU+0hpu0+U#c~lF4a zk<2ymfI^CMrFyqaAIYo;DZmtfOIb)%y&?jeGfs98Az%-ZfYCPAtIcHfM|+)#6!{3* zpD^16!59%>88(6Ggxm&0nR$p+xZz2afa#0ii*W>N2qP@I_#vq$XZwcX&%}&E9tCtZ zc;&uxXjHD`#qkUB=v8hr1@Bz&jyFUf%llBuQEaaQx&11)j>2s=c+6Y9h|=VdcphG| zBe(IjW^|{p0~o^uyky>82qP2N&?Uddvu3+S28nsR2-%0RIgO}e8V^}blp#*Ei5vUQ zNsjVFkaHs0bcP<;okshJd2ssL{?zz6#4gWVvR&qh*at4catUl0#z09b0%DXx_-|dt zRHVd6F)%KHqA)jR=wO;$geIi=$vAu%F|sGITnb4?Dg+ex9xwux#%&gS&R#St1WP9u zt5)*G4BRmY_Y{YCPlgT^AY97m0vc!CmhllLES)ah5Ie$q^a)LTGQVYr0TkwgWqI>? zBNzdsic;{XR#af0gg`)3*l6C|XbAc7V8f!C7=%PziJqbgHxwv4@E0FYQzGK{B3>P2 z;n=F-r4=ye;?yAhgV$=NP~17ox|!@C-fNlPjXfW=U)Z&u4P}RcuV}v*%8u9$?d=ru zKqm=yThzr&Vqm$?{KW_0jCm`WkOnrJaCeC~Q-;=3%>TL=hP7+k5dn+HXK?p$D==-r zSBQ@xK-ral$2OvE4%@4W`od6Vt9@XAd&iC}A#hw$`Ur-KU=9;u60B^@nE=3mmxmFO zq=3=IiM7T4FRG}4Ml!q|11E!GRqOiXaRCG89K=RzD;0u+AVW@RK)5#`u_=tF*9v)_ zCnXbp4Z|(y6BXqc`L2)g5x{eOo^qE!62&kac3qO}BsGu=)r`54p`xZ7|YbB5yZZx-p_k zbr8L_6drFScz_Smgan+E+yq+b!^hg@Is^W1N&%@&6^JKZeFgYuM(#enl@2_cfYb=k zD$V9SJey6fT&WO%w-~&`3(?2>D^1U3WA+0SR)L{>2^~n2bCUN!MI-oqTdF5|#ZJ^o z#~^6N|A_x8qLLt<{1a)?A*h}&;ivp>3$~&E9c65pn-mMUVDML%WgS^FjAc@}8{)|) zVO7|c@Ew6Xk_OS>rYYqBE>b?R-g>mo2(AcrE(iyqH*B|L6GZvmEC%6=lPJtk&pEbn z$#c~mwK!j$2}bW2;tni&U}%@SBr*y{Z{Fd$GB_@fB^SXoP&w}#{Ak3hUpT3lRoKxk zkTalAM-VyMYX}-hn=Of}n((6gH&)AM(+Ll{2@h875IEhE`fN#ERjLYxgjqbrLsS!sG`e6MA$^bDY6qyEA7i?}q28V&@0;3z7 zgdRW7Y0S=vr47T1Pzf(A`5NacITE3O34-H<7?T`{JIDodyM_t33R@D=q>x($kB8P7 zCn@$J`W)yhfDsWs4wVMflWb}li&SG(VZjs!>aH=LVf?gXv1%6Y3h!b!7N{oLjW>HF zzc~UkJoZ3|fM+2_X{TIqyr!q%5H91c#T=oj!wca8J2X=ntOl3@*yDNvNdqI z%WxfYYXOG+gzEDW-n;G<_DBj`c757k(x5j44qv3#xtVaMb8SfNcDZfdl9a-@Qt96U zefhW=LkG0Pm(_1|+hk}?&agbd<5_|K1`L+USq0ud=zFZ&LRJtKG9-QQQmJ`e9s+j- zSEDTBExq%((Fjh!UwrP9WnvzjPpH(QH&2~UfCH2yKF(K_hWgz+$o(Et=VC>Pn&&a( z%q+HQs}U$3Mn=DQX8UmWBBG)yyF*PdkQv$b($zb9( zADLn-_jLjC&RIxiJO>Hkf;Sk0<0LHF-C|>*HDUOt-N2K`Ljr$Kau~?R2>h)bUSsS8 zSe9S-C$4`y9f>*NhF~uOeP07S!MzRS>JrSwxW&GCUE+;&4fo)b^VBr%OlCCj&}rt2 zSuZ{N`7B(OSePHRaV^g$O`$~Cy&6C>joa*mp7=m>E~UDG%mL`PrQ?*mO)f+g7-C#^ z>oU9N74L>>L$>l%d0v3|cW^mx!i?FFBK)1`&Yq>7)Typ^ z9bgj`9SVmpi47wZIHI?9M$dy)H3vf)_|$X_GZ0K{d;Uy777)K_EBK7#)kZPch(mCy zuG4#OeR_s*QTP;u$~uc%z%vjhIEQLR)J5O~-{Zs%G!q?=UFTX#yxU z;ylEdKvbyR-qSu}C^b@Vo_*tP%a;5eF}EjWe9T|{nN+(KP`->b>i}=t2yR%cj_dIw z95-);^<-ZpcS80?6<9~)KZ7In1OqaHT&=sPsNjha@nH(Urp7q0oj8&mp@WodV{U^U zWI@I1nErt>QzGucH}V|cFsJ{Vj%;q@miY|3O7H9*3x+$0-m%BkE_YNi%v#%yPVFn+z>4n6;(d&;4A%Aq^Tp=ZjjiP9++>6Uyq8@>YaASh#J7ZNWD zM&#>wf3@AEYPGGfNgJCe;50g3BH+;b#mcUbU|mN4@`hmD!&J_y9BEN2h#cq8im&7~ z_HNI()yI>7@J%+>_|!{qQD#qH0peVBdr3cW<()#gAoS^YbVweB3&a>2s}m9=Mqg>}Nu` zbCb?i`+~f#@1}pR+HUVi*!1J$x=A6<1CrxwG_mmFWLN|i>v7}few^(~*qYXBGpyo% zr-(-5iqnh_NPKoyd=V@RAmh6PsZUCn`G(EOGvR%RlxNCVpO4c_MS9b^Nt|q#VXomU zimh0jOm7$va&BgfRjnoXyt_a-DH^ByfMav4@O$eg8eNhjP8t4mMfHnVK<$gG_pgm~ z+b)3qR7d*6;!ATt0`&Wf>5CERkrDiZL~$zb>IK6?F;B>@qUcy-)tBc3c;IbUbHGQj zE8OeHcB3=4qrZEbIWm}cunk=VTh(R6SN;=y;=O$1&L`iEGHrK>d<=h#8Qu@goh6E$ z;Q)NM$b3VtQFj;ahRO&sR}`+h{>I7YjR~8bt0C$pW@aVrrBtPWz8|eCSH%zU ztW^Hx#p*JL_s)`Sa(LsE*Lpg?V-jNf-pKy3b57r<;wh`BB<0!2)=KE{MD&$>9X8&p z_B{U9pp_eL@70k#KMqjsa`5TI-e;_dV~YE=kqC!|S4@|$>mYU|`W*@Zz9izeDDCGK z(1FwmQX_dsUy|31)iIg(=Ez!sR@-%V=(+%aY zDJVkO_Jt*4xc<2_Xh_*7P`8F#D8e>wbIF4^1FX<>>Uk=Z{UUvY{CeUJhDuckUoyi+ z`df-p_m;{F>~BV$anfZ7x`?7)7EfE)r6;{z>TBD&!(Tgfl=A-E|9a6?O2ihOdtV5r zikq|Y{3|^0wZKv&!6D3fvy5u=9J>LAjPqZgd}~SmQ`|R-#IEGw zAt5oNt~@M2Gli&gmxQFjx`iT`rJMzl1f6e}Kl*(Fy?$_-lkE6u&qH*4dBe_Ei>%-$J(r|-;KH{UWI|3tbLwhhZ8%m7R&9ytu4hS@K#C9mLQg2N zokXq#Hmoe%z_+UpZ4%gu$PlU8V6dI>KOHBGXet{*R3NS~*GUb&Hs+q?)M=f&;Ouyj zgt6XvIuV5vMk&LS^8M3io_)gC0gkekk&~fBw13Va0HOoMjxmuG#18kNHCFDqJvh4a ztAs0oqlfznwlM~B!lxnr?zQ~Cnhg{<1}grt8$d6H?QU;8{m6IKRa`w_HkAdzVZY^$ zr&gijSb(X!&ef23z$Lp)A0FRVM*q#^lN$v?umNumJJ19#wmMvXUJ7)Si}M+R@}wto z6ASSJL03@P1*BJFAs!&;GK$}Si8>(+tniv}WqTZ@xir_va4?A2D1~tFU^gl}VhnTm z-as5l%mn1M4u~ZP`Ul02UpgQbq631?pcwE;bHqa4fZQfg{CK4)V<8G4w+WO#0@By9 z34S2+)&CGXViO!eTZ<@v_@%RB6D&aHkq$^+pGYr$^M49FW8ona8%9~jpcx|hgcm0< zcuQyQ4dfO@*U2Vo;abg&cfuK?dgmyUxe_MW4siA+-GK7*qdm3aMj)96YQI(+CHagT zw~8!|@ENuhtQz>_d5ScU!?iNtiTnifTJ=6t3Mv%b)CzF+Al*3Om(AyikhR1Hk5R#8 zNg)XLg5@1}stM*X+mMeC#9_pH9w^~`0)^ZB!RpBV*bE`0YqtYNv+8@mVJGt;9BFb| zwYi_!wWzy$>BGB%H*|%P$6KuBqfG-YhJt_}qNW`L$MT&k8#L2TQ@ZH19`IjUVSgqQz9>gO$GmL?$OXvi4yXPRMb{sJO(H1eFn3$ns`;IM?~h)gULYp#Yo$4^!Q6des}{`k z%HX0yH5qGl8SDOrg>K^TwI!!Kiu6vv=xW%`VeXxFSYI7>mSnYTxO;S=?*@UNC26sPU3G~6e#}x)?xF>rL-Hxtun=I-sIXCF zQeIjcmKpOXQZ%uY%EG_T^iDeb&4IDCdv(3Awk|nq1!jsSvQk;__nGd=|4@hDD@Xr} zhhgti%%vB4dX7;kqj5=X9IMn{dKiHvYIIL!*3inZ!sY;m+^r_P4AFN zElj}mpM}BYoZ0YokEB<@n zK}Dg6@CCftrL&gj1a^ge421b_yBQTF;f``Vy&sE#}yG@ zfY=+XTSMd-F*mNRFa=zd)8B3m0(KBC@dlE%$bUqS19qvy3);Xa0M<%i$@l^bkesGr z{zqxbrh4e9+dGy1#JwGRE;}t5-o+S5WlT|xG!OGSU_vp9BDqErX2t6w*+X!H)rS?J z0uqOh_2YC2{Ui;%wDW*5K*@kBgbfbFFveGdi9w12%XQ%zlblhmDXrl`;2y#3`3w+r z$?*Pu_{grqE??unx(+l}WKEc|z?m-HH8z+wCkYtf*%TI;ZFddff9#fYgY?*%X8!-# zDQvdD^I$Xw6gqwNA|=^~a7q=5!o24-LpOTV)n{uBFWnSyt6lHWbn7KC59ACk+;C4< zQw{4TLJ$457dT!3PZ1L3F0?srj=tTr=~ASBgUItWr~mi%OD`*aTN<4-TDDrCem!pU zP`Xh6s=~9gMaRbJhBfN%MqeIR@EjM>9pyL5P~{y8kOc)w4v&g7_tfvp-=J=aq!<&o zAcBk7ARGiAX#^n?_5NW*7U=!Y!a4}0-?PI8NDxhwM1$E)V@FLvBVJ`gyzsH5!H&L zRL;D3LO#Sc^8p>iNm)GvKdpD&Kw`=&oUYe zC9LsyM02M;Cd~+~>K}KPjm?v1*TNG<56wns){0#!lRx{T`jMzLJ;Y+OMZk9v1@w}OZOfN8R0pM&2;JWV2ttfUG0fo764w@{A?W1b zdP>P+ptGY)6U02t4~b10P$2uUQ2xImD3sqW_=}kW`Hz3|JzxG~zC7LEZ0E^;|6kb7 zmH&SUVy=9O7O1W)ab{*{&Bok;kGm15qZeCVAwR1L(kM$zo*5dpF}L8Wtp)1n#Fm%K zYifd6{#Liym>cqOR{?djVp&V&uRnl%N)y=v@OJ%e(|CJtT=pA1$kVLcqK|j6_a0%h zL>L1(8gm3V$MA@EQJ%dVy5t{E_DqdYtCMQ(7MsB@i_baN4}0hR&)L`4*D{{H4~E&-=PyN$j;k3{9huh~VdDBpM$wF&*UKKGEX$3NO(X9+HTJlU)S^8odNCU! zNIEy7Sn^ZFL;k;l93#6WM&ldYlHs2-k3oPi^F7(=&Gaq|B$Z8Hq1>P9pho{TF^zBt(fTc4ZH+P*Z60( zE7THUWJ5!EtnX_kIG&71?s}5Tf@%Ud)7#VR@tNe0AVD6C(2&2O`N9SB1(~SO8J(;T%BcD>?2k6EIssvqQdKzk*%E zS3}oF%tqxa+3whEK_7ihWZ16BZE8-{qWuPs`+Z(l6vv$ltvL4AEuBx7dD_4SN5nA9 zZT`|a-zxLuUfy;iQ0<8NZ^gyO&m0?5;+Y~anQ%7XvM!!=X3MxHQ&esEpCyy6(H||u z7=IwsUF8;1Bw*t+5?6y?$jE-CL6M*M|6_*k^`APjd4qnT{kw zfT*@&K~WoRPT0T)SY2T>z!O^RQMkNK9!`r{giYXrCVb&D+h05Z3ZGC^^B-O^NED`N z08Iy#O`An(O~Jq|q86j5JJ{wi)K?n3_&0lBsQnq3DR}96fL{a6sSqKjqV_=qD>5&S zFyEfVxu5)Gf6>1J9mi6evMeYXm+!NaMwBf0gqQyb?|uteneD^}a7*4C3C|j8=UiMG zO{|iEt&*Wgycrm=AiKe}W5x1 zZoeJFd&2s`I(8wSy-pa>%WnKPMV-rcKsr&$_(vGA3wY=dmRiMlSU3;ehk zx_+;v!y4JL$pg>W>HycWwGZ+p{L%w;rB|3wJ4|eaVAZPMVu(%jr+E4g`Zwy%%L=MV zqwcu=@<`Uw{c?4Rc(san%vBG2iM2ujZA5|UU@nB+UYMcLYK_J>OFyDx!qASznR(Og z(;=!Bt}@O~oH4yzab1GAW|#x|F4egUEvdCdkwUWC}?;nhFN^2FTvr9MY*oe^X?#ayEk?&uj zf$x5ztNv0xCu!=OOtRQc*=O6V^x?;(MJQk@0 z&W$#v8-nZ(bg9h~ ze*v54*)4H|4$o!!b{HI2sb_{hFV=!sBDLc8af#3~JiFPddnQYJ3by-{UMZ z*^#+%XSC)Ai1%tu%t;@?w8R? zp3SYTlH!$KP>74n4=gme)+DhDj>;N_Y;(KGp3FAHH<9Qru0(WfuBvF5@AgiziOG`o z#=<&%ZB1%#HECARy7h?MOw8u1Xql{aqIr0TEWcYoOq9}9i=-3xzwTswS2J%Y!unlk z`5I*KCspMxLz%eK+NtZz|8caC_+jYJU2tPZ%0A(I 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%0DU2Y|T(lO>PBcZ`A<5nlQfy{p2r*_}Grc4H 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

2=HzJ2COG2jod*Fhb84AW-<`#JL!|AFWY@G!`n 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 z�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%0AcJegn{Y>v{2+?0ZF->>K!I(Q<-$ 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 + + + + +DocuSign Migration Console + + + + + +

+ + +
+ + +
+
+ Dashboard + + +
+
+
Adobe Sign
+
DocuSign
+
PH
+
+
+ +
+ + +
+
+
+
Migration Dashboard
+
Acme Corporation · 312 templates in Adobe Sign account
+
+
+ + +
+
+ + +
+
+
Total Templates
+
312
+
in Adobe Sign
+
+
+
Migrated
+
187
+
60% complete
+
+
+
Ready to Migrate
+
96
+
no issues detected
+
+
+
Needs Review
+
21
+
unsupported features
+
+
+
Blocked
+
8
+
hard stoppers found
+
+
+ + +
+
+ Overall Migration Progress + 187 / 312 templates +
+
+
+
+ ■ Migrated 60% + ■ Verified 31% + ■ Ready 31% + ■ Needs Review 7% + ■ Blocked 3% +
+
+
+
+
+
+
+
+
+
+
+ +
+ +
+
+ 🚨 Requires Attention + +
+
+
+
+ 🚫 +
+
Master Services Agreement
+
No PDF document attached — cannot migrate until document is linked in Adobe Sign
+
+
+
+
+ 🚫 +
+
NDA - Multi-party (3 signers)
+
Recipient routing order has gaps: roles jump from 1 → 3, missing role 2
+
+
+
+
+ ⚠️ +
+
Sales Commission Agreement
+
8 conditional SHOW/HIDE rules — only SHOW conditions supported in DocuSign
+
+
+
+
+ ⚠️ +
+
Employee Onboarding Form
+
3 JavaScript-calculated fields (auto-sum) — no DocuSign equivalent
+
+
+
+
+
+
+ + +
+
+ Recent Activity + +
+
+
+
+
Batch migration completed — 47 templates migrated, 2 warnings
+
2h ago
+
+
+
+
Verification passed — Purchase Order v3 · test envelope sent successfully
+
3h ago
+
+
+
+
Migration with warnings — Sales Commission Agreement · 3 conditional rules skipped
+
3h ago
+
+
+
+
Migration blocked — Master Services Agreement · no document attached
+
4h ago
+
+
+
+
Analysis completed — 312 templates scanned, 29 issues found
+
5h ago
+
+
+
+
Session started — Connected to Acme Corporation Adobe Sign account
+
5h ago
+
+
+
+
+
+ + + +
+
+
+
Templates
+
312 templates from Adobe Sign · Select templates to migrate
+
+
+ + + +
+
+ +
+ +
+
All 312
+
✅ Ready 96
+
✓ Migrated 187
+
⚠ Caveats 21
+
🚫 Blocked 8
+
+
+ + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Template NameFieldsRecipientsReadinessStatusIssuesModifiedActions
David Tag Demo Form
ID: CBJCHBCA_abc123
142ReadyNot Started✓ NoneApr 15
NDA — Standard
ID: CBJCHBCA_def456
92ReadyMigrated✓ NoneApr 17
Sales Commission Agreement
ID: CBJCHBCA_ghi789
283CaveatsMigrated⚠ 5 warningsApr 10
Master Services Agreement
ID: CBJCHBCA_jkl012
——🚫 BlockedNot Started🚫 1 blockerMar 29
Purchase Order v3
ID: CBJCHBCA_mno345
182Ready✓ Verified✓ NoneApr 18
Employee Onboarding Form
ID: CBJCHBCA_pqr678
421CaveatsNot Started⚠ 3 warningsApr 5
Vendor Contract — Short Form
ID: CBJCHBCA_stu901
112ReadyNot Started✓ NoneApr 12
Client Proposal Sign-off
ID: CBJCHBCA_vwx234
61ReadyMigrated✓ NoneApr 19
+
+
+ Showing 8 of 312 templates +
+ + + + + … + + +
+ 25 per page +
+
+
+ + + +
+
+
+
← Back to Templates
+
+
Sales Commission Agreement
+ Caveats — migrates with warnings +
+
Adobe Sign ID: CBJCHBCA_ghi789 · 28 fields · 3 recipients · Modified Apr 10, 2026
+
+
+ + +
+
+ +
+ +
+
+
Overview
+
Field Mapping (2 warnings)
+
Issues & Caveats (5)
+
Verification
+
+ + +
+
+
+
28
+
Fields
+
+
+
24
+
Map cleanly
+
+
+
4
+
Need attention
+
+
+
+
Recipient Roles
+
+ + + + + +
OrderRole NameActionFields Assigned
1Sales RepSIGN11 fields
2CustomerSIGN13 fields
3Finance ApproverAPPROVE4 fields
+
+
+
+
DocuSign Target
+
+
+
+
Will be created in:
+
Migrated Templates / Sales
+
+
+ ✓ Migrated Apr 10 +
+
+
+
DocuSign Template ID
+
a4b8c2d1-9f3e-4a2b-8c1d-7e6f5a4b3c2d
+
+
+
+ + + + + + + + + +
+ + +
+
+
Migration Options
+
+
+
+
Dry Run
+
Validate & compose without uploading to DocuSign
+
+
+
+
+
+
Include Documents
+
Embed the original PDF in the DocuSign template
+
+
+
+
+
+
Overwrite if Exists
+
Replace an existing DocuSign template with the same name
+
+
+
+
+
Target Folder
+
Where to create the template in DocuSign
+ +
+
+
+ +
+
Pre-migration Checklist
+
+
✓ PDF document attached
+
✓ All fields have roles assigned
+
✓ Recipient routing is sequential
+
⚠ 2 conditional HIDE rules will be lost
+
⚠ 2 calculated fields become plain text
+
+
+
+
+
+ + + +
+
+
+
Migration Results
+
Batch job completed · Apr 21, 2026 4:12 PM · 8 templates
+
+
+ + +
+
+ +
+
Succeeded
5
ready to verify
+
With Warnings
2
review recommended
+
Blocked
1
manual fix needed
+
Skipped
0
already migrated
+
+ +
+ ⚠️ +
Action required: "Master Services Agreement" was blocked due to a missing PDF document. Fix in Adobe Sign and re-run migration. "Sales Commission Agreement" migrated with 5 warnings — review the Issues tab before sending envelopes.
+
+ +
+
+ +
+
+ ✅ +
David Tag Demo Form
+ Success +
14 fields · 2 recipients
+ ▼ +
+
+
+ DocuSign ID: b5c9d3e2-0a4f-5b3c-9d2e-8f7a6b5c4d3e + Action: created + Duration: 2.1s +
+ Open in DocuSign ↗ + +
+
+ +
+
+ ⚠️ +
Sales Commission Agreement
+ 5 Warnings +
28 fields · 3 recipients
+ ▲ +
+
+
+ DocuSign ID: a4b8c2d1-9f3e-4a2b-8c1d-7e6f5a4b3c2d + Action: updated +
+
WARNINGS — review before using this template:
+
⚠2 conditional HIDE rules skipped — fields will always be visible to signers
+
⚠2 calculated fields converted to plain text — signers must enter values manually
+
⚠1 JavaScript validator removed — field accepts any input
+
ℹINLINE_IMAGE field skipped (expected — no DocuSign equivalent)
+
ℹPARTICIPATION_STAMP field skipped (expected)
+
+ Open in DocuSign ↗ + + +
+
+
+ +
+
+ ✅ +
Vendor Contract — Short Form
+ Success +
11 fields · 2 recipients
+ ▼ +
+
+ Open in DocuSign ↗ + +
+
+ +
+
+ 🚫 +
Master Services Agreement
+ Blocked +
Not migrated
+ ▼ +
+
+
🚫 Blocker: No documents attached
+
This template has no PDF document linked in Adobe Sign. At least one document is required to create a DocuSign template. Fix in Adobe Sign, then re-run migration.
+ +
+
+ +
+
+ ✅ +
Employee Onboarding Form
+ 3 Warnings +
42 fields · 1 recipient
+ ▼ +
+
+
⚠3 JavaScript validators removed
+ +
+
+ +
+
+
+ + + +
+
+
+
Issues & Warnings
+
29 issues across 312 templates · 3 blockers · 26 warnings
+
+
+
⚠️Blockers prevent migration and must be resolved in Adobe Sign first. Warnings allow migration to proceed but may affect signer experience — review each one.
+
+
+
🚫 Blockers (3)
+
+
BLOCK +
Missing PDF document
Master Services Agreement, Contractor Agreement v2, IP Assignment Form — no document attached
Fix in Adobe Sign: attach a PDF to the template, then re-analyze.
+
+
+
+
+
⚠ Feature Warnings (26)
+
+
WARNING +
Conditional HIDE actions
14 templates · 31 fields — HIDE conditions are not supported. Fields will always be visible.
+
+
WARNING +
Calculated fields
7 templates · 18 fields — auto-calculation formulas will be lost. Fields become plain text.
+
+
WARNING +
JavaScript validators
5 templates · 9 fields — custom validation rules will be removed.
+
+
INFO +
Skipped field types
12 templates · INLINE_IMAGE and PARTICIPATION_STAMP fields have no DocuSign equivalent and are safely skipped.
+
+
+
+
+
+ + +
+
+
+
Post-Migration Verification
+
Automatically verify migrated templates by sending test envelopes
+
+
+ +
+
+
ℹ️Verification sends a test envelope using each DocuSign template to a sandbox address. It checks that the template is valid, all tabs render correctly, and signers can complete the signing flow.
+
+
Verified
97
fully tested
+
Partial Pass
12
manual review needed
+
Failed
2
signing flow broken
+
Not Run
76
pending verification
+
+
+
Verification Queue
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TemplateMigration StatusVerificationTest EnvelopeActions
Purchase Order v3
Migrated✓ Verifiedenv_7f2a1b3c
Sales Commission Agreement
Migrated⚠ Partialenv_8a3b2c4d
David Tag Demo Form
MigratedPending—
Employee Onboarding Form
Migrated✗ Failedenv_9c4d3e5f
+
+
+
+ + +
+
+
History & Audit Log
+
All migration runs for Acme Corporation
+ +
+
+
+ + + + + + + +
TimestampRun TypeTemplatesResultOperatorActions
2026-04-21 16:12Batch (8)Sales Commission Agreement, David Tag Demo, +65 migrated, 1 blocked, 2 warningsPaul H.
2026-04-21 14:05Batch (47)HR templates batch45 migrated, 2 warningsPaul H.
2026-04-21 10:30SinglePurchase Order v3SuccessPaul H.
2026-04-20 09:15Dry Run (100)All templatesDry run — 8 blockers foundPaul H.
+
+
+ + +
+
+
Settings & Connections
+
+ + +
+
+ Migration Project + Each project is one customer engagement with its own credentials and history +
+
+
+
Customer Name
+
Project Label
+
Started
+
+
+ + + +
+
+
+ +
+
+
Adobe Sign Connection● Connected
+
+
Account: acme@corp.com (EU2 shard)
+
Token expires: 2026-04-21 18:30 UTC
+ + +
+
+
+
DocuSign Connection● Connected
+
+
Account: Acme Corp Sandbox (demo)
+
Auth method: JWT Grant
+ + +
+
+
+ + +
+
Verification SettingsUsed when sending test envelopes to validate migrated templates
+
+
+
+
Test Recipient Name
+ +
+
+
Test Recipient Email
+ +
+
+
Auto-void After
+ +
Test envelopes are voided automatically to keep the DocuSign account clean
+
+
+
Verification Mode
+ +
API-only is faster; full envelope confirms the signing experience end-to-end
+
+
+ +
+
+
+ +
+
+ + + + + + + From aa5ab4b653b804ceeaf621f0ef7c6a25b3bbd865 Mon Sep 17 00:00:00 2001 From: Paul Huliganga Date: Tue, 21 Apr 2026 10:14:59 -0400 Subject: [PATCH 03/24] fix(ui-mockup): replace approximated logo with official Docusign SVG Embedded the official Docusign full-color vector logo sourced from Wikimedia Commons (Docusign_Full_Color.svg, viewBox 0 0 1200 241.4). Wordmark paths changed to fill="#FFFFFF" for visibility on the Inkwell (#130032) nav bar; Nexus icon retains brand colors (Cobalt #4C00FF, Poppy #FF5252, white document shape). Brand name corrected to "docusign" (capital D, lowercase s per 2024 rebrand). Co-Authored-By: Claude Sonnet 4.6 --- docs/ui-mockup/mockup.html | 50 +++++++++++++++++++++----------------- 1 file changed, 28 insertions(+), 22 deletions(-) diff --git a/docs/ui-mockup/mockup.html b/docs/ui-mockup/mockup.html index ea1dee2..48ed5dd 100644 --- a/docs/ui-mockup/mockup.html +++ b/docs/ui-mockup/mockup.html @@ -310,29 +310,35 @@