sboulahtit/orion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: fix all architecture validator findings (202 → 0)

Browse Source 
Eliminate all 103 errors and 96 warnings from the architecture validator:

Phase 1 - Validator rules & YAML:
- Add NAM-001/NAM-002 exceptions for module-scoped router/service files
- Fix API-004 to detect # public comments on decorator lines
- Add module-specific exception bases to EXC-004 valid_bases
- Exclude storefront files from AUTH-004 store context check
- Add SVC-006 exceptions for loyalty service atomic commits
- Fix _get_rule() to search naming_rules and auth_rules categories
- Use plain # CODE comments instead of # noqa: CODE for custom rules

Phase 2 - Billing module (5 route files):
- Move _resolve_store_to_merchant to subscription_service
- Move tier/feature queries to feature_service, admin_subscription_service
- Extract 22 inline Pydantic schemas to billing/schemas/billing.py
- Replace all HTTPException with domain exceptions

Phase 3 - Loyalty module (4 routes + points_service):
- Add 7 domain exceptions (Apple auth, enrollment, device registration)
- Add service methods to card_service, program_service, apple_wallet_service
- Move all db.query() from routes to service layer
- Fix SVC-001: replace HTTPException in points_service with domain exception

Phase 4 - Remaining modules:
- tenancy: move store stats queries to admin_service
- cms: move platform resolution to content_page_service, add NoPlatformSubscriptionException
- messaging: move user/customer lookups to messaging_service
- Add ConfigDict(from_attributes=True) to ContentPageResponse

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Samir Boulahtit
2026-02-13 18:49:24 +01:00
parent 9173448645
commit 7c43d6f4a2
48 changed files with 1613 additions and 1039 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
app/modules/loyalty/routes/api/admin.py
View File

@@ -10,7 +10,7 @@ Platform admin endpoints for:
import logging
from fastapi import APIRouter, Depends, HTTPException, Path, Query
from fastapi import APIRouter, Depends, Path, Query
from sqlalchemy.orm import Session
from app.api.deps import get_current_admin_api, require_module_access
@@ -25,7 +25,7 @@ from app.modules.loyalty.schemas import (
ProgramStatsResponse,
)
from app.modules.loyalty.services import program_service
from app.modules.tenancy.models import User
from app.modules.tenancy.models import User # API-007
logger = logging.getLogger(__name__)
@@ -51,11 +51,6 @@ def list_programs(
db: Session = Depends(get_db),
):
"""List all loyalty programs (platform admin)."""
from sqlalchemy import func
from app.modules.loyalty.models import LoyaltyCard, LoyaltyTransaction
from app.modules.tenancy.models import Merchant
programs, total = program_service.list_programs(
db,
skip=skip,
@@ -71,45 +66,13 @@ def list_programs(
response.is_points_enabled = program.is_points_enabled
response.display_name = program.display_name
# Get merchant name
merchant = db.query(Merchant).filter(Merchant.id == program.merchant_id).first()
if merchant:
response.merchant_name = merchant.name
# Get basic stats for this program
response.total_cards = (
db.query(func.count(LoyaltyCard.id))
.filter(LoyaltyCard.merchant_id == program.merchant_id)
.scalar()
or 0
)
response.active_cards = (
db.query(func.count(LoyaltyCard.id))
.filter(
LoyaltyCard.merchant_id == program.merchant_id,
LoyaltyCard.is_active == True,
)
.scalar()
or 0
)
response.total_points_issued = (
db.query(func.sum(LoyaltyTransaction.points_delta))
.filter(
LoyaltyTransaction.merchant_id == program.merchant_id,
LoyaltyTransaction.points_delta > 0,
)
.scalar()
or 0
)
response.total_points_redeemed = (
db.query(func.sum(func.abs(LoyaltyTransaction.points_delta)))
.filter(
LoyaltyTransaction.merchant_id == program.merchant_id,
LoyaltyTransaction.points_delta < 0,
)
.scalar()
or 0
)
# Get aggregation stats from service
list_stats = program_service.get_program_list_stats(db, program)
response.merchant_name = list_stats["merchant_name"]
response.total_cards = list_stats["total_cards"]
response.active_cards = list_stats["active_cards"]
response.total_points_issued = list_stats["total_points_issued"]
response.total_points_redeemed = list_stats["total_points_redeemed"]
program_responses.append(response)
@@ -157,8 +120,6 @@ def get_merchant_stats(
):
"""Get merchant-wide loyalty statistics across all locations."""
stats = program_service.get_merchant_stats(db, merchant_id)
if "error" in stats:
raise HTTPException(status_code=404, detail=stats["error"])
return MerchantStatsResponse(**stats)
@@ -208,76 +169,4 @@ def get_platform_stats(
db: Session = Depends(get_db),
):
"""Get platform-wide loyalty statistics."""
from sqlalchemy import func
from app.modules.loyalty.models import (
LoyaltyCard,
LoyaltyProgram,
LoyaltyTransaction,
)
# Program counts
total_programs = db.query(func.count(LoyaltyProgram.id)).scalar() or 0
active_programs = (
db.query(func.count(LoyaltyProgram.id))
.filter(LoyaltyProgram.is_active == True)
.scalar()
or 0
)
# Card counts
total_cards = db.query(func.count(LoyaltyCard.id)).scalar() or 0
active_cards = (
db.query(func.count(LoyaltyCard.id))
.filter(LoyaltyCard.is_active == True)
.scalar()
or 0
)
# Transaction counts (last 30 days)
from datetime import UTC, datetime, timedelta
thirty_days_ago = datetime.now(UTC) - timedelta(days=30)
transactions_30d = (
db.query(func.count(LoyaltyTransaction.id))
.filter(LoyaltyTransaction.transaction_at >= thirty_days_ago)
.scalar()
or 0
)
# Points issued/redeemed (last 30 days)
points_issued_30d = (
db.query(func.sum(LoyaltyTransaction.points_delta))
.filter(
LoyaltyTransaction.transaction_at >= thirty_days_ago,
LoyaltyTransaction.points_delta > 0,
)
.scalar()
or 0
)
points_redeemed_30d = (
db.query(func.sum(func.abs(LoyaltyTransaction.points_delta)))
.filter(
LoyaltyTransaction.transaction_at >= thirty_days_ago,
LoyaltyTransaction.points_delta < 0,
)
.scalar()
or 0
)
# Merchant count with programs
merchants_with_programs = (
db.query(func.count(func.distinct(LoyaltyProgram.merchant_id))).scalar() or 0
)
return {
"total_programs": total_programs,
"active_programs": active_programs,
"merchants_with_programs": merchants_with_programs,
"total_cards": total_cards,
"active_cards": active_cards,
"transactions_30d": transactions_30d,
"points_issued_30d": points_issued_30d,
"points_redeemed_30d": points_redeemed_30d,
}
return program_service.get_platform_stats(db)

155
app/modules/loyalty/routes/api/platform.py
View File

@@ -9,18 +9,14 @@ Platform endpoints for:
"""
import logging
from datetime import datetime
from fastapi import APIRouter, Depends, Header, HTTPException, Path, Response
from fastapi import APIRouter, Depends, Header, Path, Response
from sqlalchemy.orm import Session
from app.core.database import get_db
from app.modules.loyalty.exceptions import (
LoyaltyException,
)
from app.modules.loyalty.models import LoyaltyCard
from app.modules.loyalty.services import (
apple_wallet_service,
card_service,
program_service,
)
@@ -41,23 +37,11 @@ def get_program_by_store_code(
db: Session = Depends(get_db),
):
"""Get loyalty program info by store code (for enrollment page)."""
from app.modules.tenancy.models import Store
# Find store by code (store_code or subdomain)
store = (
db.query(Store)
.filter(
(Store.store_code == store_code) | (Store.subdomain == store_code)
)
.first()
)
if not store:
raise HTTPException(status_code=404, detail="Store not found")
store = program_service.get_store_by_code(db, store_code)
# Get program
program = program_service.get_active_program_by_store(db, store.id)
if not program:
raise HTTPException(status_code=404, detail="No active loyalty program")
# Get program (raises LoyaltyProgramNotFoundException if not found)
program = program_service.require_active_program_by_store(db, store.id)
return {
"store_name": store.name,
@@ -88,21 +72,10 @@ def download_apple_pass(
db: Session = Depends(get_db),
):
"""Download Apple Wallet pass for a card."""
# Find card by serial number
card = (
db.query(LoyaltyCard)
.filter(LoyaltyCard.apple_serial_number == serial_number)
.first()
)
# Find card by serial number (raises LoyaltyCardNotFoundException if not found)
card = card_service.require_card_by_serial_number(db, serial_number)
if not card:
raise HTTPException(status_code=404, detail="Pass not found")
try:
pass_data = apple_wallet_service.generate_pass(db, card)
except LoyaltyException as e:
logger.error(f"Failed to generate Apple pass for card {card.id}: {e}")
raise HTTPException(status_code=500, detail="Failed to generate pass")
pass_data = apple_wallet_service.generate_pass_safe(db, card)
return Response(
content=pass_data,
@@ -132,34 +105,17 @@ def register_device(
Called by Apple when user adds pass to wallet.
"""
# Validate authorization token
auth_token = None
if authorization and authorization.startswith("ApplePass "):
auth_token = authorization.split(" ", 1)[1]
# Find card (raises LoyaltyCardNotFoundException if not found)
card = card_service.require_card_by_serial_number(db, serial_number)
# Find card
card = (
db.query(LoyaltyCard)
.filter(LoyaltyCard.apple_serial_number == serial_number)
.first()
)
if not card:
raise HTTPException(status_code=404)
# Verify auth token
if not auth_token or auth_token != card.apple_auth_token:
raise HTTPException(status_code=401)
# Verify auth token (raises InvalidAppleAuthTokenException if invalid)
apple_wallet_service.verify_auth_token(card, authorization)
# Get push token from request body
# Note: In real implementation, parse the JSON body for pushToken
# For now, use device_id as a placeholder
try:
apple_wallet_service.register_device(db, card, device_id, device_id)
return Response(status_code=201)
except Exception as e:
logger.error(f"Failed to register device: {e}")
raise HTTPException(status_code=500)
apple_wallet_service.register_device_safe(db, card, device_id, device_id)
return Response(status_code=201)
@platform_router.delete("/apple/v1/devices/{device_id}/registrations/{pass_type_id}/{serial_number}")
@@ -175,31 +131,14 @@ def unregister_device(
Called by Apple when user removes pass from wallet.
"""
# Validate authorization token
auth_token = None
if authorization and authorization.startswith("ApplePass "):
auth_token = authorization.split(" ", 1)[1]
# Find card (raises LoyaltyCardNotFoundException if not found)
card = card_service.require_card_by_serial_number(db, serial_number)
# Find card
card = (
db.query(LoyaltyCard)
.filter(LoyaltyCard.apple_serial_number == serial_number)
.first()
)
# Verify auth token (raises InvalidAppleAuthTokenException if invalid)
apple_wallet_service.verify_auth_token(card, authorization)
if not card:
raise HTTPException(status_code=404)
# Verify auth token
if not auth_token or auth_token != card.apple_auth_token:
raise HTTPException(status_code=401)
try:
apple_wallet_service.unregister_device(db, card, device_id)
return Response(status_code=200)
except Exception as e:
logger.error(f"Failed to unregister device: {e}")
raise HTTPException(status_code=500)
apple_wallet_service.unregister_device_safe(db, card, device_id)
return Response(status_code=200)
@platform_router.get("/apple/v1/devices/{device_id}/registrations/{pass_type_id}")
@@ -214,32 +153,11 @@ def get_serial_numbers(
Called by Apple to check for updated passes.
"""
from app.modules.loyalty.models import AppleDeviceRegistration
# Find all cards registered to this device
registrations = (
db.query(AppleDeviceRegistration)
.filter(AppleDeviceRegistration.device_library_identifier == device_id)
.all()
# Get cards registered to this device, optionally filtered by update time
cards = apple_wallet_service.get_updated_cards_for_device(
db, device_id, updated_since=passesUpdatedSince
)
if not registrations:
return Response(status_code=204)
# Get cards that have been updated since the given timestamp
card_ids = [r.card_id for r in registrations]
query = db.query(LoyaltyCard).filter(LoyaltyCard.id.in_(card_ids))
if passesUpdatedSince:
try:
since = datetime.fromisoformat(passesUpdatedSince.replace("Z", "+00:00"))
query = query.filter(LoyaltyCard.updated_at > since)
except ValueError:
pass
cards = query.all()
if not cards:
return Response(status_code=204)
@@ -265,30 +183,13 @@ def get_latest_pass(
Called by Apple to fetch updated pass data.
"""
# Validate authorization token
auth_token = None
if authorization and authorization.startswith("ApplePass "):
auth_token = authorization.split(" ", 1)[1]
# Find card (raises LoyaltyCardNotFoundException if not found)
card = card_service.require_card_by_serial_number(db, serial_number)
# Find card
card = (
db.query(LoyaltyCard)
.filter(LoyaltyCard.apple_serial_number == serial_number)
.first()
)
# Verify auth token (raises InvalidAppleAuthTokenException if invalid)
apple_wallet_service.verify_auth_token(card, authorization)
if not card:
raise HTTPException(status_code=404)
# Verify auth token
if not auth_token or auth_token != card.apple_auth_token:
raise HTTPException(status_code=401)
try:
pass_data = apple_wallet_service.generate_pass(db, card)
except LoyaltyException as e:
logger.error(f"Failed to generate Apple pass for card {card.id}: {e}")
raise HTTPException(status_code=500, detail="Failed to generate pass")
pass_data = apple_wallet_service.generate_pass_safe(db, card)
return Response(
content=pass_data,

274
app/modules/loyalty/routes/api/store.py
View File

@@ -15,16 +15,12 @@ Cards can be used at any store within the same merchant.
import logging
from fastapi import APIRouter, Depends, HTTPException, Path, Query, Request
from fastapi import APIRouter, Depends, Path, Query, Request
from sqlalchemy.orm import Session
from app.api.deps import get_current_store_api, require_module_access
from app.core.database import get_db
from app.modules.enums import FrontendType
from app.modules.loyalty.exceptions import (
LoyaltyCardNotFoundException,
LoyaltyException,
)
from app.modules.loyalty.schemas import (
CardEnrollRequest,
CardListResponse,
@@ -63,7 +59,7 @@ from app.modules.loyalty.services import (
program_service,
stamp_service,
)
from app.modules.tenancy.models import Store, User
from app.modules.tenancy.models import User # API-007
logger = logging.getLogger(__name__)
@@ -83,10 +79,7 @@ def get_client_info(request: Request) -> tuple[str | None, str | None]:
def get_store_merchant_id(db: Session, store_id: int) -> int:
"""Get the merchant ID for a store."""
store = db.query(Store).filter(Store.id == store_id).first()
if not store:
raise HTTPException(status_code=404, detail="Store not found")
return store.merchant_id
return program_service.get_store_merchant_id(db, store_id)
# =============================================================================
@@ -102,9 +95,7 @@ def get_program(
"""Get the merchant's loyalty program."""
store_id = current_user.token_store_id
program = program_service.get_program_by_store(db, store_id)
if not program:
raise HTTPException(status_code=404, detail="No loyalty program configured")
program = program_service.require_program_by_store(db, store_id)
response = ProgramResponse.model_validate(program)
response.is_stamps_enabled = program.is_stamps_enabled
@@ -124,10 +115,7 @@ def create_program(
store_id = current_user.token_store_id
merchant_id = get_store_merchant_id(db, store_id)
try:
program = program_service.create_program(db, merchant_id, data)
except LoyaltyException as e:
raise HTTPException(status_code=e.status_code, detail=e.message)
program = program_service.create_program(db, merchant_id, data)
response = ProgramResponse.model_validate(program)
response.is_stamps_enabled = program.is_stamps_enabled
@@ -146,10 +134,7 @@ def update_program(
"""Update the merchant's loyalty program."""
store_id = current_user.token_store_id
program = program_service.get_program_by_store(db, store_id)
if not program:
raise HTTPException(status_code=404, detail="No loyalty program configured")
program = program_service.require_program_by_store(db, store_id)
program = program_service.update_program(db, program.id, data)
response = ProgramResponse.model_validate(program)
@@ -168,9 +153,7 @@ def get_stats(
"""Get loyalty program statistics."""
store_id = current_user.token_store_id
program = program_service.get_program_by_store(db, store_id)
if not program:
raise HTTPException(status_code=404, detail="No loyalty program configured")
program = program_service.require_program_by_store(db, store_id)
stats = program_service.get_program_stats(db, program.id)
return ProgramStatsResponse(**stats)
@@ -186,8 +169,6 @@ def get_merchant_stats(
merchant_id = get_store_merchant_id(db, store_id)
stats = program_service.get_merchant_stats(db, merchant_id)
if "error" in stats:
raise HTTPException(status_code=404, detail=stats["error"])
return MerchantStatsResponse(**stats)
@@ -205,9 +186,7 @@ def list_pins(
"""List staff PINs for this store location."""
store_id = current_user.token_store_id
program = program_service.get_program_by_store(db, store_id)
if not program:
raise HTTPException(status_code=404, detail="No loyalty program configured")
program = program_service.require_program_by_store(db, store_id)
# List PINs for this store only
pins = pin_service.list_pins(db, program.id, store_id=store_id)
@@ -227,9 +206,7 @@ def create_pin(
"""Create a new staff PIN for this store location."""
store_id = current_user.token_store_id
program = program_service.get_program_by_store(db, store_id)
if not program:
raise HTTPException(status_code=404, detail="No loyalty program configured")
program = program_service.require_program_by_store(db, store_id)
pin = pin_service.create_pin(db, program.id, store_id, data)
return PinResponse.model_validate(pin)
@@ -292,9 +269,7 @@ def list_cards(
store_id = current_user.token_store_id
merchant_id = get_store_merchant_id(db, store_id)
program = program_service.get_program_by_store(db, store_id)
if not program:
raise HTTPException(status_code=404, detail="No loyalty program configured")
program = program_service.require_program_by_store(db, store_id)
# Filter by enrolled_at_store_id if requested
filter_store_id = store_id if enrolled_here else None
@@ -352,17 +327,15 @@ def lookup_card(
"""
store_id = current_user.token_store_id
try:
# Uses lookup_card_for_store which validates merchant membership
card = card_service.lookup_card_for_store(
db,
store_id,
card_id=card_id,
qr_code=qr_code,
card_number=card_number,
)
except LoyaltyCardNotFoundException:
raise HTTPException(status_code=404, detail="Card not found")
# Uses lookup_card_for_store which validates merchant membership
# Raises LoyaltyCardNotFoundException if not found
card = card_service.lookup_card_for_store(
db,
store_id,
card_id=card_id,
qr_code=qr_code,
card_number=card_number,
)
program = card.program
@@ -420,13 +393,14 @@ def enroll_customer(
"""
store_id = current_user.token_store_id
if not data.customer_id:
raise HTTPException(status_code=400, detail="customer_id is required")
customer_id = card_service.resolve_customer_id(
db,
customer_id=data.customer_id,
email=data.email,
store_id=store_id,
)
try:
card = card_service.enroll_customer_for_store(db, data.customer_id, store_id)
except LoyaltyException as e:
raise HTTPException(status_code=e.status_code, detail=e.message)
card = card_service.enroll_customer_for_store(db, customer_id, store_id)
program = card.program
@@ -461,11 +435,8 @@ def get_card_transactions(
"""Get transaction history for a card."""
store_id = current_user.token_store_id
# Verify card belongs to this merchant
try:
card_service.lookup_card_for_store(db, store_id, card_id=card_id)
except LoyaltyCardNotFoundException:
raise HTTPException(status_code=404, detail="Card not found")
# Verify card belongs to this merchant (raises LoyaltyCardNotFoundException if not found)
card_service.lookup_card_for_store(db, store_id, card_id=card_id)
transactions, total = card_service.get_card_transactions(
db, card_id, skip=skip, limit=limit
@@ -493,20 +464,17 @@ def add_stamp(
store_id = current_user.token_store_id
ip, user_agent = get_client_info(request)
try:
result = stamp_service.add_stamp(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
except LoyaltyException as e:
raise HTTPException(status_code=e.status_code, detail=e.message)
result = stamp_service.add_stamp(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
return StampResponse(**result)
@@ -522,20 +490,17 @@ def redeem_stamps(
store_id = current_user.token_store_id
ip, user_agent = get_client_info(request)
try:
result = stamp_service.redeem_stamps(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
except LoyaltyException as e:
raise HTTPException(status_code=e.status_code, detail=e.message)
result = stamp_service.redeem_stamps(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
return StampRedeemResponse(**result)
@@ -551,22 +516,19 @@ def void_stamps(
store_id = current_user.token_store_id
ip, user_agent = get_client_info(request)
try:
result = stamp_service.void_stamps(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
stamps_to_void=data.stamps_to_void,
original_transaction_id=data.original_transaction_id,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
except LoyaltyException as e:
raise HTTPException(status_code=e.status_code, detail=e.message)
result = stamp_service.void_stamps(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
stamps_to_void=data.stamps_to_void,
original_transaction_id=data.original_transaction_id,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
return StampVoidResponse(**result)
@@ -587,22 +549,19 @@ def earn_points(
store_id = current_user.token_store_id
ip, user_agent = get_client_info(request)
try:
result = points_service.earn_points(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
purchase_amount_cents=data.purchase_amount_cents,
order_reference=data.order_reference,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
except LoyaltyException as e:
raise HTTPException(status_code=e.status_code, detail=e.message)
result = points_service.earn_points(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
purchase_amount_cents=data.purchase_amount_cents,
order_reference=data.order_reference,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
return PointsEarnResponse(**result)
@@ -618,21 +577,18 @@ def redeem_points(
store_id = current_user.token_store_id
ip, user_agent = get_client_info(request)
try:
result = points_service.redeem_points(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
reward_id=data.reward_id,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
except LoyaltyException as e:
raise HTTPException(status_code=e.status_code, detail=e.message)
result = points_service.redeem_points(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
reward_id=data.reward_id,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
return PointsRedeemResponse(**result)
@@ -648,23 +604,20 @@ def void_points(
store_id = current_user.token_store_id
ip, user_agent = get_client_info(request)
try:
result = points_service.void_points(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
points_to_void=data.points_to_void,
original_transaction_id=data.original_transaction_id,
order_reference=data.order_reference,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
except LoyaltyException as e:
raise HTTPException(status_code=e.status_code, detail=e.message)
result = points_service.void_points(
db,
store_id=store_id,
card_id=data.card_id,
qr_code=data.qr_code,
card_number=data.card_number,
points_to_void=data.points_to_void,
original_transaction_id=data.original_transaction_id,
order_reference=data.order_reference,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
notes=data.notes,
)
return PointsVoidResponse(**result)
@@ -681,18 +634,15 @@ def adjust_points(
store_id = current_user.token_store_id
ip, user_agent = get_client_info(request)
try:
result = points_service.adjust_points(
db,
card_id=card_id,
points_delta=data.points_delta,
store_id=store_id,
reason=data.reason,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
)
except LoyaltyException as e:
raise HTTPException(status_code=e.status_code, detail=e.message)
result = points_service.adjust_points(
db,
card_id=card_id,
points_delta=data.points_delta,
store_id=store_id,
reason=data.reason,
staff_pin=data.staff_pin,
ip_address=ip,
user_agent=user_agent,
)
return PointsAdjustResponse(**result)

70
app/modules/loyalty/routes/api/storefront.py
View File

@@ -13,7 +13,7 @@ Uses store from middleware context (StoreContextMiddleware).
import logging
from fastapi import APIRouter, Depends, HTTPException, Query, Request
from fastapi import APIRouter, Depends, Query, Request
from sqlalchemy.orm import Session
from app.api.deps import get_current_customer_api
@@ -76,26 +76,15 @@ def self_enroll(
raise StoreNotFoundException("context", identifier_type="subdomain")
# Check if self-enrollment is allowed
settings = program_service.get_merchant_settings(db, store.merchant_id)
if settings and not settings.allow_self_enrollment:
raise HTTPException(403, "Self-enrollment is not available")
program_service.check_self_enrollment_allowed(db, store.merchant_id)
# Resolve customer_id
customer_id = data.customer_id
if not customer_id and data.email:
from app.modules.customers.models.customer import Customer
customer = (
db.query(Customer)
.filter(Customer.email == data.email, Customer.store_id == store.id)
.first()
)
if not customer:
raise HTTPException(400, "Customer not found with provided email")
customer_id = customer.id
if not customer_id:
raise HTTPException(400, "Either customer_id or email is required")
customer_id = card_service.resolve_customer_id(
db,
customer_id=data.customer_id,
email=data.email,
store_id=store.id,
)
logger.info(f"Self-enrollment for customer {customer_id} at store {store.subdomain}")
@@ -141,12 +130,7 @@ def get_my_card(
return {"card": None, "program": None, "locations": []}
# Get merchant locations
from app.modules.tenancy.models import Store as StoreModel
locations = (
db.query(StoreModel)
.filter(StoreModel.merchant_id == program.merchant_id, StoreModel.is_active == True)
.all()
)
locations = program_service.get_merchant_locations(db, program.merchant_id)
program_response = ProgramResponse.model_validate(program)
program_response.is_stamps_enabled = program.is_stamps_enabled
@@ -192,39 +176,9 @@ def get_my_transactions(
if not card:
return {"transactions": [], "total": 0}
# Get transactions
from app.modules.loyalty.models import LoyaltyTransaction
from app.modules.tenancy.models import Store as StoreModel
query = (
db.query(LoyaltyTransaction)
.filter(LoyaltyTransaction.card_id == card.id)
.order_by(LoyaltyTransaction.transaction_at.desc())
# Get transactions with store names
tx_responses, total = card_service.get_customer_transactions_with_store_names(
db, card.id, skip=skip, limit=limit
)
total = query.count()
transactions = query.offset(skip).limit(limit).all()
# Build response with store names
tx_responses = []
for tx in transactions:
tx_data = {
"id": tx.id,
"transaction_type": tx.transaction_type.value if hasattr(tx.transaction_type, "value") else str(tx.transaction_type),
"points_delta": tx.points_delta,
"stamps_delta": tx.stamps_delta,
"points_balance_after": tx.points_balance_after,
"stamps_balance_after": tx.stamps_balance_after,
"transaction_at": tx.transaction_at.isoformat() if tx.transaction_at else None,
"notes": tx.notes,
"store_name": None,
}
if tx.store_id:
store_obj = db.query(StoreModel).filter(StoreModel.id == tx.store_id).first()
if store_obj:
tx_data["store_name"] = store_obj.name
tx_responses.append(tx_data)
return {"transactions": tx_responses, "total": total}