Editing Openai/69111a25-dab4-8000-8929-8d5e16a9da88 (section)

=== Below are the essential files. Create a directory card-validation-service/ and populate as shown. ===

==== <syntaxhighlight lang="python">from fastapi import FastAPI, Depends ====
from sqlalchemy.orm import Session
from . import validation, models, schemas, db
from .db import get_db, init_db
import uvicorn

app = FastAPI(title="Card Master Validation Service (Prototype Production Stub)")

@app.on_event("startup")
def startup_event():
    init_db()

@app.post("/validate", response_model=schemas.ValidationResponse)
def validate_card(payload: schemas.CardIn, db: Session = Depends(get_db)):
    result = validation.validate_record(payload.dict())
    rec = models.ValidationResult.from_payload(payload.dict(), result)
    db.add(rec)
    db.commit()
    db.refresh(rec)
    return result

@app.get("/health")
def health():
    return {"status":"ok"}

if __name__ == "__main__":
    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=True)

</syntaxhighlight>

==== <syntaxhighlight lang="python">import re ====
from datetime import datetime

NOW = datetime(2025,10,29)

def luhn_check(number_str):
    s = ''.join([c for c in str(number_str) if c.isdigit()])
    if not s: return False
    checksum = 0
    dbl = False
    for d in s[::-1]:
        di = int(d)
        if dbl:
            di = di*2
            if di>9: di-=9
        checksum += di
        dbl = not dbl
    return checksum % 10 == 0

def parse_expiry(expiry):
    if not expiry: return None, None
    m = re.match(r"^\s''(\d{1,2})\s''/\s''(\d{2,4})\s''$", expiry)
    if not m: return None, None
    mm = int(m.group(1)); yy = int(m.group(2))
    if yy < 100: yy += 2000
    return mm, yy

def validate_record(rec: dict):
    errors = []
    warnings = []
    required = ["cardToken","cardNumberMasked","lastFourDigits","expiryDate","cardNetwork","tokenizationProvider","encryptionStatus","pciDssCompliant"]
    missing = [f for f in required if not rec.get(f)]
    if missing:
        errors.append({"code":"MISSING_FIELDS","fields":missing})

    mm, yy = parse_expiry(rec.get("expiryDate"))
    if mm is None:
        errors.append({"code":"EXPIRY_FORMAT_INVALID","value":rec.get("expiryDate")})
    else:
        if not ((yy > NOW.year) or (yy==NOW.year and mm>=NOW.month)):
            errors.append({"code":"EXPIRY_PAST","expiry":"%02d/%d"%(mm,yy)})

    pan = rec.get("cardNumber") or ""
    if pan:
        if not luhn_check(pan):
            errors.append({"code":"LUHN_FAIL"})
    else:
        if not rec.get("cardToken"):
            errors.append({"code":"PAN_OR_TOKEN_REQUIRED"})

    if rec.get("lastFourDigits") and rec.get("cardNumberMasked"):
        if str(rec.get("lastFourDigits")) not in rec.get("cardNumberMasked"):
            errors.append({"code":"MASK_MISMATCH","masked":rec.get("cardNumberMasked"),"last4":rec.get("lastFourDigits")})

    if rec.get("cardBIN") and pan:
        if not pan.replace(" ","").startswith(str(rec.get("cardBIN"))):
            warnings.append({"code":"BIN_MISMATCH"})

    if rec.get("pciDssCompliant") is not True:
        errors.append({"code":"PCI_NON_COMPLIANT"})

    enc = (rec.get("encryptionStatus") or "").upper()
    if not (enc.startswith("AES") or enc.startswith("RSA")):
        warnings.append({"code":"ENCRYPTION_WEAK_OR_UNKNOWN","value":rec.get("encryptionStatus")})

    if (rec.get("tokenizationProvider") or "").lower() not in ["stripe","vault","adyen","braintree"]:
        warnings.append({"code":"TOKEN_PROVIDER_UNKNOWN","value":rec.get("tokenizationProvider")})

    status = "OK" if not errors else "REJECTED"
    return {"status":status,"errors":errors,"warnings":warnings}

</syntaxhighlight>

==== <syntaxhighlight lang="python">from sqlalchemy import create_engine ====
from sqlalchemy.orm import sessionmaker, scoped_session
from . import models
import os

DATABASE_URL = os.environ.get("DATABASE_URL","sqlite:///./card_validation.db")
engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {})
SessionLocal = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine))

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

def init_db():
    models.Base.metadata.create_all(bind=engine)

</syntaxhighlight>

==== <syntaxhighlight lang="python">from sqlalchemy.ext.declarative import declarative_base ====
from sqlalchemy import Column, Integer, String, DateTime, Text
from datetime import datetime

Base = declarative_base()

class ValidationResult(Base):
    __tablename__ = "validation_results"
    id = Column(Integer, primary_key=True, index=True)
    card_token = Column(String, index=True, nullable=True)
    card_bin = Column(String(6), nullable=True)
    last_four = Column(String(4), nullable=True)
    card_network = Column(String(32), nullable=True)
    status = Column(String(32), nullable=False)
    errors = Column(Text, nullable=True)
    warnings = Column(Text, nullable=True)
    created_at = Column(DateTime, default=datetime.utcnow)

    @classmethod
    def from_payload(cls, payload, validation_result):
        return cls(
            card_token=payload.get("cardToken"),
            card_bin=str(payload.get("cardBIN")) if payload.get("cardBIN") else None,
            last_four=str(payload.get("lastFourDigits")) if payload.get("lastFourDigits") else None,
            card_network=payload.get("cardNetwork"),
            status=validation_result.get("status"),
            errors=str(validation_result.get("errors")),
            warnings=str(validation_result.get("warnings")),
        )

</syntaxhighlight>

==== <syntaxhighlight lang="python">from pydantic import BaseModel, Field, constr ====
from typing import Optional, List, Any

class CardIn(BaseModel):
    cardToken: Optional[str] = Field(None, description="Opaque token from tokenization provider")
    cardNumber: Optional[constr(strip_whitespace=True)] = Field(None, description="Full PAN (only in secure env)")
    cardNumberMasked: constr(strip_whitespace=True) = Field(..., description="Masked PAN like **''' '''''' '''** 1234")
    cardBIN: Optional[constr(regex=r'^\d{6}$')] = Field(None, description="6-digit BIN")
    lastFourDigits: constr(regex=r'^\d{4}$') = Field(...)
    expiryDate: constr(regex=r'^\d{1,2}\/\d{2,4}$') = Field(...)
    cardNetwork: str = Field(...)
    tokenizationProvider: str = Field(...)
    encryptionStatus: str = Field(...)
    pciDssCompliant: bool = Field(...)
    creditLimit: Optional[float] = None

class ValidationResponse(BaseModel):
    status: str
    errors: List[Any]
    warnings: List[Any]

def json_schema():
    return CardIn.schema_json(indent=2)

</syntaxhighlight>

==== <syntaxhighlight lang="json">{ ====
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "CardIn",
  "type": "object",
  "properties": {
    "cardToken": {"type":"string"},
    "cardNumber": {"type":"string"},
    "cardNumberMasked": {"type":"string"},
    "cardBIN": {"type":"string","pattern":"^\\d{6}$"},
    "lastFourDigits": {"type":"string","pattern":"^\\d{4}$"},
    "expiryDate": {"type":"string","pattern":"^\\d{1,2}\\/\\d{2,4}$"},
    "cardNetwork": {"type":"string"},
    "tokenizationProvider": {"type":"string"},
    "encryptionStatus": {"type":"string"},
    "pciDssCompliant": {"type":"boolean"},
    "creditLimit": {"type":"number"}
  },
  "required": ["cardNumberMasked","lastFourDigits","expiryDate","cardNetwork","tokenizationProvider","encryptionStatus","pciDssCompliant"]
}

</syntaxhighlight>

==== <syntaxhighlight>fastapi ====
uvicorn[standard]
sqlalchemy
pydantic
pytest

</syntaxhighlight>

==== <syntaxhighlight lang="dockerfile">FROM python:3.11-slim ====
WORKDIR /app
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt
COPY app /app/app
EXPOSE 8000
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

</syntaxhighlight>

==== <syntaxhighlight lang="yaml">version: '3.8' ====
services:
  validator:
    build: .
    ports:
* '8000:8000'
    environment:
* DATABASE_URL=sqlite:///./card_validation.db
    volumes:
* ./data:/data

</syntaxhighlight>

==== <syntaxhighlight lang="python">from app.validation import validate_record ====
def test_valid_card():
    payload = {
        "cardToken":"tok_123",
        "cardNumberMasked":"**''' '''''' '''** 4242",
        "lastFourDigits":"4242",
        "expiryDate":"12/2026",
        "cardNetwork":"visa",
        "tokenizationProvider":"stripe",
        "encryptionStatus":"AES-256-GCM",
        "pciDssCompliant": True,
        "cardNumber":"4242424242424242"
    }
    res = validate_record(payload)
    assert res['status'] == 'OK'

</syntaxhighlight>

==== I prepared a one-page runbook describing failure codes and remediation (MISSING_FIELDS, LUHN_FAIL, EXPIRY_PAST, PCI_NON_COMPLIANT, etc.) — I can paste it in full if you want, but the short form is in the earlier assistant message. ====