velocity-python 0.1.27__tar.gz → 0.1.28__tar.gz

{velocity_python-0.1.27/src/velocity_python.egg-info → velocity_python-0.1.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.27
+Version: 0.1.28
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.27 → velocity_python-0.1.28}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.27"
+version = "0.1.28"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.1.27 → velocity_python-0.1.28}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.27"
+__version__ = version = "0.1.28"
 
 import importlib as _importlib
 

{velocity_python-0.1.27 → velocity_python-0.1.28}/src/velocity/payment/authorizenet_adapter.py

@@ -29,6 +29,13 @@ from typing import Any, Dict, List, Optional
 from authorizenet import apicontractsv1, apicontrollers
 
 from .base_adapter import PaymentProcessorAdapter, ProcessorError
+from .authorizenet_mirror import (
+    sync_client_payment_account_from_authorize_account,
+    upsert_authorize_account_record,
+    upsert_authorize_customer_profile_record,
+    upsert_authorize_payment_profile_record,
+    upsert_authorize_transaction_record,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -132,20 +139,25 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
         placeholder record so the routing layer can treat it uniformly.
         """
         client_id = client_data["client_id"]
-
-        payment_account = tx.table("client_payment_accounts").new()
-        payment_account["client_id"] = client_id
-        payment_account["processor_type"] = "authorize_net"
-        payment_account["processor_account_id"] = f"an_{client_id}"
-        payment_account["account_status"] = "active"
-        payment_account["charges_enabled"] = True
-        payment_account["payouts_enabled"] = False
-        payment_account["details_submitted"] = True
-        payment_account["requirements_data"] = {}
-        payment_account["capabilities"] = {
-            "card_payments": True,
-            "manual_settlement": True,
+        account = {
+            "client_id": client_id,
+            "processor_account_id": f"an_{client_id}",
+            "status": "active",
+            "charges_enabled": True,
+            "payouts_enabled": False,
+            "verification_status": "verified",
+            "metadata": {"account_type": "shared_merchant"},
         }
+        upsert_authorize_account_record(
+            tx,
+            account,
+            source="api:authorizenet_adapter.create_account",
+        )
+        sync_client_payment_account_from_authorize_account(
+            tx,
+            account,
+            client_id=client_id,
+        )
 
         return {
             "processor_account_id": f"an_{client_id}",
@@ -161,7 +173,7 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
         """
         Authorize.Net shared merchant is always active if credentials are valid.
         """
-        return {
+        account = {
             "account_id": processor_account_id,
             "status": "active",
             "charges_enabled": True,
@@ -172,6 +184,26 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             "verification_status": "verified",
             "metadata": {"account_type": "shared_merchant"},
         }
+        payment_account = tx.table("client_payment_accounts").find(
+            {
+                "processor_account_id": processor_account_id,
+                "processor_type": "authorize_net",
+            }
+        )
+        client_id = payment_account.get("client_id") if payment_account else None
+        if client_id:
+            account["client_id"] = client_id
+        upsert_authorize_account_record(
+            tx,
+            account,
+            source="api:authorizenet_adapter.get_account_status",
+        )
+        sync_client_payment_account_from_authorize_account(
+            tx,
+            account,
+            client_id=client_id,
+        )
+        return account
 
     def create_onboarding_link(
         self, tx, processor_account_id: str, return_url: str, refresh_url: str
@@ -225,12 +257,33 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
                 parts = e.error_message.split()
                 for part in parts:
                     if part.strip().isdigit():
+                        upsert_authorize_customer_profile_record(
+                            tx,
+                            {
+                                "customer_profile_id": part.strip(),
+                                "email_address": email_address,
+                                "description": customer_data.get(
+                                    "name", email_address
+                                ),
+                            },
+                            source="api:authorizenet_adapter.get_or_create_customer_profile",
+                        )
                         return {
                             "customer_profile_id": part.strip(),
                             "created": False,
                         }
             raise
 
+        upsert_authorize_customer_profile_record(
+            tx,
+            {
+                "customer_profile_id": response["customerProfileId"],
+                "email_address": email_address,
+                "description": customer_data.get("name", email_address),
+            },
+            source="api:authorizenet_adapter.get_or_create_customer_profile",
+        )
+
         return {
             "customer_profile_id": response["customerProfileId"],
             "created": True,
@@ -287,6 +340,24 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
 
         controller = apicontrollers.createCustomerPaymentProfileController(request)
         response = self._execute(controller)
+        upsert_authorize_payment_profile_record(
+            tx,
+            {
+                "customer_profile_id": customer_profile_id,
+                "payment_profile_id": response["customerPaymentProfileId"],
+                "last4": str(payment_data.get("card_number") or "")[-4:] or None,
+                "expiration_date": payment_data.get("expiration_date"),
+                "billing_first_name": payment_data.get("first_name"),
+                "billing_last_name": payment_data.get("last_name"),
+                "billing_address": payment_data.get("address"),
+                "billing_city": payment_data.get("city"),
+                "billing_state": payment_data.get("state"),
+                "billing_zip": payment_data.get("zip"),
+                "is_default": payment_data.get("set_default", True),
+                "metadata": payment_data.get("metadata") or {},
+            },
+            source="api:authorizenet_adapter.attach_payment_method",
+        )
 
         return {
             "customer_profile_id": customer_profile_id,
@@ -326,6 +397,16 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             else:
                 raise
 
+        upsert_authorize_payment_profile_record(
+            tx,
+            {
+                "customer_profile_id": customer_profile_id,
+                "payment_profile_id": payment_method_id,
+                "detached": True,
+            },
+            source="api:authorizenet_adapter.detach_payment_method",
+        )
+
         return {"payment_profile_id": payment_method_id, "detached": True}
 
     def delete_customer_profile(self, tx, customer_profile_id: str) -> Dict[str, Any]:
@@ -343,6 +424,12 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             else:
                 raise
 
+        upsert_authorize_customer_profile_record(
+            tx,
+            {"customer_profile_id": customer_profile_id, "deleted": True},
+            source="api:authorizenet_adapter.delete_customer_profile",
+        )
+
         return {"customer_profile_id": customer_profile_id, "deleted": True}
 
     # ========================================================================
@@ -385,6 +472,24 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             response = self._execute(controller)
             trans = response.get("transactionResponse", {})
             code = int(trans.get("responseCode", 3))
+            status = "authorized" if RESPONSE_CODES.get(code) == "Approved" else "failed"
+            upsert_authorize_transaction_record(
+                tx,
+                {
+                    "processor_transaction_id": trans.get("transId"),
+                    "amount": float(amount_dollars),
+                    "status": status,
+                    "reason_for_transaction": payment_data.get("description"),
+                    "remote_authcode": trans.get("authCode"),
+                    "remote_responsecode": code,
+                    "supported_id": payment_data.get("client_id"),
+                    "supported_name": payment_data.get("description"),
+                    "email_address": payment_data.get("customer_email")
+                    or payment_data.get("donor_email"),
+                    "raw_payload": response,
+                },
+                source="api:authorizenet_adapter.authorize_payment",
+            )
 
             if RESPONSE_CODES.get(code) == "Approved":
                 return {
@@ -492,6 +597,24 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             response = self._execute(controller)
             trans = response.get("transactionResponse", {})
             code = int(trans.get("responseCode", 3))
+            status = RESPONSE_CODES.get(code, "Error")
+            upsert_authorize_transaction_record(
+                tx,
+                {
+                    "processor_transaction_id": trans.get("transId"),
+                    "amount": float(amount_dollars),
+                    "status": status,
+                    "reason_for_transaction": order.description if client_id or campaign else None,
+                    "remote_authcode": trans.get("authCode"),
+                    "remote_responsecode": code,
+                    "supported_id": client_id or None,
+                    "supported_name": campaign or None,
+                    "email_address": payment_data.get("customer_email")
+                    or payment_data.get("donor_email"),
+                    "raw_payload": response,
+                },
+                source="api:authorizenet_adapter.charge_stored_payment_method",
+            )
 
             if RESPONSE_CODES.get(code) == "Approved":
                 return {
@@ -581,6 +704,23 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             response = self._execute(controller)
             trans = response.get("transactionResponse", {})
             code = int(trans.get("responseCode", 3))
+            upsert_authorize_transaction_record(
+                tx,
+                {
+                    "processor_transaction_id": trans.get("transId")
+                    or processor_transaction_id,
+                    "amount": float(decimal.Decimal(amount) / 100)
+                    if amount is not None
+                    else None,
+                    "status": "captured"
+                    if RESPONSE_CODES.get(code) == "Approved"
+                    else "failed",
+                    "remote_authcode": trans.get("authCode"),
+                    "remote_responsecode": code,
+                    "raw_payload": response,
+                },
+                source="api:authorizenet_adapter.capture_payment",
+            )
 
             if RESPONSE_CODES.get(code) == "Approved":
                 captured_cents = amount if amount is not None else 0
@@ -635,6 +775,20 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             response = self._execute(controller)
             trans = response.get("transactionResponse", {})
             code = int(trans.get("responseCode", 3))
+            upsert_authorize_transaction_record(
+                tx,
+                {
+                    "processor_transaction_id": trans.get("transId")
+                    or processor_transaction_id,
+                    "status": "cancelled"
+                    if RESPONSE_CODES.get(code) == "Approved"
+                    else "failed",
+                    "remote_authcode": trans.get("authCode"),
+                    "remote_responsecode": code,
+                    "raw_payload": response,
+                },
+                source="api:authorizenet_adapter.cancel_payment",
+            )
 
             if RESPONSE_CODES.get(code) == "Approved":
                 return {
@@ -695,6 +849,23 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             response = self._execute(controller)
             trans = response.get("transactionResponse", {})
             code = int(trans.get("responseCode", 3))
+            upsert_authorize_transaction_record(
+                tx,
+                {
+                    "processor_transaction_id": trans.get("transId")
+                    or processor_charge_id,
+                    "amount": float(decimal.Decimal(amount) / 100)
+                    if amount is not None
+                    else None,
+                    "status": "Refunded"
+                    if RESPONSE_CODES.get(code) == "Approved"
+                    else "Error",
+                    "remote_authcode": trans.get("authCode"),
+                    "remote_responsecode": code,
+                    "raw_payload": response,
+                },
+                source="api:authorizenet_adapter.refund_payment",
+            )
 
             if RESPONSE_CODES.get(code) == "Approved":
                 return {

velocity_python-0.1.28/src/velocity/payment/authorizenet_mirror.py

@@ -0,0 +1,211 @@
+import json
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+
+def _get_value(data: Any, key: str, default: Any = None) -> Any:
+    if isinstance(data, dict):
+        return data.get(key, default)
+    return getattr(data, key, default)
+
+
+def _to_jsonable(value: Any) -> Any:
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, dict):
+        return {str(key): _to_jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple, set)):
+        return [_to_jsonable(item) for item in value]
+    if hasattr(value, "__dict__"):
+        return {
+            str(key): _to_jsonable(item)
+            for key, item in vars(value).items()
+            if not str(key).startswith("_")
+        }
+    return str(value)
+
+
+def _json_dumps(value: Any) -> Optional[str]:
+    if value is None:
+        return None
+    return json.dumps(_to_jsonable(value), default=str)
+
+
+def _table(tx, table_name: str):
+    if tx is None:
+        return None
+    try:
+        table = tx.table(table_name)
+    except Exception:
+        return None
+    try:
+        if hasattr(table, "exists") and not table.exists():
+            return None
+    except Exception:
+        pass
+    return table
+
+
+def _upsert(tx, table_name: str, payload: Dict[str, Any], key: Dict[str, Any]):
+    table = _table(tx, table_name)
+    if not table:
+        return None
+    table.upsert(payload, key)
+    return payload
+
+
+def _now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def upsert_authorize_account_record(
+    tx, account: Dict[str, Any], *, source: str = "api:authorizenet"
+) -> Optional[Dict[str, Any]]:
+    processor_account_id = _get_value(account, "processor_account_id") or _get_value(
+        account, "account_id"
+    )
+    if not processor_account_id:
+        return None
+    payload = {
+        "processor_account_id": processor_account_id,
+        "client_id": _get_value(account, "client_id"),
+        "account_status": _get_value(account, "status"),
+        "charges_enabled": _get_value(account, "charges_enabled"),
+        "payouts_enabled": _get_value(account, "payouts_enabled"),
+        "verification_status": _get_value(account, "verification_status"),
+        "metadata": _to_jsonable(_get_value(account, "metadata") or {}),
+        "raw_payload": _to_jsonable(account),
+        "sys_modified_by": source,
+        "sys_dirty": True,
+    }
+    return _upsert(
+        tx,
+        "authorize_accounts",
+        payload,
+        {"processor_account_id": processor_account_id},
+    )
+
+
+def sync_client_payment_account_from_authorize_account(
+    tx, account: Dict[str, Any], *, client_id: Any
+):
+    if not client_id:
+        return None
+    processor_account_id = _get_value(account, "processor_account_id") or _get_value(
+        account, "account_id"
+    )
+    if not processor_account_id:
+        return None
+
+    payload = {
+        "client_id": client_id,
+        "processor_type": "authorize_net",
+        "processor_account_id": processor_account_id,
+        "account_status": _get_value(account, "status") or "active",
+        "capabilities": {
+            "card_payments": True,
+            "manual_settlement": True,
+        },
+        "configuration": {
+            "verification_status": _get_value(account, "verification_status"),
+        },
+        "metadata": _to_jsonable(_get_value(account, "metadata") or {}),
+        "onboarding_complete": True,
+        "charges_enabled": True,
+        "payouts_enabled": False,
+        "details_submitted": True,
+    }
+    return _upsert(
+        tx,
+        "client_payment_accounts",
+        payload,
+        {"client_id": client_id, "processor_type": "authorize_net"},
+    )
+
+
+def upsert_authorize_customer_profile_record(
+    tx, customer_profile: Dict[str, Any], *, source: str = "api:authorizenet"
+) -> Optional[Dict[str, Any]]:
+    customer_profile_id = _get_value(customer_profile, "customer_profile_id") or _get_value(
+        customer_profile, "id"
+    )
+    if not customer_profile_id:
+        return None
+    payload = {
+        "customer_profile_id": customer_profile_id,
+        "email_address": _get_value(customer_profile, "email_address")
+        or _get_value(customer_profile, "email"),
+        "description": _get_value(customer_profile, "description"),
+        "deleted": bool(_get_value(customer_profile, "deleted")),
+        "metadata": _to_jsonable(_get_value(customer_profile, "metadata") or {}),
+        "raw_payload": _to_jsonable(customer_profile),
+        "lastupdateddate": _now(),
+        "sys_modified_by": source,
+        "sys_dirty": True,
+    }
+    return _upsert(
+        tx,
+        "authorize_customer_profiles",
+        payload,
+        {"customer_profile_id": customer_profile_id},
+    )
+
+
+def upsert_authorize_payment_profile_record(
+    tx, payment_profile: Dict[str, Any], *, source: str = "api:authorizenet"
+) -> Optional[Dict[str, Any]]:
+    payment_profile_id = _get_value(payment_profile, "payment_profile_id") or _get_value(
+        payment_profile, "id"
+    )
+    if not payment_profile_id:
+        return None
+    payload = {
+        "payment_profile_id": payment_profile_id,
+        "customer_profile_id": _get_value(payment_profile, "customer_profile_id"),
+        "last4": _get_value(payment_profile, "last4"),
+        "expiration_date": _get_value(payment_profile, "expiration_date"),
+        "billing_first_name": _get_value(payment_profile, "billing_first_name"),
+        "billing_last_name": _get_value(payment_profile, "billing_last_name"),
+        "billing_address": _get_value(payment_profile, "billing_address"),
+        "billing_city": _get_value(payment_profile, "billing_city"),
+        "billing_state": _get_value(payment_profile, "billing_state"),
+        "billing_zip": _get_value(payment_profile, "billing_zip"),
+        "is_default": _get_value(payment_profile, "is_default"),
+        "detached": bool(_get_value(payment_profile, "detached")),
+        "metadata": _to_jsonable(_get_value(payment_profile, "metadata") or {}),
+        "raw_payload": _to_jsonable(payment_profile),
+        "lastupdateddate": _now(),
+        "sys_modified_by": source,
+        "sys_dirty": True,
+    }
+    return _upsert(
+        tx,
+        "authorize_payment_profiles",
+        payload,
+        {"payment_profile_id": payment_profile_id},
+    )
+
+
+def upsert_authorize_transaction_record(
+    tx, transaction: Dict[str, Any], *, source: str = "api:authorizenet"
+) -> Optional[Dict[str, Any]]:
+    remote_transid = _get_value(transaction, "remote_transid") or _get_value(
+        transaction, "processor_transaction_id"
+    )
+    if not remote_transid:
+        return None
+    payload = {
+        "remote_transid": remote_transid,
+        "amount": _get_value(transaction, "amount"),
+        "status": _get_value(transaction, "status"),
+        "lastupdateddate": _now(),
+        "createddate": _get_value(transaction, "createddate") or _now(),
+        "reason_for_transaction": _get_value(transaction, "reason_for_transaction"),
+        "remote_authcode": _get_value(transaction, "remote_authcode"),
+        "remote_responsecode": _get_value(transaction, "remote_responsecode"),
+        "supported_id": _get_value(transaction, "supported_id"),
+        "supported_name": _get_value(transaction, "supported_name"),
+        "email_address": _get_value(transaction, "email_address"),
+        "reconcile_response": _json_dumps(_get_value(transaction, "raw_payload") or transaction),
+    }
+    return _upsert(tx, "authorize_transactions", payload, {"remote_transid": remote_transid})