runloopable / platform /core /amazon_pdp.py
fsanyoto's picture
Deploy AIOS web (React glide grid + FastAPI slice)
95fb175 verified
Raw History Blame Contribute Delete
60.7 kB
"""Tenant-bound PDP workflows backed by typed projects and atomic ASIN part claims.""" from contextlib import contextmanager from dataclasses import dataclass from importlib import import_module import base64 import hashlib import io import json import re import uuid import zipfile from xml.etree import ElementTree from core import amazon_projects as projects WORKFLOWS = 'amazon_pdp_workflows' ITEMS = 'amazon_pdp_items' CLAIMS = 'amazon_pdp_claims' PARTS = 'amazon_pdp_parts' PART_CHANGES = 'amazon_pdp_part_changes' BRAND_TEMPLATES = 'amazon_pdp_brand_templates' BRAND_TEXT = ('name', 'head', 'body', 'photo', 'voice') BRAND_LISTS = ('logos', 'colors', 'extra', 'photos', 'rules', 'donts') BRAND_MAX_BYTES = 50 * 1024 * 1024 BRAND_TYPES = {'pdf': 'application/pdf', 'png': 'image/png', 'jpg': 'image/jpeg', 'jpeg': 'image/jpeg', 'webp': 'image/webp', 'svg': 'image/svg+xml', 'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', 'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation'} TABLES = (WORKFLOWS, ITEMS, CLAIMS, PARTS) OBSERVED_PARTS = ('title', 'bullets', 'images') SCOPES = ( {'key': 'images', 'label': 'Gallery images', 'slots': ('MAIN', *(f'PT{i:02}' for i in range(1, 9)), 'VIDEO'), 'role': 'image_approver'}, {'key': 'title', 'label': 'Title', 'slots': ('TITLE',), 'role': 'copy_approver'}, {'key': 'highlights', 'label': 'Item highlights', 'slots': ('HIGHLIGHTS',), 'role': 'copy_approver'}, {'key': 'bullets', 'label': 'Bullet points', 'slots': ('BULLETS',), 'role': 'copy_approver'}, {'key': 'desc', 'label': 'Description', 'slots': ('DESC',), 'role': 'copy_approver'}, {'key': 'terms', 'label': 'Search terms', 'slots': ('TERMS',), 'role': 'copy_approver'}, {'key': 'aplus', 'label': 'A+ content', 'slots': tuple(f'A{i}' for i in range(1, 6)), 'role': 'image_approver'}, {'key': 'story', 'label': 'Brand Story', 'slots': ('STORY',), 'role': 'image_approver'}, {'key': 'details', 'label': 'Product details', 'slots': ('DETAILS',), 'role': 'copy_approver'}, ) SCOPE_PARTS = tuple(row['key'] for row in SCOPES) SLOTS = {slot: row for row in SCOPES for slot in row['slots']} SLOT_ALIASES = {row['key']: row['slots'][0] for row in SCOPES if len(row['slots']) == 1} ASSIGNEES = ('copy_approver', 'image_approver', 'publisher') STAGE_PROGRESS = {'setup': 0, 'draft': 25, 'review': 50, 'publish': 75, 'published': 100} ITEM_COLUMNS = ('asin', 'stage', 'published_on') WRITER = 'amazon_pdp' VIA = 'amazon_pdp' class Refused(ValueError): """A named workflow refusal with plain copy.""" def __init__(self, code, message): self.code = code super().__init__(message) @dataclass(frozen=True) class BoundRuntime: """Carry trusted, request bound readers without importing the API or harness.""" runtime: object live: object = None validate: object = None competitors: object = None can_edit: object = None details: object = None def __getattr__(self, name): return getattr(self.runtime, name) def bind(rt, *, live=None, validate=None, competitors=None, can_edit=None, details=None): """Bind server readers whose values cannot be supplied in an HTTP body.""" return BoundRuntime(rt, live, validate, competitors, can_edit, details) def _editor(rt, by): by = projects._text(by, 'by') if not isinstance(rt, BoundRuntime) or rt.can_edit is None or not rt.can_edit(by): raise Refused('forbidden', 'Only an editor of Command Center can change PDP parts.') return by def _writable(item): if item['stage'] == 'published': raise Refused('published', 'This item is published and cannot be changed.') def _slot(slot): slot = SLOT_ALIASES.get(slot, slot) if slot not in SLOTS: raise ValueError('Choose a PDP slot.') return slot def _text_slot(part): if part not in SLOT_ALIASES: raise ValueError('Choose a text part.') return SLOT_ALIASES[part] def _json(value): return json.loads(value) if isinstance(value, str) else (value or {}) def _slot_content(value): saved = _json(value) aliases = {SLOT_ALIASES.get(slot, slot): state for slot, state in saved.items()} return {**aliases, **{slot: state for slot, state in saved.items() if slot in SLOTS}} class PartTaken(ValueError): """An open workflow already holds the requested ASIN part.""" code = 'part_taken' def __init__(self, asin, part, workflow_id, name): self.asin, self.part, self.workflow_id = asin, part, workflow_id super().__init__(f'{asin} {part} is held by workflow "{name}" ({workflow_id}).') def _asins(values): if not isinstance(values, (list, tuple)) or not values: raise ValueError('Choose at least one ASIN.') return list(dict.fromkeys(projects.target('asin', value)[1] for value in values)) def _scope(values): if not isinstance(values, (list, tuple)) or not values: raise ValueError('Choose at least one PDP part.') return list(dict.fromkeys(projects._choice(value, 'part', SCOPE_PARTS) for value in values)) def _backend(rt): return PgPdpStore(projects._backend(rt), rt) def create(rt, *, name, asins, scope, listed=True, by=None, owner=None, priority='No priority', start_on=None, target_on=None, copy_approver=None, image_approver=None, publisher=None): """Create a project, workflow, setup items and part claims in one transaction.""" if type(listed) is not bool: raise ValueError('listed must be true or false.') asins, scope = _asins(asins), _scope(scope) backend = _backend(rt) record = projects._fields(dict(name=name, status='In progress', priority=priority, owner=owner, start_on=start_on, target_on=target_on, progress=0, notes=None, completed_on=None)) stamp = projects._now() record.update(id=uuid.uuid4().hex, tenant=backend.tenant_slug, type='pdp', listed=listed, created_at=stamp, updated_at=stamp, source_id=None, created_by=projects._text(by, 'by', optional=True)) settings = {key: projects._text(value, key, optional=True) for key, value in zip(ASSIGNEES, (copy_approver, image_approver, publisher))} return backend.create(record, asins, scope, stamp, settings) def get(rt, workflow_id): """Read a workflow and its items, including an unlisted project's row.""" return _backend(rt).get(projects._text(workflow_id, 'workflow_id')) def list_workflows(rt): """Read every tenant PDP workflow, including unlisted and published role sources.""" return _backend(rt).list_all() def set_stage(rt, workflow_id, asin, stage, *, by=None): """Change an item stage and derive project progress and completion from all items.""" by = _editor(rt, by) return _backend(rt).set_stage(projects._text(workflow_id, 'workflow_id'), projects.target('asin', asin)[1], projects._choice(stage, 'stage', STAGE_PROGRESS), by=by) def mark_published(rt, workflow_id, asin, *, by=None): """Complete one published item and free its claims in the same transaction.""" projects._text(by, 'by', optional=True) return _backend(rt).set_stage(projects._text(workflow_id, 'workflow_id'), projects.target('asin', asin)[1], 'published', trusted=True) def add_scope(rt, workflow_id, part, *, by): """Claim an additional family for every item without changing drafts or stages.""" _editor(rt, by) return _backend(rt).add_scope(projects._text(workflow_id, 'workflow_id'), _scope([part])[0]) def record_part_change(rt, asin, part, day, *, source='publish'): """Record a proven publish date without inventing a content snapshot.""" asin = projects.target('asin', asin)[1] part = projects._choice(part, 'part', SCOPE_PARTS) source = projects._choice(source, 'source', ('publish',)) day = projects._date(day, 'day') if day is None: raise ValueError('day must use YYYY-MM-DD.') return _backend(rt).record_part_change(asin, part, day, source) def observe_part_hashes(rt, snapshots, day): """Persist independent part hashes, leaving the first observation undated.""" day = projects._date(day, 'day') if day is None: raise ValueError('day must use YYYY-MM-DD.') rows = [(projects.target('asin', asin)[1], projects._choice(part, 'part', OBSERVED_PARTS), digest) for asin, parts in snapshots.items() for part, digest in parts.items()] return _backend(rt).observe_part_hashes(rows, day) if rows else 0 def part_dates(rt, asins): """Read recorded part dates without creating schema or observing listings.""" return _backend(rt).part_dates(_asins(asins)) if asins else {} def settings(rt, workflow_id, values, *, by, project_values=None): """Save workflow role usernames with no inherited tenant defaults.""" _editor(rt, by) if set(values) - set(ASSIGNEES): raise ValueError('Choose workflow approvers and publisher.') if set(project_values or {}) - {'name', 'owner', 'priority', 'start_on', 'target_on', 'notes'}: raise ValueError('Choose editable workflow settings.') values = {key: projects._text(value, key, optional=True) for key, value in values.items()} return _backend(rt).settings(workflow_id, values, project_values or {}) def brand(rt, workflow_id): """Read the workflow's stored kit dictionary without a second brand store.""" workflow = get(rt, workflow_id) empty = {**dict.fromkeys(BRAND_TEXT, ''), **{key: [] for key in BRAND_LISTS}, 'files': [], 'drafted': 0} return {**empty, 'name': workflow['name'], **workflow['settings'].get('brand', {})} def checked_brand(value, files): """Validate a complete kit and keep file identities under server control.""" keys = {*BRAND_TEXT, *BRAND_LISTS, 'files', 'drafted'} if not isinstance(value, dict) or set(value) != keys: raise ValueError('Send every brand kit section.') clean = {} for key in BRAND_TEXT: text = value[key] if not isinstance(text, str) or len(text) > 12000: raise ValueError('Keep each brand description within 12,000 characters.') clean[key] = text.strip() for key in BRAND_LISTS: rows = value[key] if not isinstance(rows, list) or len(rows) > 200 or any( not isinstance(row, str) or len(row) > 12000 for row in rows): raise ValueError('Use text lists with at most 200 entries per brand section.') clean[key] = [row.strip() for row in rows] if any(color and not re.fullmatch(r'#[0-9a-fA-F]{6}', color) for key in ('colors', 'extra') for color in clean[key]): raise ValueError('Use six digit hex codes for colours.') images = {file['id'] for file in files if file['mime'].startswith('image/')} if any(identity not in images for key in ('logos', 'photos') for identity in clean[key]): raise ValueError('Choose logos and photos from this project\'s uploaded images.') wanted = value['files'] if not isinstance(wanted, list) or any(not isinstance(row, dict) or row.get('id') not in {file['id'] for file in files} for row in wanted): raise ValueError('Choose files uploaded to this project.') retained = {row['id'] for row in wanted} | set(clean['logos']) | set(clean['photos']) stored = [file for file in files if file['id'] in retained] return {**clean, 'files': stored, 'drafted': sum(bool(file.get('read')) for file in stored)} def save_brand(rt, workflow_id, value, *, by): """Save one complete canonical kit on its workflow.""" _editor(rt, by) kit = checked_brand(value, brand(rt, workflow_id)['files']) return _backend(rt).settings(workflow_id, {'brand': kit}, {}) def brand_templates(rt): """Read all templates in the current tenant without creating schema.""" return _backend(rt).brand_templates() def save_brand_template(rt, workflow_id, *, by): """Keep an independent tenant template from the saved workflow kit.""" _editor(rt, by) kit = brand(rt, workflow_id) if not kit['name'].strip(): raise ValueError('Name the brand kit before saving a template.') return _backend(rt).save_brand_template(kit, by) def load_brand_template(rt, workflow_id, template_id, *, by): """Copy template assets and values without changing the template.""" _editor(rt, by) get(rt, workflow_id) kit = _backend(rt).brand_template(template_id)['kit'] files = [] for file in kit['files']: content = rt.download_bytes(file['path']) stored = _brand_file(rt, workflow_id, file['name'], file['mime'], content) files.append({**stored, 'read': file.get('read', False)}) copied = checked_brand({**kit, 'files': files}, files) return _backend(rt).settings(workflow_id, {'brand': copied}, {}) def _office_text(data, extension): """Extract bounded Word paragraphs or ordered PowerPoint slides using standard library XML.""" try: with zipfile.ZipFile(io.BytesIO(data)) as archive: members = archive.infolist() if len(members) > 2048 or sum(row.file_size for row in members) > 100 * 1024 * 1024: raise ValueError('This document is too large to read. Upload a smaller document.') pattern = r'word/document\.xml' if extension == 'docx' else r'ppt/slides/slide[0-9]+\.xml' selected = sorted((row for row in members if re.fullmatch(pattern, row.filename)), key=lambda row: (len(row.filename), row.filename)) if not selected or any(row.file_size > 4 * 1024 * 1024 or row.flag_bits & 1 for row in selected): raise ValueError('This document cannot be read. Upload a smaller, unencrypted document.') paragraphs = [] for member in selected: raw = archive.read(member) if b'\0' in raw or b'<!DOCTYPE' in raw.upper() or b'<!ENTITY' in raw.upper(): raise ValueError('This document contains unsupported XML.') tree = ElementTree.fromstring(raw) paragraphs.extend(''.join(node.itertext()) for node in tree.iter() if node.tag.endswith('}t')) if sum(map(len, paragraphs)) > 200000: raise ValueError('This document has too much text. Upload a shorter document.') return '\n'.join(paragraphs) except (zipfile.BadZipFile, ElementTree.ParseError, RuntimeError, NotImplementedError): raise ValueError('This document cannot be read. Upload a valid Word or PowerPoint file.') from None def _brand_svg(data): tags = {'svg', 'g', 'path', 'rect', 'circle', 'ellipse', 'line', 'polyline', 'polygon', 'text', 'tspan', 'defs', 'linearGradient', 'radialGradient', 'stop', 'clipPath', 'mask', 'pattern', 'symbol', 'use', 'title', 'desc'} xml = re.sub(rb'^\s*<\?xml\s+[^?]*\?>', b'', data, count=1) if (len(data) > 1024 * 1024 or b'\0' in data or b'<!DOCTYPE' in data.upper() or b'<!ENTITY' in data.upper() or b'<?' in xml): raise ValueError('Upload an SVG without scripts or external content, within 1 MB.') try: root = ElementTree.fromstring(data) except ElementTree.ParseError: raise ValueError('Upload a valid SVG file.') from None if root.tag != '{http://www.w3.org/2000/svg}svg': raise ValueError('Upload a valid SVG file.') for node in root.iter(): if node.tag.removeprefix('{http://www.w3.org/2000/svg}') not in tags: raise ValueError('Upload an SVG without scripts or external content.') for key, value in node.attrib.items(): key = key.split('}')[-1].lower() if (key.startswith('on') or key in ('base', 'src') or key == 'href' and not re.fullmatch(r'#[\w-]+', value) or any(word in value.lower() for word in ('url(', 'javascript:', 'expression(', '\\', '@'))): raise ValueError('Upload an SVG without scripts or external content.') def _brand_content(name, mime, data): if not isinstance(data, bytes) or not data: raise ValueError('Choose a file with content.') if len(data) > BRAND_MAX_BYTES: raise ValueError('Each file must be 50 MB or smaller.') extension = name.rsplit('.', 1)[-1].lower() if extension not in BRAND_TYPES or mime != BRAND_TYPES[extension]: raise ValueError('Upload PDF, Word, PowerPoint, PNG, JPG, SVG or WebP files.') if extension in ('docx', 'pptx'): _office_text(data, extension) elif extension == 'svg': _brand_svg(data) elif extension == 'pdf': if not data.startswith(b'%PDF-') or b'%%EOF' not in data[-2048:]: raise ValueError('Upload a valid PDF file.') else: from PIL import Image, UnidentifiedImageError try: with Image.open(io.BytesIO(data)) as image: if image.format != {'png': 'PNG', 'jpg': 'JPEG', 'jpeg': 'JPEG', 'webp': 'WEBP'}[extension]: raise ValueError('The image type does not match its file name.') if image.width * image.height > 40000000: raise ValueError('Use an image with at most 40 million pixels.') image.verify() except (UnidentifiedImageError, OSError, SyntaxError, Image.DecompressionBombError): raise ValueError('Upload a valid image file.') from None return extension def _brand_file(rt, workflow_id, name, mime, data): name = projects._text(name, 'file name') if len(name) > 240 or '/' in name or '\\' in name: raise ValueError('Use a file name without folders, within 240 characters.') extension = _brand_content(name, mime, data) identity = hashlib.sha256(data).hexdigest() path = f'amazon_pdp/brand/{workflow_id}/{identity}.{extension}' rt.upload_bytes(path, data) return dict(id=identity, name=name, size=len(data), mime=mime, path=path, read=False) def upload_brand_file(rt, workflow_id, name, mime, data, *, by, purpose='files'): """Validate and store bytes under one deterministic workflow prefix.""" _editor(rt, by) purpose = projects._choice(purpose, 'file purpose', ('files', 'logos', 'photos')) kit = brand(rt, workflow_id) if purpose != 'files' and not mime.startswith('image/'): raise ValueError('Choose an image for a logo or example photo.') file = _brand_file(rt, workflow_id, name, mime, data) file['read'] = next((row.get('read', False) for row in kit['files'] if row['id'] == file['id']), False) files = [row for row in kit['files'] if row['id'] != file['id']] + [file] kit = {**kit, 'files': files} if purpose != 'files': kit[purpose] = list(dict.fromkeys([*kit[purpose], file['id']])) return _backend(rt).settings(workflow_id, {'brand': checked_brand(kit, files)}, {}) def brand_file(rt, workflow_id, file_id): """Read only an asset retained by this workflow.""" file = next((file for file in brand(rt, workflow_id)['files'] if file['id'] == file_id), None) if file is None: raise KeyError('Brand file not found.') return file, rt.download_bytes(file['path']) def brand_draft_inputs(rt, workflow_id): """Keep PDFs and images as typed inputs and Office archives as extracted text.""" files = brand(rt, workflow_id)['files'] if not files: raise ValueError('Upload brand files before writing the kit.') if sum(file['size'] for file in files) > 60 * 1024 * 1024: raise ValueError('Choose at most 60 MB of brand files for one draft.') content = [] for file in files: data = rt.download_bytes(file['path']) extension = _brand_content(file['name'], file['mime'], data) if hashlib.sha256(data).hexdigest() != file['id']: raise Refused('brand_file_changed', 'A brand file changed. Upload it again.') if extension in ('docx', 'pptx'): content.append({'type': 'text', 'text': file['name'] + '\n' + _office_text(data, extension)}) continue uri = f"data:{file['mime']};base64," + base64.b64encode(data).decode('ascii') content.append({'type': 'image_url', 'image_url': {'url': uri}} if file['mime'].startswith('image/') else {'type': 'file', 'file': {'filename': file['name'], 'file_data': uri}}) return content def page(rt, workflow_id, asin, *, user): """Read live facts and all scoped slot states without writing.""" return _backend(rt).page(workflow_id, projects.target('asin', asin)[1], user=user) def part_state(rt, workflow_id, asin, slot, *, user): """Read one slot through the same state model used by the page and publisher.""" slot = _slot(slot) return next(row for row in page(rt, workflow_id, asin, user=user)['parts'] if row['slot'] == slot) def text_part(rt, workflow_id, asin, part, *, user): """Read a text part through the shared slot model.""" return part_state(rt, workflow_id, asin, _text_slot(part), user=user) def save_text_draft(rt, workflow_id, asin, part, value, *, option_id, by): """Save text through the same transition used by image selections.""" return save_draft(rt, workflow_id, asin, _text_slot(part), value, option_id=option_id, by=by) def save_draft(rt, workflow_id, asin, slot, value, *, option_id=None, by): """Save or clear one slot, removing its approval and resolved request.""" return _backend(rt).mutate(workflow_id, projects.target('asin', asin)[1], slot, 'draft', by=_editor(rt, by), value=value, option_id=option_id) def _details_provider(): try: return import_module('core.amazon_listing_attributes') except ModuleNotFoundError as exc: if exc.name != 'core.amazon_listing_attributes': raise raise Refused('details_provider_unavailable', 'Product details are unavailable. Try again later.') from None def details_problems(attrs, *, title=''): """Apply the shared physical checks to canonical editor values and a trusted listing title.""" provider = _details_provider() if not isinstance(attrs, dict) or set(attrs) - provider.EDITOR_KEYS or any( not isinstance(value, str) for value in attrs.values()): raise Refused('invalid_details', 'Send product attributes as text.') return provider.pd_flags(title, attrs) def _details_schema(rt, workflow_id, asin): provider = _details_provider() if not isinstance(rt, BoundRuntime) or rt.details is None: raise Refused('details_provider_unavailable', 'Product details are unavailable. Try again later.') schema = rt.details(workflow_id, asin) if not isinstance(schema, provider.DetailsSchema): raise Refused('details_schema_unavailable', 'Product details schema is unavailable. Try again later.') return provider, schema def _details_values(schema, attrs, *, draft=False): provider = _details_provider() try: if draft: if not isinstance(attrs, dict): raise provider.DetailFailure('InvalidDetailsDraft') for name, values in attrs.items(): schema.validate_attribute(name, values) return schema.render_all(attrs) except provider.DetailFailure as exc: raise Refused('invalid_details', f'Product attribute refused: {exc.reason}' + (f' ({exc.field}).' if exc.field else '.')) from None def _details_draft(rt, workflow_id, asin, value, facts): provider, schema = _details_schema(rt, workflow_id, asin) if value is None or value == {}: return None try: patch = schema.patch(value) raw = {**facts['slots']['DETAILS'], **{row['path'].removeprefix('/attributes/'): row['value'] for row in patch['patches']}} live = _details_values(schema, facts['slots']['DETAILS']) return None if _details_values(schema, raw) == live else raw except provider.DetailFailure as exc: raise Refused('invalid_details', f'Product attribute refused: {exc.reason}' + (f' ({exc.field}).' if exc.field else '.')) from None def details_part(rt, workflow_id, asin, *, user): """Expose editor strings separately from the canonical slot's raw attribute arrays.""" state = part_state(rt, workflow_id, asin, 'DETAILS', user=user) _provider, schema = _details_schema(rt, workflow_id, asin) live = _details_values(schema, state['live']) draft = _details_values(schema, state['draft'], draft=True) if state['draft'] is not None else {} facts = _facts(rt, workflow_id, asin) return dict(state=state, live=live, draft=draft, checks=details_problems({**live, **draft}, title=facts['slots'].get('TITLE') or ''), product_type=schema.product_type, marketplace_id=schema.marketplace, unsupported=list(schema.unsupported), attributes={key: field['attribute'] for key, field in schema.fields.items()}) def save_details_draft(rt, workflow_id, asin, draft, *, by): """Save editor changes through the shared guarded slot transition and return canonical text.""" if not isinstance(draft, dict): raise Refused('invalid_details', 'Send draft product attributes as an object.') save_draft(rt, workflow_id, asin, 'DETAILS', draft, by=by) return details_part(rt, workflow_id, asin, user=by) def approve(rt, workflow_id, asin, slot, *, by): """Approve a changed slot only as its assigned role and never as its drafter.""" return _backend(rt).mutate(workflow_id, projects.target('asin', asin)[1], slot, 'approve', by=_editor(rt, by)) def request_changes(rt, workflow_id, asin, slot, note, *, by): """Keep Review and attach the assigned approver's request to one slot.""" note = projects._text(note, 'request', limit=4000) return _backend(rt).mutate(workflow_id, projects.target('asin', asin)[1], slot, 'request', by=_editor(rt, by), value=note) def clear_approval(rt, workflow_id, asin, slot, *, by): """Invalidate a slot approval when an image provider changes its selected content.""" return _backend(rt).mutate(workflow_id, projects.target('asin', asin)[1], slot, 'clear_approval', by=_editor(rt, by)) def save_competitors(rt, workflow_id, asin, selected, *, by): """Save selected competitor identities resolved by the trusted source.""" by = _editor(rt, by) selected = _asins(selected) if selected else [] return _backend(rt).save_competitors(workflow_id, projects.target('asin', asin)[1], selected, by=by) def publish_snapshot(rt, workflow_id, asin, *, user): """Read the publisher and every scoped slot from the canonical part model.""" result = page(rt, workflow_id, asin, user=user) fields = ('part', 'slot', 'live', 'draft', 'changed', 'approved_by', 'requested', 'fails', 'option_id') return {key: result[key] for key in ('workflow_id', 'asin', 'sku', 'stage', 'publisher')} | { 'parts': [{key: row[key] for key in fields} for row in result['parts'] if row['part'] in result['scope']]} def _facts(rt, workflow_id, asin): if not isinstance(rt, BoundRuntime) or rt.live is None: return {'slots': {}, 'unavailable': {}, 'sku': None, 'last_updated': None} return rt.live(workflow_id, asin) def _fails(rt, workflow_id, asin, slot, value, facts): reason = facts.get('unavailable', {}).get(slot) if reason or slot not in facts['slots'] or not facts.get('sku') or not facts.get('last_updated'): return [reason or 'Live listing facts are unavailable for this part.'] if slot == 'DETAILS': try: _provider, schema = _details_schema(rt, workflow_id, asin) values = _details_values(schema, value, draft=True) return list(details_problems(values, title=facts['slots'].get('TITLE') or '').values()) except Refused as exc: return [str(exc)] if not isinstance(rt, BoundRuntime) or rt.validate is None: return ['Rules are unavailable for this part.'] fails = rt.validate(workflow_id, asin, slot, value) if not isinstance(fails, list) or any(not isinstance(reason, str) or not reason.strip() for reason in fails): return ['Rules are unavailable for this part.'] return fails def _state(rt, workflow, item, slot, saved, facts, user): part = SLOTS[slot]['key'] live = facts['slots'].get(slot) changed = saved.get('draft') is not None and saved['draft'] != live requested = saved.get('requested') approved = saved.get('approved_by') if changed and not requested else None editable_stage = item['stage'] == 'draft' or (item['stage'] == 'review' and bool(requested)) editor = isinstance(rt, BoundRuntime) and rt.can_edit is not None and rt.can_edit(user) fails = _fails(rt, workflow['id'], item['asin'], slot, saved['draft'], facts) if changed else [] label = ('Changes requested' if requested else 'No change' if not changed else 'Fails rules' if fails else 'Approved' if approved else 'Saved draft') return dict(workflow_id=workflow['id'], asin=item['asin'], part=part, slot=slot, stage=item['stage'], scope=workflow['scope'], editable=bool(editor and part in workflow['scope'] and editable_stage), requested=requested, live=live, draft=saved['draft'] if changed else None, state=label, draft_by=saved.get('draft_by') if changed else None, approved_by=approved, fails=fails, option_id=saved.get('option_id') if changed else None, changed=changed, unavailable=facts.get('unavailable', {}).get(slot)) def _draft_value(saved, value, live, option_id, by): """Every draft save, clear and reselection invalidates its approval.""" result = dict(saved) result['approved_by'] = None if value is None or value == live: return {} return {**result, 'draft': value, 'draft_by': by, 'option_id': option_id, 'requested': None} def _approve_state(workflow, state, by): if state['draft_by'] == by: raise Refused('self_approval', 'The drafter cannot approve this part.') if by != workflow.get(SLOTS[state['slot']]['role']): raise Refused('wrong_approver', 'Only the assigned approver can review this part.') if not state['changed']: raise Refused('no_change', 'Save a changed draft before approving it.') if state['fails']: raise Refused('fails_rules', 'Fix the failing rules before approving this part.') if state['requested']: raise Refused('changes_requested', 'Resolve the request before approving this part.') def _stage_rules(workflow, item, stage, states): current = item['stage'] if stage == 'published': raise Refused('trusted_publish_required', 'Publish this item through the publish action.') if current == 'setup' and stage == 'draft' and not workflow['settings'].get('competitors', {}).get(item['asin']): raise Refused('no_competitor', 'Save at least one competitor before starting Draft.') if stage == current or stage in ('setup', 'draft'): return changed = [state for state in states if state['changed']] if stage == 'review' and current == 'draft': if not changed: raise Refused('no_change', 'Save a changed draft before submitting for review.') if any(state['fails'] for state in changed): raise Refused('fails_rules', 'Fix the failing rules before submitting for review.') elif stage == 'publish' and current == 'review': if not changed or any(state['requested'] for state in states) or any(not s['approved_by'] for s in changed): raise Refused('unapproved', 'Approve every changed part and resolve every request before publishing.') if any(state['fails'] for state in changed): raise Refused('fails_rules', 'Fix the failing rules before publishing.') elif not (stage == 'review' and current == 'publish'): raise Refused('invalid_stage', 'Move this item through Setup, Draft, Review and Publish in order.') def delete(rt, workflow_id, *, by=None): """Delete a workflow and its project atomically and return its touched ASINs.""" projects._text(by, 'by', optional=True) return _backend(rt).delete(projects._text(workflow_id, 'workflow_id')) def rows(rt, asins): """Read open workflow items for the requested ASINs without creating schema.""" return _backend(rt).rows(_asins(asins)) def taken(rt, asins): """Read the tenant's named part holders for the requested ASINs.""" return _backend(rt).taken(_asins(asins)) def add_items(rt, workflow_id, asins, *, by=None): """Join ASINs and claim their workflow parts atomically.""" projects._text(by, 'by', optional=True) return _backend(rt).change_items(projects._text(workflow_id, 'workflow_id'), _asins(asins), remove=False) def remove_items(rt, workflow_id, asins, *, by=None): """Remove ASINs, their targets and their workflow graph atomically.""" projects._text(by, 'by', optional=True) return _backend(rt).change_items(projects._text(workflow_id, 'workflow_id'), _asins(asins), remove=True) def _purge_images(rt, workflow_id): try: images = import_module('core.pdp_images') except ModuleNotFoundError as exc: if exc.name != 'core.pdp_images': raise return images.purge(rt, workflow_id) class PgPdpStore: """Reuse the projects backend, tenant guard and transaction for PDP authorship.""" def __init__(self, backend, runtime=None): self.projects = backend self.rt = runtime self.tenant_slug = backend.tenant_slug self.t = backend.t def _exists(self, con): return con.execute('SELECT to_regclass(%s)', (self.t(WORKFLOWS),)).fetchone()[0] is not None def _ensure_part_changes(self, con): con.execute(f'''CREATE TABLE IF NOT EXISTS {self.t(PART_CHANGES)} ( tenant TEXT NOT NULL, asin TEXT NOT NULL, part TEXT NOT NULL CHECK (part IN ({projects._in_sql(SCOPE_PARTS)})), content_hash TEXT, observed_on DATE, changed_on DATE, source TEXT, PRIMARY KEY (tenant, asin, part))''') def record_part_change(self, asin, part, day, source): self.projects._write_guard() with self.projects._connection() as con: self._ensure_part_changes(con) con.execute(f'''INSERT INTO {self.t(PART_CHANGES)} (tenant, asin, part, changed_on, source) VALUES (%s, %s, %s, %s, %s) ON CONFLICT (tenant, asin, part) DO UPDATE SET changed_on = EXCLUDED.changed_on, source = EXCLUDED.source WHERE changed_on IS NULL OR changed_on <= EXCLUDED.changed_on''', (self.tenant_slug, asin, part, day, source)) def observe_part_hashes(self, rows, day): self.projects._write_guard() changed = ("content_hash IS NOT NULL AND content_hash <> EXCLUDED.content_hash " "AND (changed_on IS NULL OR changed_on <= EXCLUDED.observed_on)") with self.projects._connection() as con: self._ensure_part_changes(con) for asin, part, digest in rows: con.execute(f'''INSERT INTO {self.t(PART_CHANGES)} (tenant, asin, part, content_hash, observed_on) VALUES (%s, %s, %s, %s, %s) ON CONFLICT (tenant, asin, part) DO UPDATE SET content_hash = EXCLUDED.content_hash, observed_on = EXCLUDED.observed_on, changed_on = CASE WHEN {changed} THEN EXCLUDED.observed_on ELSE changed_on END, source = CASE WHEN {changed} THEN 'snapshot' ELSE source END WHERE observed_on IS NULL OR observed_on <= EXCLUDED.observed_on''', (self.tenant_slug, asin, part, digest, day)) return len(rows) def part_dates(self, asins): with self.projects._connection() as con: if con.execute('SELECT to_regclass(%s)', (self.t(PART_CHANGES),)).fetchone()[0] is None: return {} rows = [] for offset in range(0, len(asins), 2048): batch = asins[offset:offset + 2048] marks = ', '.join('%s' for _ in batch) rows.extend(con.execute(f'''SELECT asin, part, changed_on FROM {self.t(PART_CHANGES)} WHERE tenant = %s AND asin IN ({marks}) AND changed_on IS NOT NULL''', (self.tenant_slug, *batch)).fetchall()) result = {} for asin, part, day in rows: result.setdefault(asin, {})[part + '_last_updated'] = projects._date(day, 'changed_on') return result def ensure_schema(self, con): con.execute(f'''CREATE TABLE IF NOT EXISTS {self.t(WORKFLOWS)} ( tenant TEXT NOT NULL, id TEXT NOT NULL, scope JSONB NOT NULL, PRIMARY KEY (tenant, id), FOREIGN KEY (tenant, id) REFERENCES {self.t(projects.PROJECTS)} (tenant, id) ON DELETE CASCADE)''') con.execute(f"ALTER TABLE {self.t(WORKFLOWS)} ADD COLUMN IF NOT EXISTS settings JSONB NOT NULL DEFAULT '{{}}'") con.execute(f'''CREATE TABLE IF NOT EXISTS {self.t(ITEMS)} ( tenant TEXT NOT NULL, workflow_id TEXT NOT NULL, asin TEXT NOT NULL, stage TEXT NOT NULL CHECK (stage IN ({projects._in_sql(STAGE_PROGRESS)})), published_on DATE, PRIMARY KEY (tenant, workflow_id, asin), FOREIGN KEY (tenant, workflow_id) REFERENCES {self.t(WORKFLOWS)} (tenant, id) ON DELETE CASCADE, CHECK ((stage = 'published' AND published_on IS NOT NULL) OR (stage <> 'published' AND published_on IS NULL)))''') con.execute(f'''CREATE TABLE IF NOT EXISTS {self.t(CLAIMS)} ( tenant TEXT NOT NULL, asin TEXT NOT NULL, part TEXT NOT NULL, workflow_id TEXT NOT NULL, CHECK (part IN ({projects._in_sql(SCOPE_PARTS)})), PRIMARY KEY (tenant, asin, part), FOREIGN KEY (tenant, workflow_id, asin) REFERENCES {self.t(ITEMS)} (tenant, workflow_id, asin) ON DELETE CASCADE)''') con.execute(f'CREATE INDEX IF NOT EXISTS "amazon_pdp_claims_workflow" ' f'ON {self.t(CLAIMS)} (tenant, workflow_id, asin)') con.execute(f'''CREATE TABLE IF NOT EXISTS {self.t(PARTS)} ( tenant TEXT NOT NULL, workflow_id TEXT NOT NULL, asin TEXT NOT NULL, part TEXT NOT NULL CHECK (part IN ({projects._in_sql(SCOPE_PARTS)})), content JSONB NOT NULL DEFAULT '{{}}', updated_at TEXT NOT NULL, PRIMARY KEY (tenant, workflow_id, asin, part), FOREIGN KEY (tenant, workflow_id, asin) REFERENCES {self.t(ITEMS)} (tenant, workflow_id, asin) ON DELETE CASCADE)''') @contextmanager def _write(self): with self.projects._write() as con: self.ensure_schema(con) yield con def _workflow(self, con, workflow_id, *, lock=False): if not self.projects._exists(con) or not self._exists(con): raise KeyError('PDP workflow not found.') project = self.projects._one(con, workflow_id, lock=lock) row = con.execute(f"SELECT scope, to_jsonb(w)->'settings' FROM {self.t(WORKFLOWS)} w " 'WHERE tenant = %s AND id = %s', (self.tenant_slug, workflow_id)).fetchone() if project['type'] != 'pdp' or row is None: raise KeyError('PDP workflow not found.') config = _json(row[1]) return dict(project, scope=_json(row[0]), settings=config, **{key: config.get(key) for key in ASSIGNEES}) def _items(self, con, workflow_id): rows = con.execute(f'SELECT {", ".join(ITEM_COLUMNS)} FROM {self.t(ITEMS)} ' 'WHERE tenant = %s AND workflow_id = %s ORDER BY asin', (self.tenant_slug, workflow_id)).fetchall() return [dict(asin=row[0], stage=row[1], published_on=projects._date(row[2], 'published_on')) for row in rows] def _read(self, con, workflow_id): return dict(self._workflow(con, workflow_id), items=self._items(con, workflow_id)) def get(self, workflow_id): with self.projects._connection() as con: return self._read(con, workflow_id) def list_all(self): with self.projects._connection() as con: if not self.projects._exists(con) or not self._exists(con): return [] cursor = con.execute(f'SELECT w.id FROM {self.t(WORKFLOWS)} w ' f'JOIN {self.t(projects.PROJECTS)} p ON p.tenant = w.tenant AND p.id = w.id ' "WHERE w.tenant = %s AND p.type = 'pdp' ORDER BY p.created_at, p.id", (self.tenant_slug,)) records = [] for batch in iter(lambda: cursor.fetchmany(100), []): records.extend(self._read(con, row[0]) for row in batch) return records def _context(self, con, workflow_id, asin, *, lock=False): workflow = self._workflow(con, workflow_id, lock=lock) item = next((row for row in self._items(con, workflow_id) if row['asin'] == asin), None) if item is None: raise KeyError('ASIN not found in this PDP workflow.') return workflow, item def _content(self, con, workflow_id, asin): rows = con.execute(f'SELECT part, content FROM {self.t(PARTS)} ' 'WHERE tenant = %s AND workflow_id = %s AND asin = %s', (self.tenant_slug, workflow_id, asin)).fetchall() return {part: _slot_content(value) for part, value in rows} def _states(self, con, workflow, item, user): content = self._content(con, workflow['id'], item['asin']) facts = _facts(self.rt, workflow['id'], item['asin']) states = [_state(self.rt, workflow, item, slot, content.get(row['key'], {}).get(slot, {}), facts, user) for slot, row in SLOTS.items()] return states, facts def page(self, workflow_id, asin, *, user): with self.projects._connection() as con: workflow, item = self._context(con, workflow_id, asin) states, facts = self._states(con, workflow, item, user) return dict(workflow_id=workflow_id, asin=asin, stage=item['stage'], sku=facts.get('sku'), last_updated=facts.get('last_updated'), scope=workflow['scope'], parts=states, publisher=workflow['publisher'], competitors=workflow['settings'].get('competitors', {}).get(asin, [])) def _save_settings(self, con, workflow_id, config): con.execute(f'UPDATE {self.t(WORKFLOWS)} SET settings = %s::jsonb WHERE tenant = %s AND id = %s', (json.dumps(config), self.tenant_slug, workflow_id)) def settings(self, workflow_id, values, project_values): with self._write() as con: workflow = self._workflow(con, workflow_id, lock=True) for item in self._items(con, workflow_id): _writable(item) candidate = projects._fields(project_values, previous=workflow) config = {**workflow['settings'], **values} if (any(workflow[key] != config.get(key) for key in ASSIGNEES[:2]) or workflow['settings'].get('brand') != config.get('brand')): for item in self._items(con, workflow_id): self._clear_approvals(con, workflow_id, item['asin']) self._save_settings(con, workflow_id, config) fields = sorted(project_values) con.execute(f'UPDATE {self.t(projects.PROJECTS)} SET ' + ''.join(f'{key} = %s, ' for key in fields) + 'updated_at = %s WHERE tenant = %s AND id = %s', tuple(candidate[key] for key in fields) + (projects._now(), self.tenant_slug, workflow_id)) return self._read(con, workflow_id) def brand_templates(self): with self.projects._connection() as con: if con.execute('SELECT to_regclass(%s)', (self.t(BRAND_TEMPLATES),)).fetchone()[0] is None: return [] cursor = con.execute(f'SELECT id, name FROM {self.t(BRAND_TEMPLATES)} ' 'WHERE tenant = %s ORDER BY name, id', (self.tenant_slug,)) return [dict(id=row[0], name=row[1]) for batch in iter(lambda: cursor.fetchmany(100), []) for row in batch] def brand_template(self, template_id): projects._text(template_id, 'template id') with self.projects._connection() as con: if con.execute('SELECT to_regclass(%s)', (self.t(BRAND_TEMPLATES),)).fetchone()[0] is not None: row = con.execute(f'SELECT kit FROM {self.t(BRAND_TEMPLATES)} WHERE tenant = %s AND id = %s', (self.tenant_slug, template_id)).fetchone() if row: return {'id': template_id, 'kit': _json(row[0])} raise KeyError('Brand template not found.') def save_brand_template(self, kit, by): identity = hashlib.sha256(json.dumps(kit, sort_keys=True).encode()).hexdigest() with self._write() as con: con.execute(f'''CREATE TABLE IF NOT EXISTS {self.t(BRAND_TEMPLATES)} ( tenant TEXT NOT NULL, id TEXT NOT NULL, name TEXT NOT NULL, kit JSONB NOT NULL, created_at TEXT NOT NULL, created_by TEXT NOT NULL, PRIMARY KEY (tenant, id))''') con.execute(f'''INSERT INTO {self.t(BRAND_TEMPLATES)} (tenant, id, name, kit, created_at, created_by) VALUES (%s, %s, %s, %s, %s, %s) ON CONFLICT (tenant, id) DO NOTHING''', (self.tenant_slug, identity, kit['name'], json.dumps(kit), projects._now(), by)) return {'id': identity, 'name': kit['name']} def save_competitors(self, workflow_id, asin, selected, *, by): with self._write() as con: workflow, item = self._context(con, workflow_id, asin, lock=True) _writable(item) if item['stage'] != 'setup': raise Refused('setup_only', 'Choose competitors in Setup.') if selected and (not isinstance(self.rt, BoundRuntime) or self.rt.competitors is None): raise Refused('competitors_unavailable', 'Saved competitors are unavailable. Try again later.') found = self.rt.competitors(workflow_id, asin, selected) if selected else [] if not isinstance(found, list) or {row.get('asin') for row in found} != set(selected): raise Refused('invalid_competitor', 'Choose competitors saved for this item.') config = dict(workflow['settings']) config['competitors'] = {**config.get('competitors', {}), asin: found} self._save_settings(con, workflow_id, config) return self._read(con, workflow_id) def _save_content(self, con, workflow_id, asin, part, content): con.execute(f'UPDATE {self.t(PARTS)} SET content = %s::jsonb, updated_at = %s ' 'WHERE tenant = %s AND workflow_id = %s AND asin = %s AND part = %s', (json.dumps(content), projects._now(), self.tenant_slug, workflow_id, asin, part)) def _clear_approvals(self, con, workflow_id, asin): for part, content in self._content(con, workflow_id, asin).items(): if any(saved.get('approved_by') for saved in content.values()): self._save_content(con, workflow_id, asin, part, {slot: {**saved, 'approved_by': None} for slot, saved in content.items()}) def mutate(self, workflow_id, asin, slot, action, *, by, value=None, option_id=None): slot = _slot(slot) family = SLOTS[slot] option_id = projects._text(option_id, 'option_id', optional=True) with self._write() as con: workflow, item = self._context(con, workflow_id, asin, lock=True) _writable(item) if family['key'] not in workflow['scope']: raise Refused('out_of_scope', 'This part is outside the workflow scope.') content = self._content(con, workflow_id, asin)[family['key']] saved = content.get(slot, {}) facts = _facts(self.rt, workflow_id, asin) state = _state(self.rt, workflow, item, slot, saved, facts, by) updated = self._transition(workflow, state, saved, action, by, value, option_id, facts) if updated: content[slot] = updated else: content.pop(slot, None) self._save_content(con, workflow_id, asin, family['key'], content) return _state(self.rt, workflow, item, slot, updated, facts, by) def _transition(self, workflow, state, saved, action, by, value, option_id, facts): if action in ('draft', 'clear_approval'): if not state['editable']: raise Refused('not_editable', 'Edit in Draft or fix a requested part in Review.') if action == 'clear_approval': return {**saved, 'approved_by': None} if saved else {} if state['slot'] not in facts['slots'] or facts.get('unavailable', {}).get(state['slot']): raise Refused('live_unavailable', 'Live listing facts are unavailable for this part.') if state['slot'] == 'DETAILS': value = _details_draft(self.rt, workflow['id'], state['asin'], value, facts) updated = _draft_value(saved, value, state['live'], option_id, by) if updated and state['slot'] == 'DETAILS': updated['fails'] = _fails(self.rt, workflow['id'], state['asin'], state['slot'], value, facts) return updated if state['stage'] != 'review': raise Refused('review_only', 'Review this part in Review.') if action == 'approve': _approve_state(workflow, state, by) return {**saved, 'approved_by': by} if by != workflow[SLOTS[state['slot']]['role']]: raise Refused('wrong_approver', 'Only the assigned approver can review this part.') return {**saved, 'requested': value} def rows(self, asins): found = {asin: [] for asin in asins} with self.projects._connection() as con: if not self.projects._exists(con) or not self._exists(con): return found placeholders = ', '.join(['%s'] * len(asins)) items = con.execute(f'SELECT i.asin, i.workflow_id, p.name, i.stage ' f'FROM {self.t(ITEMS)} i JOIN {self.t(projects.PROJECTS)} p ' 'ON p.tenant = i.tenant AND p.id = i.workflow_id ' f'WHERE i.tenant = %s AND i.asin IN ({placeholders}) ' "AND i.stage <> 'published' ORDER BY p.created_at, p.id", (self.tenant_slug, *asins)).fetchall() for asin, workflow_id, name, stage in items: found[asin].append(dict(id=workflow_id, name=name, stage=stage, progress=STAGE_PROGRESS[stage])) return found def taken(self, asins): with self.projects._connection() as con: if not self.projects._exists(con) or not self._exists(con): return [] placeholders = ', '.join(['%s'] * len(asins)) claims = con.execute(f'SELECT c.asin, c.part, c.workflow_id, p.name FROM {self.t(CLAIMS)} c ' f'JOIN {self.t(projects.PROJECTS)} p ' 'ON p.tenant = c.tenant AND p.id = c.workflow_id ' f'WHERE c.tenant = %s AND c.asin IN ({placeholders}) ' 'ORDER BY c.asin, c.part', (self.tenant_slug, *asins)).fetchall() return [dict(asin=asin, part=part, workflowId=workflow_id, name=name) for asin, part, workflow_id, name in claims] def _claim(self, con, workflow_id, asin, scope): for part in sorted(scope): inserted = con.execute(f'INSERT INTO {self.t(CLAIMS)} (tenant, asin, part, workflow_id) ' 'VALUES (%s, %s, %s, %s) ON CONFLICT DO NOTHING RETURNING workflow_id', (self.tenant_slug, asin, part, workflow_id)).fetchone() if inserted is not None: continue holder = con.execute(f'SELECT c.workflow_id, p.name FROM {self.t(CLAIMS)} AS c ' f'JOIN {self.t(projects.PROJECTS)} AS p ' 'ON p.tenant = c.tenant AND p.id = c.workflow_id ' 'WHERE c.tenant = %s AND c.asin = %s AND c.part = %s', (self.tenant_slug, asin, part)).fetchone() if holder is None: raise RuntimeError('The holding PDP workflow changed. Retry the request.') if holder[0] != workflow_id: raise PartTaken(asin, part, *holder) def create(self, record, asins, scope, stamp, settings): workflow_id = record['id'] with self._write() as con: self.projects._insert(con, record, [('asin', asin) for asin in asins], stamp) con.execute(f'INSERT INTO {self.t(WORKFLOWS)} (tenant, id, scope, settings) ' 'VALUES (%s, %s, %s::jsonb, %s::jsonb)', (self.tenant_slug, workflow_id, json.dumps(scope), json.dumps(settings))) for asin in sorted(asins): self._insert_item(con, workflow_id, asin, scope, stamp) return self._read(con, workflow_id) def _insert_item(self, con, workflow_id, asin, scope, stamp): con.execute(f'INSERT INTO {self.t(ITEMS)} (tenant, workflow_id, asin, stage) ' "VALUES (%s, %s, %s, 'setup')", (self.tenant_slug, workflow_id, asin)) self._claim(con, workflow_id, asin, scope) for part in scope: con.execute(f'INSERT INTO {self.t(PARTS)} ' '(tenant, workflow_id, asin, part, updated_at) VALUES (%s, %s, %s, %s, %s)', (self.tenant_slug, workflow_id, asin, part, stamp)) def add_scope(self, workflow_id, part): with self._write() as con: workflow = self._workflow(con, workflow_id, lock=True) if part in workflow['scope']: return self._read(con, workflow_id) items = self._items(con, workflow_id) # Shared scope cannot change after any item has published. for item in items: _writable(item) stamp = projects._now() for item in items: self._claim(con, workflow_id, item['asin'], [part]) con.execute(f'INSERT INTO {self.t(PARTS)} ' '(tenant, workflow_id, asin, part, updated_at) VALUES (%s, %s, %s, %s, %s) ' 'ON CONFLICT DO NOTHING', (self.tenant_slug, workflow_id, item['asin'], part, stamp)) scope = [key for key in SCOPE_PARTS if key in {*workflow['scope'], part}] con.execute(f'UPDATE {self.t(WORKFLOWS)} SET scope = %s::jsonb WHERE tenant = %s AND id = %s', (json.dumps(scope), self.tenant_slug, workflow_id)) return self._read(con, workflow_id) def change_items(self, workflow_id, asins, *, remove): with self._write() as con: workflow = self._workflow(con, workflow_id, lock=True) current = {item['asin'] for item in self._items(con, workflow_id)} stamp = projects._now() if remove: for asin in sorted(set(asins) & current): _writable(next(item for item in self._items(con, workflow_id) if item['asin'] == asin)) for table in (PARTS, CLAIMS, ITEMS): con.execute(f'DELETE FROM {self.t(table)} ' 'WHERE tenant = %s AND workflow_id = %s AND asin = %s', (self.tenant_slug, workflow_id, asin)) con.execute(f'DELETE FROM {self.t(projects.TARGETS)} ' "WHERE tenant = %s AND project_id = %s AND grain = 'asin' AND key = %s", (self.tenant_slug, workflow_id, asin)) else: for asin in sorted(set(asins) - current): self._insert_item(con, workflow_id, asin, workflow['scope'], stamp) self.projects._insert_targets(con, workflow_id, [('asin', asin) for asin in asins], stamp) self._sync_progress(con, workflow_id) return self._read(con, workflow_id) def _sync_progress(self, con, workflow_id): items = self._items(con, workflow_id) progress = round(sum(STAGE_PROGRESS[item['stage']] for item in items) / len(items)) if items else 0 completed = bool(items) and all(item['stage'] == 'published' for item in items) status = projects.COMPLETED if completed else 'In progress' previous = self.projects._one(con, workflow_id) completed_on = (previous['completed_on'] or projects._today().isoformat()) if completed else None con.execute(f'UPDATE {self.t(projects.PROJECTS)} SET progress = %s, status = %s, completed_on = %s, ' 'updated_at = %s, rollup = NULL, impact = %s::jsonb WHERE tenant = %s AND id = %s', (progress, status, completed_on, projects._now(), json.dumps(projects._with_result_configs(None, previous['result_configs'])), self.tenant_slug, workflow_id)) def set_stage(self, workflow_id, asin, stage, *, by=None, trusted=False): with self._write() as con: workflow, current = self._context(con, workflow_id, asin, lock=True) if trusted and current['stage'] == 'published': return self._read(con, workflow_id) _writable(current) if not trusted: states, _facts_read = self._states(con, workflow, current, by) _stage_rules(workflow, current, stage, [s for s in states if s['part'] in workflow['scope']]) if stage in ('setup', 'draft'): self._clear_approvals(con, workflow_id, asin) published_on = (current['published_on'] or projects._today().isoformat()) if stage == 'published' else None con.execute(f'UPDATE {self.t(ITEMS)} SET stage = %s, published_on = %s ' 'WHERE tenant = %s AND workflow_id = %s AND asin = %s', (stage, published_on, self.tenant_slug, workflow_id, asin)) if stage == 'published': con.execute(f'DELETE FROM {self.t(CLAIMS)} WHERE tenant = %s AND workflow_id = %s AND asin = %s', (self.tenant_slug, workflow_id, asin)) self._sync_progress(con, workflow_id) return self._read(con, workflow_id) def delete(self, workflow_id): with self._write() as con: self._workflow(con, workflow_id, lock=True) items = self._items(con, workflow_id) for item in items: _writable(item) asins = [item['asin'] for item in items] _purge_images(self.rt, workflow_id) for table in (PARTS, CLAIMS, ITEMS): con.execute(f'DELETE FROM {self.t(table)} WHERE tenant = %s AND workflow_id = %s', (self.tenant_slug, workflow_id)) con.execute(f'DELETE FROM {self.t(WORKFLOWS)} WHERE tenant = %s AND id = %s', (self.tenant_slug, workflow_id)) self.projects._delete(con, workflow_id) return {'deleted': workflow_id, 'asins': asins}
"""Tenant-bound PDP workflows backed by typed projects and atomic ASIN part claims."""
from contextlib import contextmanager
from dataclasses import dataclass
from importlib import import_module
import base64
import hashlib
import io
import json
import re
import uuid
import zipfile
from xml.etree import ElementTree
from core import amazon_projects as projects
WORKFLOWS = 'amazon_pdp_workflows'
ITEMS = 'amazon_pdp_items'
CLAIMS = 'amazon_pdp_claims'
PARTS = 'amazon_pdp_parts'
PART_CHANGES = 'amazon_pdp_part_changes'
BRAND_TEMPLATES = 'amazon_pdp_brand_templates'
BRAND_TEXT = ('name', 'head', 'body', 'photo', 'voice')
BRAND_LISTS = ('logos', 'colors', 'extra', 'photos', 'rules', 'donts')
BRAND_MAX_BYTES = 50 * 1024 * 1024
BRAND_TYPES = {'pdf': 'application/pdf', 'png': 'image/png', 'jpg': 'image/jpeg',
'jpeg': 'image/jpeg', 'webp': 'image/webp', 'svg': 'image/svg+xml',
'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation'}
TABLES = (WORKFLOWS, ITEMS, CLAIMS, PARTS)
OBSERVED_PARTS = ('title', 'bullets', 'images')
SCOPES = (
{'key': 'images', 'label': 'Gallery images', 'slots': ('MAIN', *(f'PT{i:02}' for i in range(1, 9)), 'VIDEO'), 'role': 'image_approver'},
{'key': 'title', 'label': 'Title', 'slots': ('TITLE',), 'role': 'copy_approver'},
{'key': 'highlights', 'label': 'Item highlights', 'slots': ('HIGHLIGHTS',), 'role': 'copy_approver'},
{'key': 'bullets', 'label': 'Bullet points', 'slots': ('BULLETS',), 'role': 'copy_approver'},
{'key': 'desc', 'label': 'Description', 'slots': ('DESC',), 'role': 'copy_approver'},
{'key': 'terms', 'label': 'Search terms', 'slots': ('TERMS',), 'role': 'copy_approver'},
{'key': 'aplus', 'label': 'A+ content', 'slots': tuple(f'A{i}' for i in range(1, 6)), 'role': 'image_approver'},
{'key': 'story', 'label': 'Brand Story', 'slots': ('STORY',), 'role': 'image_approver'},
{'key': 'details', 'label': 'Product details', 'slots': ('DETAILS',), 'role': 'copy_approver'},
)
SCOPE_PARTS = tuple(row['key'] for row in SCOPES)
SLOTS = {slot: row for row in SCOPES for slot in row['slots']}
SLOT_ALIASES = {row['key']: row['slots'][0] for row in SCOPES if len(row['slots']) == 1}
ASSIGNEES = ('copy_approver', 'image_approver', 'publisher')
STAGE_PROGRESS = {'setup': 0, 'draft': 25, 'review': 50, 'publish': 75, 'published': 100}
ITEM_COLUMNS = ('asin', 'stage', 'published_on')
WRITER = 'amazon_pdp'
VIA = 'amazon_pdp'
class Refused(ValueError):
"""A named workflow refusal with plain copy."""
def __init__(self, code, message):
self.code = code
super().__init__(message)
@dataclass(frozen=True)
class BoundRuntime:
"""Carry trusted, request bound readers without importing the API or harness."""
runtime: object
live: object = None
validate: object = None
competitors: object = None
can_edit: object = None
details: object = None
def __getattr__(self, name):
return getattr(self.runtime, name)
def bind(rt, *, live=None, validate=None, competitors=None, can_edit=None, details=None):
"""Bind server readers whose values cannot be supplied in an HTTP body."""
return BoundRuntime(rt, live, validate, competitors, can_edit, details)
def _editor(rt, by):
by = projects._text(by, 'by')
if not isinstance(rt, BoundRuntime) or rt.can_edit is None or not rt.can_edit(by):
raise Refused('forbidden', 'Only an editor of Command Center can change PDP parts.')
return by
def _writable(item):
if item['stage'] == 'published':
raise Refused('published', 'This item is published and cannot be changed.')
def _slot(slot):
slot = SLOT_ALIASES.get(slot, slot)
if slot not in SLOTS:
raise ValueError('Choose a PDP slot.')
return slot
def _text_slot(part):