velocity-python 0.0.230__tar.gz → 0.0.232__tar.gz

{velocity_python-0.0.230/src/velocity_python.egg-info → velocity_python-0.0.232}/PKG-INFO

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

{velocity_python-0.0.230 → velocity_python-0.0.232}/pyproject.toml

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

{velocity_python-0.0.230 → velocity_python-0.0.232}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.229"
+__version__ = version = "0.0.232"
 
 from . import aws
 from . import db

{velocity_python-0.0.230 → velocity_python-0.0.232}/src/velocity/payment/__init__.py

@@ -54,6 +54,7 @@ from .profiles import (
     build_stripe_payment_profile,
     upsert_payment_profile,
 )
+from .demo_profiles import resolve_demo_charge_cards, get_card_lookup_id
 
 __all__ = [
     # Base classes
@@ -80,6 +81,8 @@ __all__ = [
     "get_payment_profile_sources",
     "build_stripe_payment_profile",
     "upsert_payment_profile",
+    "resolve_demo_charge_cards",
+    "get_card_lookup_id",
 ]
 
 __version__ = "1.0.0"

velocity_python-0.0.232/src/velocity/payment/demo_profiles.py

@@ -0,0 +1,304 @@
+"""Demo-only payment profile helpers for charging copied production users safely."""
+
+import os
+from typing import Dict, List, Optional
+
+from .profiles import get_payment_profile_sources, upsert_payment_profile
+from .router import get_processor_config
+
+_DEMO_BRAINTREE_NONCE = "fake-valid-nonce"
+_DEMO_STRIPE_TOKEN = "tok_visa"
+_DEMO_AUTHORIZE_CARD_NUMBER = "4111111111111111"
+_DEMO_AUTHORIZE_EXPIRATION = "2030-12"
+_DEMO_AUTHORIZE_CARD_CODE = "123"
+
+
+def is_demo_environment() -> bool:
+    return str(os.environ.get("USER_BRANCH") or "demo").lower() != "production"
+
+
+def build_demo_profile_email(email_address: str, processor_code: str) -> str:
+    email_address = str(email_address or "")
+    if "@" not in email_address:
+        return email_address
+    local_part, domain = email_address.split("@", 1)
+    return f"{local_part}+demo-{processor_code}@{domain}"
+
+
+def _format_expiration_date(year, month) -> str:
+    return f"{year}-{str(month).zfill(2)}"
+
+
+def _save_payment_profile(tx, data: Dict) -> Dict:
+    upsert_payment_profile(
+        tx,
+        data,
+        key={"payment_profile_id": data["payment_profile_id"]},
+    )
+    tx.commit()
+    return data
+
+
+def get_card_lookup_id(card: Dict) -> str:
+    return str(
+        card.get("sys_id")
+        or card.get("payment_profile_id")
+        or card.get("customer_profile_id")
+        or card.get("src")
+        or "unknown-card"
+    )
+
+
+def _get_demo_braintree_card(tx, user: Dict) -> Dict:
+    import braintree
+
+    config = get_processor_config("braintree")
+    environment = (
+        braintree.Environment.Production
+        if str(config.get("environment") or "sandbox").lower() == "production"
+        else braintree.Environment.Sandbox
+    )
+    gateway = braintree.BraintreeGateway(
+        braintree.Configuration(
+            environment=environment,
+            merchant_id=config["merchant_id"],
+            public_key=config["public_key"],
+            private_key=config["private_key"],
+        )
+    )
+
+    demo_email = build_demo_profile_email(user["email_address"], "bt")
+    customer = None
+
+    collection = gateway.customer.search(braintree.CustomerSearch.email == demo_email)
+    for existing_customer in collection.items:
+      customer = existing_customer
+      for payment_method in existing_customer.payment_methods:
+          return _save_payment_profile(
+              tx,
+              {
+                  "src": "BT",
+                  "card_type": getattr(payment_method, "card_type", "Visa"),
+                  "card_number": getattr(payment_method, "last_4", "1111"),
+                  "expiration_date": _format_expiration_date(
+                      getattr(payment_method, "expiration_year", "2030"),
+                      getattr(payment_method, "expiration_month", "12"),
+                  ),
+                  "payment_profile_id": payment_method.token,
+                  "customer_profile_id": payment_method.customer_id,
+                  "email_address": user["email_address"],
+                  "first_name": user.get("first_name")
+                  or user["email_address"].split("@")[0],
+                  "last_name": user.get("last_name") or "Demo",
+                  "is_default": getattr(payment_method, "default", True),
+              },
+          )
+
+    if customer is None:
+        result = gateway.customer.create(
+            {
+                "email": demo_email,
+                "first_name": user.get("first_name")
+                or user["email_address"].split("@")[0],
+                "last_name": user.get("last_name") or "Demo",
+            }
+        )
+        if not result.is_success:
+            raise RuntimeError(result.message)
+        customer = result.customer
+
+    payment_method_result = gateway.payment_method.create(
+        {
+            "customer_id": customer.id,
+            "payment_method_nonce": _DEMO_BRAINTREE_NONCE,
+            "options": {"make_default": True, "verify_card": True},
+        }
+    )
+    if not payment_method_result.is_success:
+        raise RuntimeError(payment_method_result.message)
+
+    payment_method = payment_method_result.payment_method
+    return _save_payment_profile(
+        tx,
+        {
+            "src": "BT",
+            "card_type": getattr(payment_method, "card_type", "Visa"),
+            "card_number": getattr(payment_method, "last_4", "1111"),
+            "expiration_date": _format_expiration_date(
+                getattr(payment_method, "expiration_year", "2030"),
+                getattr(payment_method, "expiration_month", "12"),
+            ),
+            "payment_profile_id": payment_method.token,
+            "customer_profile_id": customer.id,
+            "email_address": user["email_address"],
+            "first_name": user.get("first_name")
+            or user["email_address"].split("@")[0],
+            "last_name": user.get("last_name") or "Demo",
+            "is_default": True,
+        },
+    )
+
+
+def _get_demo_stripe_card(tx, user: Dict) -> Dict:
+    import stripe
+
+    stripe_config = get_processor_config("stripe")
+    api_key = stripe_config["api_key"]
+    demo_email = build_demo_profile_email(user["email_address"], "st")
+    full_name = user.get("full_name") or user["email_address"]
+
+    customers = stripe.Customer.list(email=demo_email, limit=1, api_key=api_key)
+    if customers.data:
+        customer = customers.data[0]
+    else:
+        customer = stripe.Customer.create(
+            email=demo_email,
+            name=full_name,
+            metadata={
+                "platform": "caringcent",
+                "environment": "demo",
+                "source_email": user["email_address"],
+            },
+            api_key=api_key,
+        )
+
+    payment_methods = stripe.PaymentMethod.list(
+        customer=customer.id, type="card", limit=1, api_key=api_key
+    )
+    if payment_methods.data:
+        payment_method = payment_methods.data[0]
+    else:
+        payment_method = stripe.PaymentMethod.create(
+            type="card",
+            card={"token": _DEMO_STRIPE_TOKEN},
+            billing_details={"email": demo_email, "name": full_name},
+            api_key=api_key,
+        )
+        payment_method = stripe.PaymentMethod.attach(
+            payment_method.id, customer=customer.id, api_key=api_key
+        )
+        stripe.Customer.modify(
+            customer.id,
+            invoice_settings={"default_payment_method": payment_method.id},
+            api_key=api_key,
+        )
+
+    return _save_payment_profile(
+        tx,
+        {
+            "src": "ST",
+            "card_type": getattr(payment_method.card, "brand", "visa"),
+            "card_number": getattr(payment_method.card, "last4", "4242"),
+            "expiration_date": _format_expiration_date(
+                getattr(payment_method.card, "exp_year", "2030"),
+                getattr(payment_method.card, "exp_month", "12"),
+            ),
+            "payment_profile_id": payment_method.id,
+            "customer_profile_id": customer.id,
+            "email_address": user["email_address"],
+            "first_name": user.get("first_name")
+            or user["email_address"].split("@")[0],
+            "last_name": user.get("last_name") or "Demo",
+            "is_default": True,
+        },
+    )
+
+
+def _get_demo_authorize_card(tx, user: Dict) -> Dict:
+    from .authorizenet_adapter import AuthorizeNetAdapter
+
+    adapter = AuthorizeNetAdapter(get_processor_config("authorizenet"))
+    demo_email = build_demo_profile_email(user["email_address"], "an")
+    customer_result = adapter.get_or_create_customer_profile(
+        tx,
+        {
+            "email_address": demo_email,
+            "name": user.get("full_name") or user["email_address"],
+        },
+    )
+    customer_profile_id = customer_result["customer_profile_id"]
+    existing = (
+        tx.table("payment_profiles")
+        .select(
+            where={
+                "src": "AN",
+                "email_address": user["email_address"],
+                "customer_profile_id": customer_profile_id,
+            },
+            orderby="is_default desc, sys_id desc",
+        )
+        .as_dict()
+        .all()
+    )
+    if existing:
+        return existing[0]
+
+    payment_result = adapter.attach_payment_method(
+        tx,
+        customer_profile_id,
+        "",
+        {
+            "card_number": _DEMO_AUTHORIZE_CARD_NUMBER,
+            "expiration_date": _DEMO_AUTHORIZE_EXPIRATION,
+            "card_code": _DEMO_AUTHORIZE_CARD_CODE,
+            "first_name": user.get("first_name")
+            or user["email_address"].split("@")[0],
+            "last_name": user.get("last_name") or "Demo",
+            "set_default": True,
+        },
+    )
+    return _save_payment_profile(
+        tx,
+        {
+            "src": "AN",
+            "card_type": "Visa",
+            "card_number": _DEMO_AUTHORIZE_CARD_NUMBER[-4:],
+            "expiration_date": _DEMO_AUTHORIZE_EXPIRATION,
+            "payment_profile_id": payment_result["payment_profile_id"],
+            "customer_profile_id": customer_profile_id,
+            "email_address": user["email_address"],
+            "first_name": user.get("first_name")
+            or user["email_address"].split("@")[0],
+            "last_name": user.get("last_name") or "Demo",
+            "is_default": True,
+        },
+    )
+
+
+def get_demo_card_for_source(tx, user: Dict, source: str) -> Optional[Dict]:
+    if source == "BT":
+        return _get_demo_braintree_card(tx, user)
+    if source == "ST":
+        return _get_demo_stripe_card(tx, user)
+    if source == "AN":
+        return _get_demo_authorize_card(tx, user)
+    return None
+
+
+def resolve_demo_charge_cards(tx, user: Dict, payment_processor: str, cards: List[Dict]):
+    if not is_demo_environment():
+        return cards
+
+    resolved_cards = []
+    demo_cards_by_source = {}
+    for card in cards:
+        source = card.get("src")
+        if source not in demo_cards_by_source:
+            demo_cards_by_source[source] = get_demo_card_for_source(tx, user, source)
+        demo_card = demo_cards_by_source[source]
+        if demo_card:
+            merged_card = dict(card)
+            merged_card.update(demo_card)
+            resolved_cards.append(merged_card)
+        else:
+            resolved_cards.append(card)
+
+    if resolved_cards:
+        return resolved_cards
+
+    for source in get_payment_profile_sources(payment_processor):
+        demo_card = get_demo_card_for_source(tx, user, source)
+        if demo_card:
+            return [demo_card]
+
+    return cards

{velocity_python-0.0.230 → velocity_python-0.0.232/src/velocity_python.egg-info}/PKG-INFO

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

{velocity_python-0.0.230 → velocity_python-0.0.232}/src/velocity_python.egg-info/SOURCES.txt

@@ -133,6 +133,7 @@ src/velocity/payment/__init__.py
 src/velocity/payment/authorizenet_adapter.py
 src/velocity/payment/base_adapter.py
 src/velocity/payment/braintree_adapter.py
+src/velocity/payment/demo_profiles.py
 src/velocity/payment/profiles.py
 src/velocity/payment/router.py
 src/velocity/payment/stripe_adapter.py
@@ -148,6 +149,7 @@ tests/test_lambda_handler.py
 tests/test_lambda_handler_auth.py
 tests/test_mixins_import.py
 tests/test_payment_braintree_adapter.py
+tests/test_payment_demo_profiles.py
 tests/test_payment_profiles.py
 tests/test_payment_router.py
 tests/test_payment_stripe_adapter.py

velocity_python-0.0.232/tests/test_payment_demo_profiles.py

@@ -0,0 +1,58 @@
+from velocity.payment.demo_profiles import resolve_demo_charge_cards
+
+
+def test_resolve_demo_charge_cards_replaces_existing_cards(monkeypatch):
+    user = {"email_address": "person@example.com"}
+    prod_card = {
+        "src": "BT",
+        "payment_profile_id": "prod-token",
+        "customer_profile_id": "prod-customer",
+    }
+
+    monkeypatch.setattr(
+        "velocity.payment.demo_profiles.is_demo_environment", lambda: True
+    )
+    monkeypatch.setattr(
+        "velocity.payment.demo_profiles.get_demo_card_for_source",
+        lambda tx, user, source: {
+            "src": source,
+            "payment_profile_id": "demo-token",
+            "customer_profile_id": "demo-customer",
+        },
+    )
+
+    resolved = resolve_demo_charge_cards(None, user, "braintree", [prod_card])
+
+    assert resolved == [
+        {
+            "src": "BT",
+            "payment_profile_id": "demo-token",
+            "customer_profile_id": "demo-customer",
+        }
+    ]
+
+
+def test_resolve_demo_charge_cards_creates_fallback_card_when_none_exist(monkeypatch):
+    user = {"email_address": "person@example.com"}
+
+    monkeypatch.setattr(
+        "velocity.payment.demo_profiles.is_demo_environment", lambda: True
+    )
+    monkeypatch.setattr(
+        "velocity.payment.demo_profiles.get_demo_card_for_source",
+        lambda tx, user, source: {
+            "src": source,
+            "payment_profile_id": f"{source.lower()}-demo-token",
+            "customer_profile_id": f"{source.lower()}-demo-customer",
+        },
+    )
+
+    resolved = resolve_demo_charge_cards(None, user, "stripe", [])
+
+    assert resolved == [
+        {
+            "src": "ST",
+            "payment_profile_id": "st-demo-token",
+            "customer_profile_id": "st-demo-customer",
+        }
+    ]