celerp 1.2.7__tar.gz → 1.2.8__tar.gz

{celerp-1.2.7 → celerp-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celerp
-Version: 1.2.7
+Version: 1.2.8
 Summary: Free, self-hosted ERP for small businesses
 License: Business Source License 1.1
         

{celerp-1.2.7 → celerp-1.2.8}/celerp/connectors/base.py

@@ -9,7 +9,7 @@ CelERP relay service and injected at call time via ConnectorContext.
 
 Sync direction:
   - INBOUND: external platform -> Celerp (pull products, orders, contacts)
-  - OUTBOUND: Celerp -> external platform (push invoices, inventory updates)
+  - OUTBOUND: Celerp -> external platform (push items, invoices, inventory)
   - BOTH: bidirectional
 """
 from __future__ import annotations
@@ -49,7 +49,8 @@ class SyncFrequency(str, Enum):
     DAILY = "daily"         # once per day at configured hour
 
 
-# Entity classification for direction filtering
+# Entity classification for direction filtering. Inbound entities are pulled from
+# the platform; the *_out entities are pushed from Celerp to the platform.
 _INBOUND_ENTITIES = {"products", "orders", "contacts", "inventory"}
 _OUTBOUND_ENTITIES = {"products_out", "invoices_out", "inventory_out"}
 
@@ -77,7 +78,7 @@ class ConnectorContext:
 @dataclass
 class SyncResult:
     entity: SyncEntity
-    direction: SyncDirection
+    direction: SyncDirection = SyncDirection.INBOUND
     created: int = 0
     updated: int = 0
     skipped: int = 0
@@ -87,9 +88,18 @@ class SyncResult:
     def ok(self) -> bool:
         return not self.errors
 
+    def record(self, outcome: str) -> None:
+        """Tally a `connector_upsert`/push outcome ("created" | "updated" | "noop")."""
+        if outcome == "created":
+            self.created += 1
+        elif outcome == "updated":
+            self.updated += 1
+        else:
+            self.skipped += 1
+
 
 class ConnectorBase(ABC):
-    """Abstract base for all platform connectors."""
+    """Abstract base for all platform connectors (inbound + outbound)."""
 
     name: str
     display_name: str
@@ -109,8 +119,8 @@ class ConnectorBase(ABC):
         ...
 
     async def sync_inventory(self, ctx: ConnectorContext, since: datetime | None = None) -> SyncResult:
-        """Push Celerp inventory levels -> platform. Override if supported."""
-        raise NotImplementedError(f"{self.name} does not support inventory push")
+        """Pull inventory levels from platform -> Celerp. Override if supported."""
+        raise NotImplementedError(f"{self.name} does not support inventory sync")
 
     async def sync_contacts(self, ctx: ConnectorContext, since: datetime | None = None) -> SyncResult:
         """Pull customers/vendors from platform -> Celerp CRM. Override if supported."""
@@ -130,7 +140,7 @@ class ConnectorBase(ABC):
 
     # -- Webhook lifecycle (override for e-commerce connectors) ----------------
 
-    async def register_webhooks(self, ctx: ConnectorContext, webhook_url: str) -> list[str]:
+    async def register_webhooks(self, ctx: ConnectorContext, webhook_url: str, secret: str | None = None) -> list[str]:
         """Register platform webhooks. Returns list of webhook IDs. Override if supported."""
         return []
 

{celerp-1.2.7 → celerp-1.2.8}/celerp/connectors/daily_scheduler.py

@@ -16,11 +16,28 @@ from typing import Awaitable, Callable
 
 import sqlalchemy as sa
 
-from celerp.connectors.base import ConnectorCategory, SyncDirection, SyncFrequency
+from celerp.connectors.base import SyncDirection
 from celerp.models.connector_config import ConnectorConfig
 
 log = logging.getLogger(__name__)
 
+# Outbound entity -> connector method. A connector "supports" an outbound entity when it
+# overrides the base (which raises NotImplementedError); we only dispatch those, so the
+# scheduler never emits a failed run for a push a connector doesn't implement.
+_OUTBOUND_ENTITY_METHODS = {
+    "products_out": "sync_products_out",
+    "invoices_out": "sync_invoices_out",
+    "inventory_out": "sync_inventory_out",
+}
+
+
+def _supported_outbound(connector) -> list[str]:
+    from celerp.connectors.base import ConnectorBase
+    return [
+        entity for entity, method in _OUTBOUND_ENTITY_METHODS.items()
+        if getattr(type(connector), method, None) is not getattr(ConnectorBase, method, None)
+    ]
+
 _CHECK_INTERVAL_SECONDS = 3600  # check every hour
 _MIN_HOURS_BETWEEN_SYNCS = 23
 
@@ -81,8 +98,7 @@ async def check_and_run_daily_syncs(
             )
             continue
 
-        direction = SyncDirection(config.direction)
-        log.info("daily_scheduler: running %s (direction=%s)", config.connector, direction.value)
+        log.info("daily_scheduler: running %s", config.connector)
 
         try:
             ctx = await token_fetcher(company_id, config.connector)
@@ -90,16 +106,29 @@ async def check_and_run_daily_syncs(
             log.warning("daily_scheduler: token fetch failed for %s: %s", config.connector, exc)
             continue
 
-        # Run sync for all supported entities respecting direction
-        for entity_enum in connector.supported_entities:
+        # Sync every supported entity, honouring the configured direction: inbound
+        # entities pull from the platform; outbound (*_out) entities push back the ones
+        # the connector actually implements. run_sync enforces the direction gate too.
+        direction = SyncDirection(config.direction)
+        entities = [e.value for e in connector.supported_entities]
+        if direction in (SyncDirection.BOTH, SyncDirection.OUTBOUND):
+            entities += _supported_outbound(connector)
+        entity_results = []
+        for entity in entities:
             try:
-                await run_sync(connector, ctx, entity_enum.value, direction=direction)
+                entity_results.append(await run_sync(connector, ctx, entity, direction=direction))
             except Exception as exc:
-                log.error("daily_scheduler: sync error %s/%s: %s", config.connector, entity_enum.value, exc)
+                log.error("daily_scheduler: sync error %s/%s: %s", config.connector, entity, exc)
+
+        # Only mark the connector synced (advancing the daily clock) if at least one
+        # entity made progress. On a total failure (e.g. a transient outage) we leave
+        # last_daily_sync_at unset, so the connector stays "due" and retries at the next
+        # tick that lands on its configured hour (the next day, or sooner on app restart).
+        if not any((r.created or r.updated or not r.errors) for r in entity_results):
+            log.warning("daily_scheduler: all entities failed for %s — will retry when next due", config.connector)
+            continue
 
         synced.append(config.connector)
-
-        # Update last_daily_sync_at only after actually running
         async with get_session_ctx() as session:
             await session.execute(
                 sa.update(ConnectorConfig)

{celerp-1.2.7 → celerp-1.2.8}/celerp/connectors/http.py

@@ -45,9 +45,25 @@ class RateLimitedClient:
     async def delete(self, url: str, **kwargs) -> httpx.Response:
         return await self._request("DELETE", url, **kwargs)
 
+    # Transient transport failures (flaky network, mid-pagination drops) — retried
+    # with the same backoff as 429/503 rather than aborting the whole sync page.
+    _RETRY_EXC = (
+        httpx.ConnectError, httpx.ReadTimeout, httpx.WriteTimeout,
+        httpx.PoolTimeout, httpx.RemoteProtocolError,
+    )
+
     async def _request(self, method: str, url: str, **kwargs) -> httpx.Response:
         for attempt in range(self._max_retries + 1):
-            resp = await self._client.request(method, url, **kwargs)
+            try:
+                resp = await self._client.request(method, url, **kwargs)
+            except self._RETRY_EXC as exc:
+                if attempt == self._max_retries:
+                    raise
+                delay = self._backoff_base ** attempt
+                log.info("Transport error (%s), retry %d/%d in %.1fs",
+                         type(exc).__name__, attempt + 1, self._max_retries, delay)
+                await asyncio.sleep(delay)
+                continue
             if resp.status_code not in (429, 503):
                 return resp
             if attempt == self._max_retries:

{celerp-1.2.7 → celerp-1.2.8}/celerp/connectors/quickbooks.py

@@ -100,14 +100,13 @@ async def _query(ctx: ConnectorContext, sql: str) -> list[dict[str, Any]]:
 class QuickBooksConnector(ConnectorBase):
     name = "quickbooks"
     display_name = "QuickBooks"
-    supported_entities = [SyncEntity.PRODUCTS, SyncEntity.ORDERS, SyncEntity.CONTACTS, SyncEntity.INVOICES]
-    direction = SyncDirection.BOTH
+    supported_entities = [SyncEntity.PRODUCTS, SyncEntity.ORDERS, SyncEntity.CONTACTS]
     category = ConnectorCategory.ACCOUNTING
+    direction = SyncDirection.BOTH
     conflict_strategy = {
         SyncEntity.PRODUCTS: "newest",
         SyncEntity.ORDERS: "platform",
         SyncEntity.CONTACTS: "merge",
-        SyncEntity.INVOICES: "platform",
     }
 
     # -- Products (Items in QB) ------------------------------------------------
@@ -124,7 +123,7 @@ class QuickBooksConnector(ConnectorBase):
           Item.PurchaseCost     -> item.cost_price
           Item.Id               -> idempotency_key
         """
-        result = SyncResult(entity=SyncEntity.PRODUCTS, direction=SyncDirection.INBOUND)
+        result = SyncResult(entity=SyncEntity.PRODUCTS)
         errors: list[str] = []
 
         try:
@@ -159,11 +158,7 @@ class QuickBooksConnector(ConnectorBase):
                     cost_price=money(qb_item.get("PurchaseCost")),
                     idempotency_key=idempotency_key,
                 )
-                created = await _upsert.upsert_item(ctx.company_id, item)
-                if created:
-                    result.created += 1
-                else:
-                    result.skipped += 1
+                result.record(await _upsert.upsert_item(ctx.company_id, item))
             except Exception as exc:
                 errors.append(f"SKU {sku}: {exc}")
 
@@ -187,7 +182,7 @@ class QuickBooksConnector(ConnectorBase):
           Invoice.Balance         -> used to determine status
           Invoice.Id              -> idempotency_key
         """
-        result = SyncResult(entity=SyncEntity.ORDERS, direction=SyncDirection.INBOUND)
+        result = SyncResult(entity=SyncEntity.ORDERS)
         errors: list[str] = []
 
         try:
@@ -199,11 +194,7 @@ class QuickBooksConnector(ConnectorBase):
 
         for inv in invoices:
             try:
-                created = await _upsert.upsert_invoice_from_quickbooks(ctx.company_id, inv)
-                if created:
-                    result.created += 1
-                else:
-                    result.skipped += 1
+                result.record(await _upsert.upsert_invoice_from_quickbooks(ctx.company_id, inv))
             except Exception as exc:
                 errors.append(f"Invoice {inv.get('DocNumber')}: {exc}")
 
@@ -218,7 +209,7 @@ class QuickBooksConnector(ConnectorBase):
 
     async def sync_contacts(self, ctx: ConnectorContext, since: datetime | None = None) -> SyncResult:
         """Pull QuickBooks Customers -> Celerp CRM contacts."""
-        result = SyncResult(entity=SyncEntity.CONTACTS, direction=SyncDirection.INBOUND)
+        result = SyncResult(entity=SyncEntity.CONTACTS)
         errors: list[str] = []
 
         try:
@@ -230,11 +221,7 @@ class QuickBooksConnector(ConnectorBase):
 
         for customer in customers:
             try:
-                created = await _upsert.upsert_contact_from_quickbooks(ctx.company_id, customer)
-                if created:
-                    result.created += 1
-                else:
-                    result.skipped += 1
+                result.record(await _upsert.upsert_contact_from_quickbooks(ctx.company_id, customer))
             except Exception as exc:
                 errors.append(f"Customer {customer.get('Id')}: {exc}")
 
@@ -286,6 +273,11 @@ class QuickBooksConnector(ConnectorBase):
                         json=payload,
                     )
                     resp.raise_for_status()
+                    # Write-back: stamp the returned QB invoice id so the next run's
+                    # list_unsynced_invoices skips this doc — never created in QB twice.
+                    qb_id = ((resp.json() or {}).get("Invoice") or {}).get("Id")
+                    if qb_id and inv.get("entity_id"):
+                        await _upsert.mark_doc_pushed(ctx.company_id, inv["entity_id"], "quickbooks", qb_id)
                     result.created += 1
                 except Exception as exc:
                     errors.append(f"Invoice {inv.get('ref_id')}: {exc}")

{celerp-1.2.7 → celerp-1.2.8}/celerp/connectors/shopify.py

@@ -58,8 +58,8 @@ class ShopifyConnector(ConnectorBase):
     name = "shopify"
     display_name = "Shopify"
     supported_entities = [SyncEntity.PRODUCTS, SyncEntity.ORDERS, SyncEntity.CONTACTS]
-    direction = SyncDirection.BOTH
     category = ConnectorCategory.WEBSITE
+    direction = SyncDirection.BOTH
     conflict_strategy = {
         SyncEntity.PRODUCTS: "newest",
         SyncEntity.ORDERS: "platform",
@@ -99,7 +99,7 @@ class ShopifyConnector(ConnectorBase):
         """
         from celerp_inventory.routes import ItemCreate
 
-        result = SyncResult(entity=SyncEntity.PRODUCTS, direction=SyncDirection.INBOUND)
+        result = SyncResult(entity=SyncEntity.PRODUCTS)
         errors: list[str] = []
 
         try:
@@ -132,11 +132,7 @@ class ShopifyConnector(ConnectorBase):
                 )
 
                 try:
-                    created = await _upsert.upsert_item(ctx.company_id, item)
-                    if created:
-                        result.created += 1
-                    else:
-                        result.skipped += 1
+                    result.record(await _upsert.upsert_item(ctx.company_id, item))
                 except Exception as exc:
                     errors.append(f"SKU {sku}: {exc}")
                     continue
@@ -203,7 +199,7 @@ class ShopifyConnector(ConnectorBase):
           financial_status            -> doc status (paid -> closed, pending -> open)
           order.id                    -> idempotency_key
         """
-        result = SyncResult(entity=SyncEntity.ORDERS, direction=SyncDirection.INBOUND)
+        result = SyncResult(entity=SyncEntity.ORDERS)
         errors: list[str] = []
 
         try:
@@ -217,11 +213,7 @@ class ShopifyConnector(ConnectorBase):
 
         for order in orders:
             try:
-                created = await _upsert.upsert_order_from_shopify(ctx.company_id, order)
-                if created:
-                    result.created += 1
-                else:
-                    result.skipped += 1
+                result.record(await _upsert.upsert_order_from_shopify(ctx.company_id, order))
             except Exception as exc:
                 msg = f"Order {order.get('name')}: {exc}"
                 log.warning("shopify.sync_orders error: %s", msg)
@@ -238,7 +230,7 @@ class ShopifyConnector(ConnectorBase):
 
     async def sync_contacts(self, ctx: ConnectorContext, since: datetime | None = None) -> SyncResult:
         """Pull Shopify customers -> Celerp CRM contacts."""
-        result = SyncResult(entity=SyncEntity.CONTACTS, direction=SyncDirection.INBOUND)
+        result = SyncResult(entity=SyncEntity.CONTACTS)
         errors: list[str] = []
 
         try:
@@ -249,11 +241,7 @@ class ShopifyConnector(ConnectorBase):
 
         for customer in customers:
             try:
-                created = await _upsert.upsert_contact_from_shopify(ctx.company_id, customer)
-                if created:
-                    result.created += 1
-                else:
-                    result.skipped += 1
+                result.record(await _upsert.upsert_contact_from_shopify(ctx.company_id, customer))
             except Exception as exc:
                 errors.append(f"Customer {customer.get('id')}: {exc}")
 
@@ -262,8 +250,13 @@ class ShopifyConnector(ConnectorBase):
 
     # -- Outbound: Inventory push ----------------------------------------------
 
-    async def sync_inventory(self, ctx: ConnectorContext, since: datetime | None = None) -> SyncResult:
-        """Push Celerp stock levels -> Shopify inventory levels."""
+    async def sync_inventory_out(self, ctx: ConnectorContext) -> SyncResult:
+        """Push Celerp stock levels -> Shopify inventory levels (outbound).
+
+        Named *_out so it is classified as an outbound entity and actually gets
+        dispatched by the scheduler; as `sync_inventory` it was mis-typed as the
+        inbound 'inventory' entity and never ran (Shopify has no inbound inventory
+        pull — stock arrives via product variants)."""
         result = SyncResult(entity=SyncEntity.INVENTORY, direction=SyncDirection.OUTBOUND)
         errors: list[str] = []
 
@@ -376,47 +369,6 @@ class ShopifyConnector(ConnectorBase):
         )
         return result
 
-    # -- Webhook lifecycle -----------------------------------------------------
-
-    _INBOUND_TOPICS = [
-        "products/create", "products/update", "products/delete",
-        "orders/create", "orders/updated",
-        "inventory_levels/update",
-        "customers/create", "customers/update",
-    ]
-
-    def webhook_topics_for_direction(self, direction: SyncDirection) -> list[str]:
-        if direction == SyncDirection.OUTBOUND:
-            return []
-        return self._INBOUND_TOPICS
-
-    async def register_webhooks(self, ctx: ConnectorContext, webhook_url: str) -> list[str]:
-        """Register Shopify webhooks. Returns list of webhook IDs."""
-        base = _base_url(ctx)
-        ids: list[str] = []
-        topics = self.webhook_topics_for_direction(self.direction)
-        async with RateLimitedClient() as client:
-            for topic in topics:
-                resp = await client.post(
-                    f"{base}/webhooks.json",
-                    headers=_headers(ctx),
-                    json={"webhook": {"topic": topic, "address": webhook_url, "format": "json"}},
-                )
-                if resp.status_code in (200, 201):
-                    wh = resp.json().get("webhook", {})
-                    ids.append(str(wh.get("id", "")))
-                else:
-                    log.warning("shopify.register_webhook topic=%s status=%d", topic, resp.status_code)
-        return ids
-
-    async def deregister_webhooks(self, ctx: ConnectorContext, webhook_ids: list[str]) -> None:
-        base = _base_url(ctx)
-        async with RateLimitedClient() as client:
-            for wid in webhook_ids:
-                resp = await client.delete(f"{base}/webhooks/{wid}.json", headers=_headers(ctx))
-                if resp.status_code not in (200, 204):
-                    log.warning("shopify.deregister_webhook id=%s status=%d", wid, resp.status_code)
-
 
 # -- Pagination helper ---------------------------------------------------------
 

{celerp-1.2.7 → celerp-1.2.8}/celerp/connectors/sync_runner.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 import json
 import logging
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 
 from celerp.connectors.base import (
     ConnectorBase,
@@ -53,10 +53,90 @@ async def _last_success_watermark(company_id: str, connector: str, entity: str):
                     SyncRun.status == "success",
                 )
             )
-    except Exception:
+    except Exception as exc:
+        # A read failure degrades to a full re-pull (safe, dup-safe via idempotency
+        # keys) — but say so rather than silently widening every sync.
+        log.warning("Could not read sync watermark for %s.%s: %s — full pull", connector, entity, exc)
+        return None
+
+
+# Concurrency guard: a still-unfinished run older than this is treated as dead (the
+# process likely crashed mid-sync), so a new run is allowed to supersede it.
+_STALE_AFTER = timedelta(minutes=15)
+_BUSY = "busy"
+
+
+async def _begin_run(company_id: str, connector: str, entity: str, direction_str: str, started_at):
+    """Insert an in-progress SyncRun (status=running, finished_at=None) so the UI can
+    observe an active sync, and return its id. Returns _BUSY if a recent unfinished run
+    for this (company, connector, entity) already exists (the concurrency guard). Returns
+    None if the row could not be written, in which case the sync still runs and a single
+    final row is written by _finish_run."""
+    import sqlalchemy as sa
+
+    from celerp.db import get_session_ctx
+
+    try:
+        async with get_session_ctx() as session:
+            existing = await session.scalar(
+                sa.select(SyncRun.id)
+                .where(
+                    SyncRun.company_id == company_id,
+                    SyncRun.connector == connector,
+                    SyncRun.entity == entity,
+                    SyncRun.finished_at.is_(None),
+                    SyncRun.started_at >= started_at - _STALE_AFTER,
+                )
+                .limit(1)
+            )
+            if existing is not None:
+                return _BUSY
+            run = SyncRun(
+                company_id=company_id, connector=connector, entity=entity,
+                direction=direction_str, started_at=started_at, finished_at=None,
+                created_count=0, updated_count=0, skipped_count=0,
+                errors_json=None, status="running",
+            )
+            session.add(run)
+            await session.commit()
+            await session.refresh(run)
+            return run.id
+    except Exception as exc:
+        log.warning("Failed to record in-progress SyncRun: %s", exc)
         return None
 
 
+async def _finish_run(run_id, company_id, connector, entity, result, started_at, finished_at, status):
+    """Update the in-progress row with the final outcome, or insert a final row if the
+    in-progress write failed (run_id is None)."""
+    import sqlalchemy as sa
+
+    from celerp.db import get_session_ctx
+
+    direction_str = result.direction.value if hasattr(result.direction, "value") else str(result.direction)
+    errors_json = json.dumps(result.errors) if result.errors else None
+    try:
+        async with get_session_ctx() as session:
+            if run_id is not None:
+                await session.execute(
+                    sa.update(SyncRun).where(SyncRun.id == run_id).values(
+                        direction=direction_str, finished_at=finished_at,
+                        created_count=result.created, updated_count=result.updated,
+                        skipped_count=result.skipped, errors_json=errors_json, status=status,
+                    )
+                )
+            else:
+                session.add(SyncRun(
+                    company_id=company_id, connector=connector, entity=entity,
+                    direction=direction_str, started_at=started_at, finished_at=finished_at,
+                    created_count=result.created, updated_count=result.updated,
+                    skipped_count=result.skipped, errors_json=errors_json, status=status,
+                ))
+            await session.commit()
+    except Exception as exc:
+        log.warning("Failed to record SyncRun: %s", exc)
+
+
 async def run_sync(
     connector: ConnectorBase,
     ctx: ConnectorContext,
@@ -69,8 +149,6 @@ async def run_sync(
     If ``direction`` is provided, checks whether ``entity`` is allowed
     for that direction before running. Returns a failed SyncResult if blocked.
     """
-    from celerp.db import get_session_ctx
-
     # Direction gate
     if direction and not entity_allowed(entity, direction):
         try:
@@ -92,13 +170,25 @@ async def run_sync(
     if sync_method is None:
         raise ValueError(f"{connector.name} has no method {method_name}")
 
+    started_at = datetime.now(timezone.utc)
+    intended_direction = direction if isinstance(direction, SyncDirection) else connector.direction
+    direction_str = intended_direction.value if hasattr(intended_direction, "value") else str(intended_direction)
+
+    # Mark this entity's sync as in progress (and refuse to start a second concurrent
+    # run for the same entity). The UI polls these rows for live status.
+    run_id = await _begin_run(ctx.company_id, connector.name, entity, direction_str, started_at)
+    if run_id == _BUSY:
+        return SyncResult(
+            entity=entity,
+            direction=intended_direction,
+            errors=[f"{entity} sync already in progress"],
+        )
+
     # Incremental by default: pull only what changed since the last successful run
     # for this entity. Idempotency keys make any overlap dup-safe.
     if since is None and entity not in _OUTBOUND_ENTITIES:
         since = await _last_success_watermark(ctx.company_id, connector.name, entity)
 
-    started_at = datetime.now(timezone.utc)
-
     try:
         if entity in _OUTBOUND_ENTITIES:
             result = await sync_method(ctx)
@@ -126,26 +216,7 @@ async def run_sync(
     else:
         status = "success"
 
-    run = SyncRun(
-        company_id=ctx.company_id,
-        connector=connector.name,
-        entity=entity,
-        direction=result.direction.value if hasattr(result.direction, "value") else str(result.direction),
-        started_at=started_at,
-        finished_at=finished_at,
-        created_count=result.created,
-        updated_count=result.updated,
-        skipped_count=result.skipped,
-        errors_json=json.dumps(result.errors) if result.errors else None,
-        status=status,
-    )
-
-    try:
-        async with get_session_ctx() as session:
-            session.add(run)
-            await session.commit()
-    except Exception as exc:
-        log.warning("Failed to record SyncRun: %s", exc)
+    await _finish_run(run_id, ctx.company_id, connector.name, entity, result, started_at, finished_at, status)
 
     log.info(
         "sync_run %s.%s company=%s status=%s created=%d updated=%d skipped=%d errors=%d",

{celerp-1.2.7 → celerp-1.2.8}/celerp/connectors/upsert.py

@@ -9,51 +9,53 @@ light and to respect default-module load order.
 from __future__ import annotations
 
 
-async def upsert_item(company_id: str, item) -> bool:
+async def upsert_item(company_id: str, item) -> str:
     from celerp_inventory import services as items_svc
     return await items_svc.upsert_from_connector(company_id, item)
 
 
-async def upsert_order_from_shopify(company_id: str, order: dict) -> bool:
+async def upsert_order_from_shopify(company_id: str, order: dict) -> str:
     from celerp_docs import doc_service as docs_svc
     return await docs_svc.upsert_order_from_shopify(company_id, order)
 
 
-async def upsert_invoice_from_quickbooks(company_id: str, invoice: dict) -> bool:
+async def upsert_invoice_from_quickbooks(company_id: str, invoice: dict) -> str:
     from celerp_docs import doc_service as docs_svc
     return await docs_svc.upsert_invoice_from_quickbooks(company_id, invoice)
 
 
-async def upsert_invoice_from_xero(company_id: str, invoice: dict) -> bool:
+async def upsert_invoice_from_xero(company_id: str, invoice: dict) -> str:
     from celerp_docs import doc_service as docs_svc
     return await docs_svc.upsert_invoice_from_xero(company_id, invoice)
 
 
-async def upsert_order_from_woocommerce(company_id: str, order: dict) -> bool:
+async def upsert_order_from_woocommerce(company_id: str, order: dict) -> str:
     from celerp_docs import doc_service as docs_svc
     return await docs_svc.upsert_order_from_woocommerce(company_id, order)
 
 
-async def upsert_contact_from_shopify(company_id: str, customer: dict) -> bool:
+async def upsert_contact_from_shopify(company_id: str, customer: dict) -> str:
     from celerp_contacts import services as contacts_svc
     return await contacts_svc.upsert_contact_from_shopify(company_id, customer)
 
 
-async def upsert_contact_from_quickbooks(company_id: str, customer: dict) -> bool:
+async def upsert_contact_from_quickbooks(company_id: str, customer: dict) -> str:
     from celerp_contacts import services as contacts_svc
     return await contacts_svc.upsert_contact_from_quickbooks(company_id, customer)
 
 
-async def upsert_contact_from_xero(company_id: str, contact: dict) -> bool:
+async def upsert_contact_from_xero(company_id: str, contact: dict) -> str:
     from celerp_contacts import services as contacts_svc
     return await contacts_svc.upsert_contact_from_xero(company_id, contact)
 
 
-async def upsert_contact_from_woocommerce(company_id: str, customer: dict) -> bool:
+async def upsert_contact_from_woocommerce(company_id: str, customer: dict) -> str:
     from celerp_contacts import services as contacts_svc
     return await contacts_svc.upsert_contact_from_woocommerce(company_id, customer)
 
 
+# -- Outbound: read the Celerp-side list of records to push ---------------------
+
 async def list_items_with_external_id(company_id: str, platform: str) -> list:
     from celerp_inventory import services as items_svc
     return await items_svc.list_items_with_external_id(company_id, platform=platform)
@@ -67,3 +69,8 @@ async def list_items_modified_since_last_sync(company_id: str, platform: str) ->
 async def list_unsynced_invoices(company_id: str, platform: str) -> list:
     from celerp_docs import doc_service as docs_svc
     return await docs_svc.list_unsynced_invoices(company_id, platform=platform)
+
+
+async def mark_doc_pushed(company_id: str, entity_id: str, platform: str, external_id: str, entity: str = "invoice") -> None:
+    from celerp_docs import doc_service as docs_svc
+    return await docs_svc.mark_doc_pushed(company_id, entity_id, platform, external_id, entity=entity)