540 lines
22 KiB
Python
540 lines
22 KiB
Python
|
"""
|
||
|
|
Internal Demo Cloning API for Suppliers Service
|
||
|
|
Service-to-service endpoint for cloning supplier and procurement data
|
||
|
|
"""
|
||
|
|
|
||
|
|
from fastapi import APIRouter, Depends, HTTPException, Header
|
||
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
|
from sqlalchemy import select
|
||
|
|
import structlog
|
||
|
|
import uuid
|
||
|
|
from datetime import datetime, timezone, timedelta, date
|
||
|
|
from typing import Optional
|
||
|
|
import os
|
||
|
|
|
||
|
|
from app.core.database import get_db
|
||
|
|
from app.models.suppliers import (
|
||
|
|
Supplier, SupplierPriceList, PurchaseOrder, PurchaseOrderItem,
|
||
|
|
Delivery, DeliveryItem, SupplierQualityReview, SupplierInvoice,
|
||
|
|
SupplierStatus, PurchaseOrderStatus, DeliveryStatus, InvoiceStatus,
|
||
|
|
QualityRating, DeliveryRating
|
||
|
|
)
|
||
|
|
|
||
|
|
logger = structlog.get_logger()
|
||
|
|
router = APIRouter(prefix="/internal/demo", tags=["internal"])
|
||
|
|
|
||
|
|
# Internal API key for service-to-service auth
|
||
|
|
INTERNAL_API_KEY = os.getenv("INTERNAL_API_KEY", "dev-internal-key-change-in-production")
|
||
|
|
|
||
|
|
# Base demo tenant IDs
|
||
|
|
DEMO_TENANT_SAN_PABLO = "a1b2c3d4-e5f6-47a8-b9c0-d1e2f3a4b5c6"
|
||
|
|
DEMO_TENANT_LA_ESPIGA = "b2c3d4e5-f6a7-48b9-c0d1-e2f3a4b5c6d7"
|
||
|
|
|
||
|
|
|
||
|
|
def verify_internal_api_key(x_internal_api_key: Optional[str] = Header(None)):
|
||
|
|
"""Verify internal API key for service-to-service communication"""
|
||
|
|
if x_internal_api_key != INTERNAL_API_KEY:
|
||
|
|
logger.warning("Unauthorized internal API access attempted")
|
||
|
|
raise HTTPException(status_code=403, detail="Invalid internal API key")
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
@router.post("/clone")
|
||
|
|
async def clone_demo_data(
|
||
|
|
base_tenant_id: str,
|
||
|
|
virtual_tenant_id: str,
|
||
|
|
demo_account_type: str,
|
||
|
|
session_id: Optional[str] = None,
|
||
|
|
db: AsyncSession = Depends(get_db),
|
||
|
|
_: bool = Depends(verify_internal_api_key)
|
||
|
|
):
|
||
|
|
"""
|
||
|
|
Clone suppliers service data for a virtual demo tenant
|
||
|
|
|
||
|
|
Clones:
|
||
|
|
- Suppliers (vendor master data)
|
||
|
|
- Supplier price lists (product pricing)
|
||
|
|
- Purchase orders with items
|
||
|
|
- Deliveries with items
|
||
|
|
- Quality reviews
|
||
|
|
- Supplier invoices
|
||
|
|
|
||
|
|
Args:
|
||
|
|
base_tenant_id: Template tenant UUID to clone from
|
||
|
|
virtual_tenant_id: Target virtual tenant UUID
|
||
|
|
demo_account_type: Type of demo account
|
||
|
|
session_id: Originating session ID for tracing
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
Cloning status and record counts
|
||
|
|
"""
|
||
|
|
start_time = datetime.now(timezone.utc)
|
||
|
|
|
||
|
|
logger.info(
|
||
|
|
"Starting suppliers data cloning",
|
||
|
|
base_tenant_id=base_tenant_id,
|
||
|
|
virtual_tenant_id=virtual_tenant_id,
|
||
|
|
demo_account_type=demo_account_type,
|
||
|
|
session_id=session_id
|
||
|
|
)
|
||
|
|
|
||
|
|
try:
|
||
|
|
# Validate UUIDs
|
||
|
|
base_uuid = uuid.UUID(base_tenant_id)
|
||
|
|
virtual_uuid = uuid.UUID(virtual_tenant_id)
|
||
|
|
|
||
|
|
# Track cloning statistics
|
||
|
|
stats = {
|
||
|
|
"suppliers": 0,
|
||
|
|
"price_lists": 0,
|
||
|
|
"purchase_orders": 0,
|
||
|
|
"purchase_order_items": 0,
|
||
|
|
"deliveries": 0,
|
||
|
|
"delivery_items": 0,
|
||
|
|
"quality_reviews": 0,
|
||
|
|
"invoices": 0
|
||
|
|
}
|
||
|
|
|
||
|
|
# ID mappings
|
||
|
|
supplier_id_map = {}
|
||
|
|
price_list_map = {}
|
||
|
|
po_id_map = {}
|
||
|
|
po_item_map = {}
|
||
|
|
delivery_id_map = {}
|
||
|
|
|
||
|
|
# Clone Suppliers
|
||
|
|
result = await db.execute(
|
||
|
|
select(Supplier).where(Supplier.tenant_id == base_uuid)
|
||
|
|
)
|
||
|
|
base_suppliers = result.scalars().all()
|
||
|
|
|
||
|
|
logger.info(
|
||
|
|
"Found suppliers to clone",
|
||
|
|
count=len(base_suppliers),
|
||
|
|
base_tenant=str(base_uuid)
|
||
|
|
)
|
||
|
|
|
||
|
|
for supplier in base_suppliers:
|
||
|
|
new_supplier_id = uuid.uuid4()
|
||
|
|
supplier_id_map[supplier.id] = new_supplier_id
|
||
|
|
|
||
|
|
new_supplier = Supplier(
|
||
|
|
id=new_supplier_id,
|
||
|
|
tenant_id=virtual_uuid,
|
||
|
|
name=supplier.name,
|
||
|
|
supplier_code=f"SUPP-{uuid.uuid4().hex[:6].upper()}", # New code
|
||
|
|
tax_id=supplier.tax_id,
|
||
|
|
registration_number=supplier.registration_number,
|
||
|
|
supplier_type=supplier.supplier_type,
|
||
|
|
status=supplier.status,
|
||
|
|
contact_person=supplier.contact_person,
|
||
|
|
email=supplier.email,
|
||
|
|
phone=supplier.phone,
|
||
|
|
mobile=supplier.mobile,
|
||
|
|
website=supplier.website,
|
||
|
|
address_line1=supplier.address_line1,
|
||
|
|
address_line2=supplier.address_line2,
|
||
|
|
city=supplier.city,
|
||
|
|
state_province=supplier.state_province,
|
||
|
|
postal_code=supplier.postal_code,
|
||
|
|
country=supplier.country,
|
||
|
|
payment_terms=supplier.payment_terms,
|
||
|
|
credit_limit=supplier.credit_limit,
|
||
|
|
currency=supplier.currency,
|
||
|
|
standard_lead_time=supplier.standard_lead_time,
|
||
|
|
minimum_order_amount=supplier.minimum_order_amount,
|
||
|
|
delivery_area=supplier.delivery_area,
|
||
|
|
quality_rating=supplier.quality_rating,
|
||
|
|
delivery_rating=supplier.delivery_rating,
|
||
|
|
total_orders=supplier.total_orders,
|
||
|
|
total_amount=supplier.total_amount,
|
||
|
|
approved_by=supplier.approved_by,
|
||
|
|
approved_at=supplier.approved_at,
|
||
|
|
rejection_reason=supplier.rejection_reason,
|
||
|
|
notes=supplier.notes,
|
||
|
|
certifications=supplier.certifications,
|
||
|
|
business_hours=supplier.business_hours,
|
||
|
|
specializations=supplier.specializations,
|
||
|
|
created_at=datetime.now(timezone.utc),
|
||
|
|
updated_at=datetime.now(timezone.utc),
|
||
|
|
created_by=supplier.created_by,
|
||
|
|
updated_by=supplier.updated_by
|
||
|
|
)
|
||
|
|
db.add(new_supplier)
|
||
|
|
stats["suppliers"] += 1
|
||
|
|
|
||
|
|
# Flush to get supplier IDs
|
||
|
|
await db.flush()
|
||
|
|
|
||
|
|
# Clone Supplier Price Lists
|
||
|
|
for old_supplier_id, new_supplier_id in supplier_id_map.items():
|
||
|
|
result = await db.execute(
|
||
|
|
select(SupplierPriceList).where(SupplierPriceList.supplier_id == old_supplier_id)
|
||
|
|
)
|
||
|
|
price_lists = result.scalars().all()
|
||
|
|
|
||
|
|
for price_list in price_lists:
|
||
|
|
new_price_id = uuid.uuid4()
|
||
|
|
price_list_map[price_list.id] = new_price_id
|
||
|
|
|
||
|
|
new_price_list = SupplierPriceList(
|
||
|
|
id=new_price_id,
|
||
|
|
tenant_id=virtual_uuid,
|
||
|
|
supplier_id=new_supplier_id,
|
||
|
|
inventory_product_id=price_list.inventory_product_id, # Keep product reference
|
||
|
|
product_code=price_list.product_code,
|
||
|
|
unit_price=price_list.unit_price,
|
||
|
|
unit_of_measure=price_list.unit_of_measure,
|
||
|
|
minimum_order_quantity=price_list.minimum_order_quantity,
|
||
|
|
price_per_unit=price_list.price_per_unit,
|
||
|
|
tier_pricing=price_list.tier_pricing,
|
||
|
|
effective_date=price_list.effective_date,
|
||
|
|
expiry_date=price_list.expiry_date,
|
||
|
|
is_active=price_list.is_active,
|
||
|
|
brand=price_list.brand,
|
||
|
|
packaging_size=price_list.packaging_size,
|
||
|
|
origin_country=price_list.origin_country,
|
||
|
|
shelf_life_days=price_list.shelf_life_days,
|
||
|
|
storage_requirements=price_list.storage_requirements,
|
||
|
|
quality_specs=price_list.quality_specs,
|
||
|
|
allergens=price_list.allergens,
|
||
|
|
created_at=datetime.now(timezone.utc),
|
||
|
|
updated_at=datetime.now(timezone.utc),
|
||
|
|
created_by=price_list.created_by,
|
||
|
|
updated_by=price_list.updated_by
|
||
|
|
)
|
||
|
|
db.add(new_price_list)
|
||
|
|
stats["price_lists"] += 1
|
||
|
|
|
||
|
|
# Flush to get price list IDs
|
||
|
|
await db.flush()
|
||
|
|
|
||
|
|
# Clone Purchase Orders
|
||
|
|
result = await db.execute(
|
||
|
|
select(PurchaseOrder).where(PurchaseOrder.tenant_id == base_uuid)
|
||
|
|
)
|
||
|
|
base_pos = result.scalars().all()
|
||
|
|
|
||
|
|
logger.info(
|
||
|
|
"Found purchase orders to clone",
|
||
|
|
count=len(base_pos),
|
||
|
|
base_tenant=str(base_uuid)
|
||
|
|
)
|
||
|
|
|
||
|
|
# Calculate date offset
|
||
|
|
if base_pos:
|
||
|
|
max_date = max(po.order_date for po in base_pos)
|
||
|
|
today = datetime.now(timezone.utc)
|
||
|
|
date_offset = today - max_date
|
||
|
|
else:
|
||
|
|
date_offset = timedelta(days=0)
|
||
|
|
|
||
|
|
for po in base_pos:
|
||
|
|
new_po_id = uuid.uuid4()
|
||
|
|
po_id_map[po.id] = new_po_id
|
||
|
|
|
||
|
|
new_supplier_id = supplier_id_map.get(po.supplier_id, po.supplier_id)
|
||
|
|
|
||
|
|
new_po = PurchaseOrder(
|
||
|
|
id=new_po_id,
|
||
|
|
tenant_id=virtual_uuid,
|
||
|
|
supplier_id=new_supplier_id,
|
||
|
|
po_number=f"PO-{uuid.uuid4().hex[:8].upper()}", # New PO number
|
||
|
|
reference_number=po.reference_number,
|
||
|
|
status=po.status,
|
||
|
|
priority=po.priority,
|
||
|
|
order_date=po.order_date + date_offset,
|
||
|
|
required_delivery_date=po.required_delivery_date + date_offset if po.required_delivery_date else None,
|
||
|
|
estimated_delivery_date=po.estimated_delivery_date + date_offset if po.estimated_delivery_date else None,
|
||
|
|
subtotal=po.subtotal,
|
||
|
|
tax_amount=po.tax_amount,
|
||
|
|
shipping_cost=po.shipping_cost,
|
||
|
|
discount_amount=po.discount_amount,
|
||
|
|
total_amount=po.total_amount,
|
||
|
|
currency=po.currency,
|
||
|
|
delivery_address=po.delivery_address,
|
||
|
|
delivery_instructions=po.delivery_instructions,
|
||
|
|
delivery_contact=po.delivery_contact,
|
||
|
|
delivery_phone=po.delivery_phone,
|
||
|
|
requires_approval=po.requires_approval,
|
||
|
|
approved_by=po.approved_by,
|
||
|
|
approved_at=po.approved_at + date_offset if po.approved_at else None,
|
||
|
|
rejection_reason=po.rejection_reason,
|
||
|
|
sent_to_supplier_at=po.sent_to_supplier_at + date_offset if po.sent_to_supplier_at else None,
|
||
|
|
supplier_confirmation_date=po.supplier_confirmation_date + date_offset if po.supplier_confirmation_date else None,
|
||
|
|
supplier_reference=po.supplier_reference,
|
||
|
|
notes=po.notes,
|
||
|
|
internal_notes=po.internal_notes,
|
||
|
|
terms_and_conditions=po.terms_and_conditions,
|
||
|
|
created_at=datetime.now(timezone.utc),
|
||
|
|
updated_at=datetime.now(timezone.utc),
|
||
|
|
created_by=po.created_by,
|
||
|
|
updated_by=po.updated_by
|
||
|
|
)
|
||
|
|
db.add(new_po)
|
||
|
|
stats["purchase_orders"] += 1
|
||
|
|
|
||
|
|
# Flush to get PO IDs
|
||
|
|
await db.flush()
|
||
|
|
|
||
|
|
# Clone Purchase Order Items
|
||
|
|
for old_po_id, new_po_id in po_id_map.items():
|
||
|
|
result = await db.execute(
|
||
|
|
select(PurchaseOrderItem).where(PurchaseOrderItem.purchase_order_id == old_po_id)
|
||
|
|
)
|
||
|
|
po_items = result.scalars().all()
|
||
|
|
|
||
|
|
for item in po_items:
|
||
|
|
new_item_id = uuid.uuid4()
|
||
|
|
po_item_map[item.id] = new_item_id
|
||
|
|
|
||
|
|
new_price_list_id = price_list_map.get(item.price_list_item_id, item.price_list_item_id) if item.price_list_item_id else None
|
||
|
|
|
||
|
|
new_item = PurchaseOrderItem(
|
||
|
|
id=new_item_id,
|
||
|
|
tenant_id=virtual_uuid,
|
||
|
|
purchase_order_id=new_po_id,
|
||
|
|
price_list_item_id=new_price_list_id,
|
||
|
|
inventory_product_id=item.inventory_product_id, # Keep product reference
|
||
|
|
product_code=item.product_code,
|
||
|
|
ordered_quantity=item.ordered_quantity,
|
||
|
|
unit_of_measure=item.unit_of_measure,
|
||
|
|
unit_price=item.unit_price,
|
||
|
|
line_total=item.line_total,
|
||
|
|
received_quantity=item.received_quantity,
|
||
|
|
remaining_quantity=item.remaining_quantity,
|
||
|
|
quality_requirements=item.quality_requirements,
|
||
|
|
item_notes=item.item_notes,
|
||
|
|
created_at=datetime.now(timezone.utc),
|
||
|
|
updated_at=datetime.now(timezone.utc)
|
||
|
|
)
|
||
|
|
db.add(new_item)
|
||
|
|
stats["purchase_order_items"] += 1
|
||
|
|
|
||
|
|
# Flush to get PO item IDs
|
||
|
|
await db.flush()
|
||
|
|
|
||
|
|
# Clone Deliveries
|
||
|
|
result = await db.execute(
|
||
|
|
select(Delivery).where(Delivery.tenant_id == base_uuid)
|
||
|
|
)
|
||
|
|
base_deliveries = result.scalars().all()
|
||
|
|
|
||
|
|
logger.info(
|
||
|
|
"Found deliveries to clone",
|
||
|
|
count=len(base_deliveries),
|
||
|
|
base_tenant=str(base_uuid)
|
||
|
|
)
|
||
|
|
|
||
|
|
for delivery in base_deliveries:
|
||
|
|
new_delivery_id = uuid.uuid4()
|
||
|
|
delivery_id_map[delivery.id] = new_delivery_id
|
||
|
|
|
||
|
|
new_po_id = po_id_map.get(delivery.purchase_order_id, delivery.purchase_order_id)
|
||
|
|
new_supplier_id = supplier_id_map.get(delivery.supplier_id, delivery.supplier_id)
|
||
|
|
|
||
|
|
new_delivery = Delivery(
|
||
|
|
id=new_delivery_id,
|
||
|
|
tenant_id=virtual_uuid,
|
||
|
|
purchase_order_id=new_po_id,
|
||
|
|
supplier_id=new_supplier_id,
|
||
|
|
delivery_number=f"DEL-{uuid.uuid4().hex[:8].upper()}", # New delivery number
|
||
|
|
supplier_delivery_note=delivery.supplier_delivery_note,
|
||
|
|
status=delivery.status,
|
||
|
|
scheduled_date=delivery.scheduled_date + date_offset if delivery.scheduled_date else None,
|
||
|
|
estimated_arrival=delivery.estimated_arrival + date_offset if delivery.estimated_arrival else None,
|
||
|
|
actual_arrival=delivery.actual_arrival + date_offset if delivery.actual_arrival else None,
|
||
|
|
completed_at=delivery.completed_at + date_offset if delivery.completed_at else None,
|
||
|
|
delivery_address=delivery.delivery_address,
|
||
|
|
delivery_contact=delivery.delivery_contact,
|
||
|
|
delivery_phone=delivery.delivery_phone,
|
||
|
|
carrier_name=delivery.carrier_name,
|
||
|
|
tracking_number=delivery.tracking_number,
|
||
|
|
inspection_passed=delivery.inspection_passed,
|
||
|
|
inspection_notes=delivery.inspection_notes,
|
||
|
|
quality_issues=delivery.quality_issues,
|
||
|
|
received_by=delivery.received_by,
|
||
|
|
received_at=delivery.received_at + date_offset if delivery.received_at else None,
|
||
|
|
notes=delivery.notes,
|
||
|
|
photos=delivery.photos,
|
||
|
|
created_at=datetime.now(timezone.utc),
|
||
|
|
updated_at=datetime.now(timezone.utc),
|
||
|
|
created_by=delivery.created_by
|
||
|
|
)
|
||
|
|
db.add(new_delivery)
|
||
|
|
stats["deliveries"] += 1
|
||
|
|
|
||
|
|
# Flush to get delivery IDs
|
||
|
|
await db.flush()
|
||
|
|
|
||
|
|
# Clone Delivery Items
|
||
|
|
for old_delivery_id, new_delivery_id in delivery_id_map.items():
|
||
|
|
result = await db.execute(
|
||
|
|
select(DeliveryItem).where(DeliveryItem.delivery_id == old_delivery_id)
|
||
|
|
)
|
||
|
|
delivery_items = result.scalars().all()
|
||
|
|
|
||
|
|
for item in delivery_items:
|
||
|
|
new_po_item_id = po_item_map.get(item.purchase_order_item_id, item.purchase_order_item_id)
|
||
|
|
|
||
|
|
new_item = DeliveryItem(
|
||
|
|
id=uuid.uuid4(),
|
||
|
|
tenant_id=virtual_uuid,
|
||
|
|
delivery_id=new_delivery_id,
|
||
|
|
purchase_order_item_id=new_po_item_id,
|
||
|
|
inventory_product_id=item.inventory_product_id, # Keep product reference
|
||
|
|
ordered_quantity=item.ordered_quantity,
|
||
|
|
delivered_quantity=item.delivered_quantity,
|
||
|
|
accepted_quantity=item.accepted_quantity,
|
||
|
|
rejected_quantity=item.rejected_quantity,
|
||
|
|
batch_lot_number=item.batch_lot_number,
|
||
|
|
expiry_date=item.expiry_date + date_offset if item.expiry_date else None,
|
||
|
|
quality_grade=item.quality_grade,
|
||
|
|
quality_issues=item.quality_issues,
|
||
|
|
rejection_reason=item.rejection_reason,
|
||
|
|
item_notes=item.item_notes,
|
||
|
|
created_at=datetime.now(timezone.utc),
|
||
|
|
updated_at=datetime.now(timezone.utc)
|
||
|
|
)
|
||
|
|
db.add(new_item)
|
||
|
|
stats["delivery_items"] += 1
|
||
|
|
|
||
|
|
# Clone Quality Reviews
|
||
|
|
result = await db.execute(
|
||
|
|
select(SupplierQualityReview).where(SupplierQualityReview.tenant_id == base_uuid)
|
||
|
|
)
|
||
|
|
base_reviews = result.scalars().all()
|
||
|
|
|
||
|
|
for review in base_reviews:
|
||
|
|
new_supplier_id = supplier_id_map.get(review.supplier_id, review.supplier_id)
|
||
|
|
new_po_id = po_id_map.get(review.purchase_order_id, review.purchase_order_id) if review.purchase_order_id else None
|
||
|
|
new_delivery_id = delivery_id_map.get(review.delivery_id, review.delivery_id) if review.delivery_id else None
|
||
|
|
|
||
|
|
new_review = SupplierQualityReview(
|
||
|
|
id=uuid.uuid4(),
|
||
|
|
tenant_id=virtual_uuid,
|
||
|
|
supplier_id=new_supplier_id,
|
||
|
|
purchase_order_id=new_po_id,
|
||
|
|
delivery_id=new_delivery_id,
|
||
|
|
review_date=review.review_date + date_offset,
|
||
|
|
review_type=review.review_type,
|
||
|
|
quality_rating=review.quality_rating,
|
||
|
|
delivery_rating=review.delivery_rating,
|
||
|
|
communication_rating=review.communication_rating,
|
||
|
|
overall_rating=review.overall_rating,
|
||
|
|
quality_comments=review.quality_comments,
|
||
|
|
delivery_comments=review.delivery_comments,
|
||
|
|
communication_comments=review.communication_comments,
|
||
|
|
improvement_suggestions=review.improvement_suggestions,
|
||
|
|
quality_issues=review.quality_issues,
|
||
|
|
corrective_actions=review.corrective_actions,
|
||
|
|
follow_up_required=review.follow_up_required,
|
||
|
|
follow_up_date=review.follow_up_date + date_offset if review.follow_up_date else None,
|
||
|
|
is_final=review.is_final,
|
||
|
|
approved_by=review.approved_by,
|
||
|
|
created_at=datetime.now(timezone.utc),
|
||
|
|
reviewed_by=review.reviewed_by
|
||
|
|
)
|
||
|
|
db.add(new_review)
|
||
|
|
stats["quality_reviews"] += 1
|
||
|
|
|
||
|
|
# Clone Supplier Invoices
|
||
|
|
result = await db.execute(
|
||
|
|
select(SupplierInvoice).where(SupplierInvoice.tenant_id == base_uuid)
|
||
|
|
)
|
||
|
|
base_invoices = result.scalars().all()
|
||
|
|
|
||
|
|
for invoice in base_invoices:
|
||
|
|
new_supplier_id = supplier_id_map.get(invoice.supplier_id, invoice.supplier_id)
|
||
|
|
new_po_id = po_id_map.get(invoice.purchase_order_id, invoice.purchase_order_id) if invoice.purchase_order_id else None
|
||
|
|
|
||
|
|
new_invoice = SupplierInvoice(
|
||
|
|
id=uuid.uuid4(),
|
||
|
|
tenant_id=virtual_uuid,
|
||
|
|
supplier_id=new_supplier_id,
|
||
|
|
purchase_order_id=new_po_id,
|
||
|
|
invoice_number=f"INV-{uuid.uuid4().hex[:8].upper()}", # New invoice number
|
||
|
|
supplier_invoice_number=invoice.supplier_invoice_number,
|
||
|
|
status=invoice.status,
|
||
|
|
invoice_date=invoice.invoice_date + date_offset,
|
||
|
|
due_date=invoice.due_date + date_offset,
|
||
|
|
received_date=invoice.received_date + date_offset,
|
||
|
|
subtotal=invoice.subtotal,
|
||
|
|
tax_amount=invoice.tax_amount,
|
||
|
|
shipping_cost=invoice.shipping_cost,
|
||
|
|
discount_amount=invoice.discount_amount,
|
||
|
|
total_amount=invoice.total_amount,
|
||
|
|
currency=invoice.currency,
|
||
|
|
paid_amount=invoice.paid_amount,
|
||
|
|
payment_date=invoice.payment_date + date_offset if invoice.payment_date else None,
|
||
|
|
payment_reference=invoice.payment_reference,
|
||
|
|
approved_by=invoice.approved_by,
|
||
|
|
approved_at=invoice.approved_at + date_offset if invoice.approved_at else None,
|
||
|
|
rejection_reason=invoice.rejection_reason,
|
||
|
|
notes=invoice.notes,
|
||
|
|
invoice_document_url=invoice.invoice_document_url,
|
||
|
|
created_at=datetime.now(timezone.utc),
|
||
|
|
updated_at=datetime.now(timezone.utc),
|
||
|
|
created_by=invoice.created_by
|
||
|
|
)
|
||
|
|
db.add(new_invoice)
|
||
|
|
stats["invoices"] += 1
|
||
|
|
|
||
|
|
# Commit all changes
|
||
|
|
await db.commit()
|
||
|
|
|
||
|
|
total_records = sum(stats.values())
|
||
|
|
duration_ms = int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000)
|
||
|
|
|
||
|
|
logger.info(
|
||
|
|
"Suppliers data cloning completed",
|
||
|
|
virtual_tenant_id=virtual_tenant_id,
|
||
|
|
total_records=total_records,
|
||
|
|
stats=stats,
|
||
|
|
duration_ms=duration_ms
|
||
|
|
)
|
||
|
|
|
||
|
|
return {
|
||
|
|
"service": "suppliers",
|
||
|
|
"status": "completed",
|
||
|
|
"records_cloned": total_records,
|
||
|
|
"duration_ms": duration_ms,
|
||
|
|
"details": stats
|
||
|
|
}
|
||
|
|
|
||
|
|
except ValueError as e:
|
||
|
|
logger.error("Invalid UUID format", error=str(e))
|
||
|
|
raise HTTPException(status_code=400, detail=f"Invalid UUID: {str(e)}")
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(
|
||
|
|
"Failed to clone suppliers data",
|
||
|
|
error=str(e),
|
||
|
|
virtual_tenant_id=virtual_tenant_id,
|
||
|
|
exc_info=True
|
||
|
|
)
|
||
|
|
|
||
|
|
# Rollback on error
|
||
|
|
await db.rollback()
|
||
|
|
|
||
|
|
return {
|
||
|
|
"service": "suppliers",
|
||
|
|
"status": "failed",
|
||
|
|
"records_cloned": 0,
|
||
|
|
"duration_ms": int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000),
|
||
|
|
"error": str(e)
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
@router.get("/clone/health")
|
||
|
|
async def clone_health_check(_: bool = Depends(verify_internal_api_key)):
|
||
|
|
"""
|
||
|
|
Health check for internal cloning endpoint
|
||
|
|
Used by orchestrator to verify service availability
|
||
|
|
"""
|
||
|
|
return {
|
||
|
|
"service": "suppliers",
|
||
|
|
"clone_endpoint": "available",
|
||
|
|
"version": "2.0.0"
|
||
|
|
}
|