770 lines
29 KiB
Python
770 lines
29 KiB
Python
|
"""
|
||
|
|
Fixed-Price Agreement Router
|
||
|
|
CRUD operations, billing period management, and reporting
|
||
|
|
"""
|
||
|
|
from fastapi import APIRouter, HTTPException, Response
|
||
|
|
from fastapi.responses import StreamingResponse
|
||
|
|
from app.core.database import execute_query
|
||
|
|
from app.fixed_price.backend.models import (
|
||
|
|
FixedPriceAgreement,
|
||
|
|
FixedPriceAgreementCreate,
|
||
|
|
FixedPriceAgreementUpdate,
|
||
|
|
CancellationRequest,
|
||
|
|
BillingPeriod,
|
||
|
|
BillingPeriodCreate,
|
||
|
|
BillingPeriodApproval,
|
||
|
|
)
|
||
|
|
from typing import List, Optional, Dict, Any
|
||
|
|
from datetime import date, datetime, timedelta
|
||
|
|
from decimal import Decimal, ROUND_CEILING
|
||
|
|
from calendar import monthrange
|
||
|
|
import logging
|
||
|
|
import csv
|
||
|
|
from io import StringIO
|
||
|
|
|
||
|
|
logger = logging.getLogger(__name__)
|
||
|
|
|
||
|
|
router = APIRouter()
|
||
|
|
|
||
|
|
|
||
|
|
def _apply_rounding(hours: Decimal, rounding_minutes: int) -> Decimal:
|
||
|
|
"""Apply rounding to hours based on interval (same as prepaid cards)"""
|
||
|
|
if rounding_minutes <= 0:
|
||
|
|
return hours
|
||
|
|
|
||
|
|
interval = Decimal(rounding_minutes) / Decimal(60)
|
||
|
|
rounded = (hours / interval).to_integral_value(ROUND_CEILING) * interval
|
||
|
|
return rounded
|
||
|
|
|
||
|
|
|
||
|
|
def _last_day_of_month(dt: date) -> date:
|
||
|
|
"""Get last day of month for given date"""
|
||
|
|
last_day = monthrange(dt.year, dt.month)[1]
|
||
|
|
return date(dt.year, dt.month, last_day)
|
||
|
|
|
||
|
|
|
||
|
|
def _calculate_prorated_amount(monthly_hours: float, hourly_rate: float,
|
||
|
|
period_start: date, period_end: date) -> float:
|
||
|
|
"""
|
||
|
|
Calculate pro-rated amount based on actual days in period.
|
||
|
|
|
||
|
|
If period is a full calendar month, returns full monthly amount.
|
||
|
|
Otherwise, calculates daily rate and multiplies by days in period.
|
||
|
|
"""
|
||
|
|
# Full month amount
|
||
|
|
monthly_amount = monthly_hours * hourly_rate
|
||
|
|
|
||
|
|
# Check if period is a full month (starts on 1st and ends on last day)
|
||
|
|
last_day_of_month = monthrange(period_start.year, period_start.month)[1]
|
||
|
|
if period_start.day == 1 and period_end.day == last_day_of_month and period_start.month == period_end.month:
|
||
|
|
return monthly_amount
|
||
|
|
|
||
|
|
# Calculate pro-rated amount for partial month
|
||
|
|
days_in_month = monthrange(period_start.year, period_start.month)[1]
|
||
|
|
days_in_period = (period_end - period_start).days + 1 # +1 to include both start and end
|
||
|
|
|
||
|
|
daily_rate = monthly_amount / days_in_month
|
||
|
|
prorated_amount = daily_rate * days_in_period
|
||
|
|
|
||
|
|
return prorated_amount
|
||
|
|
|
||
|
|
|
||
|
|
# ============================================================================
|
||
|
|
# CRUD Operations
|
||
|
|
# ============================================================================
|
||
|
|
|
||
|
|
@router.get("/fixed-price-agreements", response_model=List[Dict[str, Any]])
|
||
|
|
async def get_agreements(
|
||
|
|
customer_id: Optional[int] = None,
|
||
|
|
status: Optional[str] = None,
|
||
|
|
include_current_period: bool = True
|
||
|
|
):
|
||
|
|
"""
|
||
|
|
Get all fixed-price agreements with optional filters
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
filters = []
|
||
|
|
params = []
|
||
|
|
|
||
|
|
if customer_id:
|
||
|
|
filters.append("customer_id = %s")
|
||
|
|
params.append(customer_id)
|
||
|
|
|
||
|
|
if status:
|
||
|
|
filters.append("status = %s")
|
||
|
|
params.append(status)
|
||
|
|
|
||
|
|
where_clause = "WHERE " + " AND ".join(filters) if filters else ""
|
||
|
|
|
||
|
|
agreements = execute_query(f"""
|
||
|
|
SELECT * FROM customer_fixed_price_agreements
|
||
|
|
{where_clause}
|
||
|
|
ORDER BY created_at DESC
|
||
|
|
""", params if params else None)
|
||
|
|
|
||
|
|
# Enrich with current period info
|
||
|
|
if include_current_period and agreements:
|
||
|
|
for agr in agreements:
|
||
|
|
period = execute_query("""
|
||
|
|
SELECT
|
||
|
|
used_hours,
|
||
|
|
remaining_hours,
|
||
|
|
overtime_hours,
|
||
|
|
status
|
||
|
|
FROM fixed_price_billing_periods
|
||
|
|
WHERE agreement_id = %s
|
||
|
|
AND period_start <= CURRENT_DATE
|
||
|
|
AND period_end >= CURRENT_DATE
|
||
|
|
ORDER BY period_start DESC
|
||
|
|
LIMIT 1
|
||
|
|
""", (agr['id'],))
|
||
|
|
|
||
|
|
if period and len(period) > 0:
|
||
|
|
agr['current_period'] = period[0]
|
||
|
|
agr['remaining_hours_this_month'] = float(period[0]['remaining_hours'])
|
||
|
|
else:
|
||
|
|
agr['current_period'] = None
|
||
|
|
agr['remaining_hours_this_month'] = float(agr['monthly_hours'])
|
||
|
|
|
||
|
|
return agreements or []
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error fetching agreements: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.get("/fixed-price-agreements/{agreement_id}", response_model=Dict[str, Any])
|
||
|
|
async def get_agreement(agreement_id: int):
|
||
|
|
"""
|
||
|
|
Get single agreement with full details including periods and timelogs
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
agreements = execute_query("""
|
||
|
|
SELECT * FROM customer_fixed_price_agreements
|
||
|
|
WHERE id = %s
|
||
|
|
""", (agreement_id,))
|
||
|
|
|
||
|
|
if not agreements or len(agreements) == 0:
|
||
|
|
raise HTTPException(status_code=404, detail="Agreement not found")
|
||
|
|
|
||
|
|
agreement = agreements[0]
|
||
|
|
|
||
|
|
# Get billing periods
|
||
|
|
periods = execute_query("""
|
||
|
|
SELECT * FROM fixed_price_billing_periods
|
||
|
|
WHERE agreement_id = %s
|
||
|
|
ORDER BY period_start DESC
|
||
|
|
""", (agreement_id,))
|
||
|
|
|
||
|
|
agreement['billing_periods'] = periods or []
|
||
|
|
|
||
|
|
# Get timelogs (similar to prepaid card detail)
|
||
|
|
sag_logs = execute_query("""
|
||
|
|
SELECT
|
||
|
|
t.id,
|
||
|
|
t.worked_date,
|
||
|
|
t.original_hours as actual_hours,
|
||
|
|
t.approved_hours as rounded_hours,
|
||
|
|
t.description,
|
||
|
|
t.sag_id as source_id,
|
||
|
|
'sag' as source,
|
||
|
|
s.titel as source_title
|
||
|
|
FROM tmodule_times t
|
||
|
|
LEFT JOIN tmodule_sag s ON t.sag_id = s.id
|
||
|
|
WHERE t.fixed_price_agreement_id = %s
|
||
|
|
ORDER BY t.worked_date DESC
|
||
|
|
""", (agreement_id,))
|
||
|
|
|
||
|
|
ticket_logs = execute_query("""
|
||
|
|
SELECT
|
||
|
|
w.id,
|
||
|
|
w.created_at::date as worked_date,
|
||
|
|
w.hours as actual_hours,
|
||
|
|
w.rounded_hours,
|
||
|
|
w.description,
|
||
|
|
w.ticket_id as source_id,
|
||
|
|
'ticket' as source,
|
||
|
|
t.ticket_number,
|
||
|
|
t.subject as source_title
|
||
|
|
FROM tticket_worklog w
|
||
|
|
LEFT JOIN tticket_tickets t ON w.ticket_id = t.id
|
||
|
|
WHERE w.fixed_price_agreement_id = %s
|
||
|
|
ORDER BY w.created_at DESC
|
||
|
|
""", (agreement_id,))
|
||
|
|
|
||
|
|
# Combine and sort timelogs
|
||
|
|
timelogs = []
|
||
|
|
for log in (sag_logs or []):
|
||
|
|
timelogs.append(log)
|
||
|
|
for log in (ticket_logs or []):
|
||
|
|
timelogs.append(log)
|
||
|
|
|
||
|
|
timelogs.sort(key=lambda x: x['worked_date'], reverse=True)
|
||
|
|
agreement['timelogs'] = timelogs
|
||
|
|
|
||
|
|
return agreement
|
||
|
|
|
||
|
|
except HTTPException:
|
||
|
|
raise
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error fetching agreement {agreement_id}: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.post("/fixed-price-agreements", response_model=Dict[str, Any])
|
||
|
|
async def create_agreement(data: FixedPriceAgreementCreate):
|
||
|
|
"""
|
||
|
|
Create new fixed-price agreement and initialize first billing period
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
# Validate rounding
|
||
|
|
if data.rounding_minutes not in (0, 15, 30, 60):
|
||
|
|
raise HTTPException(status_code=400, detail="Invalid rounding_minutes")
|
||
|
|
|
||
|
|
# Insert agreement
|
||
|
|
from app.core.database import get_db_connection, release_db_connection
|
||
|
|
from psycopg2.extras import RealDictCursor
|
||
|
|
|
||
|
|
conn = get_db_connection()
|
||
|
|
try:
|
||
|
|
with conn.cursor(cursor_factory=RealDictCursor) as cursor:
|
||
|
|
# Create agreement
|
||
|
|
cursor.execute("""
|
||
|
|
INSERT INTO customer_fixed_price_agreements (
|
||
|
|
customer_id, customer_name, subscription_id,
|
||
|
|
monthly_hours, hourly_rate, overtime_rate, internal_cost_rate,
|
||
|
|
rounding_minutes, start_date, binding_months, end_date,
|
||
|
|
notice_period_days, auto_renew, economic_product_number,
|
||
|
|
economic_overtime_product_number, notes
|
||
|
|
) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||
|
|
RETURNING *
|
||
|
|
""", (
|
||
|
|
data.customer_id,
|
||
|
|
data.customer_name,
|
||
|
|
data.subscription_id,
|
||
|
|
data.monthly_hours,
|
||
|
|
data.hourly_rate,
|
||
|
|
data.overtime_rate,
|
||
|
|
data.internal_cost_rate,
|
||
|
|
data.rounding_minutes,
|
||
|
|
data.start_date,
|
||
|
|
data.binding_months,
|
||
|
|
data.end_date,
|
||
|
|
data.notice_period_days,
|
||
|
|
data.auto_renew,
|
||
|
|
data.economic_product_number,
|
||
|
|
data.economic_overtime_product_number,
|
||
|
|
data.notes
|
||
|
|
))
|
||
|
|
agreement = cursor.fetchone()
|
||
|
|
|
||
|
|
# Create first billing period
|
||
|
|
period_start = data.start_date
|
||
|
|
period_end = _last_day_of_month(period_start)
|
||
|
|
|
||
|
|
# Calculate pro-rated amount for first period
|
||
|
|
base_amount = _calculate_prorated_amount(
|
||
|
|
data.monthly_hours,
|
||
|
|
data.hourly_rate,
|
||
|
|
period_start,
|
||
|
|
period_end
|
||
|
|
)
|
||
|
|
|
||
|
|
# Pro-rate included hours as well for partial months
|
||
|
|
days_in_month = monthrange(period_start.year, period_start.month)[1]
|
||
|
|
days_in_period = (period_end - period_start).days + 1
|
||
|
|
last_day_of_month = monthrange(period_start.year, period_start.month)[1]
|
||
|
|
|
||
|
|
if period_start.day == 1 and period_end.day == last_day_of_month:
|
||
|
|
# Full month
|
||
|
|
included_hours = data.monthly_hours
|
||
|
|
else:
|
||
|
|
# Pro-rate hours for partial month
|
||
|
|
included_hours = (data.monthly_hours / days_in_month) * days_in_period
|
||
|
|
|
||
|
|
cursor.execute("""
|
||
|
|
INSERT INTO fixed_price_billing_periods (
|
||
|
|
agreement_id, period_start, period_end,
|
||
|
|
included_hours, base_amount
|
||
|
|
) VALUES (%s, %s, %s, %s, %s)
|
||
|
|
RETURNING *
|
||
|
|
""", (
|
||
|
|
agreement['id'],
|
||
|
|
period_start,
|
||
|
|
period_end,
|
||
|
|
included_hours,
|
||
|
|
base_amount
|
||
|
|
))
|
||
|
|
first_period = cursor.fetchone()
|
||
|
|
|
||
|
|
conn.commit()
|
||
|
|
|
||
|
|
logger.info(f"✅ Created fixed-price agreement {agreement['agreement_number']} for customer {data.customer_id}")
|
||
|
|
|
||
|
|
agreement['first_period'] = first_period
|
||
|
|
return agreement
|
||
|
|
|
||
|
|
finally:
|
||
|
|
release_db_connection(conn)
|
||
|
|
|
||
|
|
except HTTPException:
|
||
|
|
raise
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error creating agreement: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.patch("/fixed-price-agreements/{agreement_id}", response_model=Dict[str, Any])
|
||
|
|
async def update_agreement(agreement_id: int, data: FixedPriceAgreementUpdate):
|
||
|
|
"""
|
||
|
|
Update agreement terms (does not affect existing periods)
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
# Build UPDATE query dynamically
|
||
|
|
updates = []
|
||
|
|
params = []
|
||
|
|
|
||
|
|
for field, value in data.model_dump(exclude_unset=True).items():
|
||
|
|
if value is not None:
|
||
|
|
updates.append(f"{field} = %s")
|
||
|
|
params.append(value)
|
||
|
|
|
||
|
|
if not updates:
|
||
|
|
raise HTTPException(status_code=400, detail="No fields to update")
|
||
|
|
|
||
|
|
params.append(agreement_id)
|
||
|
|
|
||
|
|
result = execute_query(f"""
|
||
|
|
UPDATE customer_fixed_price_agreements
|
||
|
|
SET {", ".join(updates)}
|
||
|
|
WHERE id = %s
|
||
|
|
RETURNING *
|
||
|
|
""", params)
|
||
|
|
|
||
|
|
if not result or len(result) == 0:
|
||
|
|
raise HTTPException(status_code=404, detail="Agreement not found")
|
||
|
|
|
||
|
|
logger.info(f"✅ Updated fixed-price agreement {agreement_id}")
|
||
|
|
return result[0]
|
||
|
|
|
||
|
|
except HTTPException:
|
||
|
|
raise
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error updating agreement {agreement_id}: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.put("/fixed-price-agreements/{agreement_id}/status")
|
||
|
|
async def update_status(agreement_id: int, status: str):
|
||
|
|
"""
|
||
|
|
Update agreement status (active, suspended, etc.)
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
valid_statuses = ['active', 'suspended', 'expired', 'cancelled', 'pending_cancellation']
|
||
|
|
if status not in valid_statuses:
|
||
|
|
raise HTTPException(status_code=400, detail=f"Invalid status. Must be one of {valid_statuses}")
|
||
|
|
|
||
|
|
result = execute_query("""
|
||
|
|
UPDATE customer_fixed_price_agreements
|
||
|
|
SET status = %s
|
||
|
|
WHERE id = %s
|
||
|
|
RETURNING *
|
||
|
|
""", (status, agreement_id))
|
||
|
|
|
||
|
|
if not result or len(result) == 0:
|
||
|
|
raise HTTPException(status_code=404, detail="Agreement not found")
|
||
|
|
|
||
|
|
logger.info(f"✅ Agreement {agreement_id} status → {status}")
|
||
|
|
return result[0]
|
||
|
|
|
||
|
|
except HTTPException:
|
||
|
|
raise
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error updating status: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.post("/fixed-price-agreements/{agreement_id}/cancel")
|
||
|
|
async def cancel_agreement(agreement_id: int, request: CancellationRequest):
|
||
|
|
"""
|
||
|
|
Request cancellation with binding period validation
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
agreements = execute_query("""
|
||
|
|
SELECT * FROM customer_fixed_price_agreements
|
||
|
|
WHERE id = %s
|
||
|
|
""", (agreement_id,))
|
||
|
|
|
||
|
|
if not agreements or len(agreements) == 0:
|
||
|
|
raise HTTPException(status_code=404, detail="Agreement not found")
|
||
|
|
|
||
|
|
agreement = agreements[0]
|
||
|
|
today = date.today()
|
||
|
|
binding_end = agreement['binding_end_date']
|
||
|
|
|
||
|
|
# Check binding period
|
||
|
|
if binding_end and today < binding_end and not request.force:
|
||
|
|
raise HTTPException(
|
||
|
|
status_code=400,
|
||
|
|
detail=f"Aftale er bundet til {binding_end}. Kontakt administrator for tvungen opsigelse."
|
||
|
|
)
|
||
|
|
|
||
|
|
# Calculate effective date
|
||
|
|
effective_date = request.effective_date or (today + timedelta(days=agreement['notice_period_days']))
|
||
|
|
|
||
|
|
# Update agreement
|
||
|
|
result = execute_query("""
|
||
|
|
UPDATE customer_fixed_price_agreements
|
||
|
|
SET status = 'pending_cancellation',
|
||
|
|
cancellation_requested_date = %s,
|
||
|
|
cancellation_effective_date = %s,
|
||
|
|
cancellation_reason = %s
|
||
|
|
WHERE id = %s
|
||
|
|
RETURNING *
|
||
|
|
""", (today, effective_date, request.reason, agreement_id))
|
||
|
|
|
||
|
|
logger.info(f"⚠️ Agreement {agreement_id} cancellation requested, effective {effective_date}")
|
||
|
|
return result[0]
|
||
|
|
|
||
|
|
except HTTPException:
|
||
|
|
raise
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error cancelling agreement: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
# ============================================================================
|
||
|
|
# Billing Period Management
|
||
|
|
# ============================================================================
|
||
|
|
|
||
|
|
@router.get("/fixed-price-agreements/{agreement_id}/periods", response_model=List[Dict[str, Any]])
|
||
|
|
async def get_periods(agreement_id: int):
|
||
|
|
"""Get all billing periods for agreement"""
|
||
|
|
try:
|
||
|
|
periods = execute_query("""
|
||
|
|
SELECT * FROM fixed_price_billing_periods
|
||
|
|
WHERE agreement_id = %s
|
||
|
|
ORDER BY period_start DESC
|
||
|
|
""", (agreement_id,))
|
||
|
|
|
||
|
|
return periods or []
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error fetching periods: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.put("/fixed-price-agreements/{agreement_id}/periods/{period_id}/approve-overtime")
|
||
|
|
async def approve_overtime(agreement_id: int, period_id: int, approval: BillingPeriodApproval):
|
||
|
|
"""
|
||
|
|
Approve overtime hours for billing
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
# Calculate overtime amount
|
||
|
|
agreements = execute_query("""
|
||
|
|
SELECT overtime_rate FROM customer_fixed_price_agreements
|
||
|
|
WHERE id = %s
|
||
|
|
""", (agreement_id,))
|
||
|
|
|
||
|
|
if not agreements or len(agreements) == 0:
|
||
|
|
raise HTTPException(status_code=404, detail="Agreement not found")
|
||
|
|
|
||
|
|
overtime_rate = agreements[0]['overtime_rate']
|
||
|
|
overtime_amount = approval.overtime_hours * Decimal(str(overtime_rate))
|
||
|
|
|
||
|
|
# Update period
|
||
|
|
result = execute_query("""
|
||
|
|
UPDATE fixed_price_billing_periods
|
||
|
|
SET overtime_amount = %s,
|
||
|
|
overtime_approved = %s,
|
||
|
|
status = CASE
|
||
|
|
WHEN %s THEN 'ready_to_bill'
|
||
|
|
ELSE status
|
||
|
|
END
|
||
|
|
WHERE id = %s AND agreement_id = %s
|
||
|
|
RETURNING *
|
||
|
|
""", (overtime_amount, approval.approved, approval.approved, period_id, agreement_id))
|
||
|
|
|
||
|
|
if not result or len(result) == 0:
|
||
|
|
raise HTTPException(status_code=404, detail="Period not found")
|
||
|
|
|
||
|
|
logger.info(f"✅ Overtime approved for period {period_id}: {approval.overtime_hours}t = {overtime_amount} DKK")
|
||
|
|
return result[0]
|
||
|
|
|
||
|
|
except HTTPException:
|
||
|
|
raise
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error approving overtime: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
# ============================================================================
|
||
|
|
# Reporting & Analytics
|
||
|
|
# ============================================================================
|
||
|
|
|
||
|
|
@router.get("/fixed-price-agreements/stats/summary")
|
||
|
|
async def get_stats_summary():
|
||
|
|
"""
|
||
|
|
Overall fixed-price system statistics
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
result = execute_query("""
|
||
|
|
SELECT
|
||
|
|
COUNT(DISTINCT id) as total_agreements,
|
||
|
|
COUNT(DISTINCT id) FILTER (WHERE status = 'active') as active_agreements,
|
||
|
|
COUNT(DISTINCT id) FILTER (WHERE status = 'cancelled') as cancelled_agreements,
|
||
|
|
COUNT(DISTINCT id) FILTER (WHERE status = 'expired') as expired_agreements,
|
||
|
|
|
||
|
|
SUM(monthly_hours) FILTER (WHERE status = 'active') as total_active_monthly_hours,
|
||
|
|
AVG(hourly_rate) FILTER (WHERE status = 'active') as avg_hourly_rate,
|
||
|
|
|
||
|
|
COUNT(DISTINCT customer_id) as unique_customers
|
||
|
|
FROM customer_fixed_price_agreements
|
||
|
|
""")[0]
|
||
|
|
|
||
|
|
# Get revenue and profit from performance view
|
||
|
|
performance = execute_query("""
|
||
|
|
SELECT
|
||
|
|
COALESCE(SUM(total_revenue), 0) as total_revenue,
|
||
|
|
COALESCE(SUM(total_internal_cost), 0) as total_cost,
|
||
|
|
COALESCE(SUM(total_profit), 0) as total_profit,
|
||
|
|
COALESCE(AVG(utilization_percent), 0) as avg_utilization
|
||
|
|
FROM fixed_price_agreement_performance
|
||
|
|
WHERE status = 'active'
|
||
|
|
""")[0]
|
||
|
|
|
||
|
|
return {**result, **performance}
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error fetching stats: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.get("/fixed-price-agreements/reports/profitability")
|
||
|
|
async def get_profitability_report(
|
||
|
|
customer_id: Optional[int] = None,
|
||
|
|
start_date: Optional[date] = None,
|
||
|
|
end_date: Optional[date] = None
|
||
|
|
):
|
||
|
|
"""
|
||
|
|
Detailed profitability analysis with filters
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
filters = []
|
||
|
|
params = []
|
||
|
|
|
||
|
|
if customer_id:
|
||
|
|
filters.append("a.customer_id = %s")
|
||
|
|
params.append(customer_id)
|
||
|
|
if start_date:
|
||
|
|
filters.append("bp.period_start >= %s")
|
||
|
|
params.append(start_date)
|
||
|
|
if end_date:
|
||
|
|
filters.append("bp.period_end <= %s")
|
||
|
|
params.append(end_date)
|
||
|
|
|
||
|
|
where_clause = "WHERE " + " AND ".join(filters) if filters else ""
|
||
|
|
|
||
|
|
return execute_query(f"""
|
||
|
|
SELECT
|
||
|
|
a.id,
|
||
|
|
a.agreement_number,
|
||
|
|
a.customer_name,
|
||
|
|
a.monthly_hours,
|
||
|
|
a.hourly_rate,
|
||
|
|
a.internal_cost_rate,
|
||
|
|
|
||
|
|
COUNT(bp.id) as period_count,
|
||
|
|
COALESCE(SUM(bp.used_hours), 0) as total_hours,
|
||
|
|
COALESCE(SUM(bp.overtime_hours) FILTER (WHERE bp.overtime_approved), 0) as overtime_hours,
|
||
|
|
|
||
|
|
COALESCE(SUM(bp.base_amount) FILTER (WHERE bp.status = 'billed'), 0) as base_revenue,
|
||
|
|
COALESCE(SUM(bp.overtime_amount) FILTER (WHERE bp.status = 'billed' AND bp.overtime_approved), 0) as overtime_revenue,
|
||
|
|
COALESCE(SUM(bp.base_amount + COALESCE(bp.overtime_amount, 0)) FILTER (WHERE bp.status = 'billed'), 0) as total_revenue,
|
||
|
|
|
||
|
|
COALESCE(SUM(bp.used_hours), 0) * a.internal_cost_rate as internal_cost,
|
||
|
|
COALESCE(SUM(bp.base_amount + COALESCE(bp.overtime_amount, 0)) FILTER (WHERE bp.status = 'billed'), 0) -
|
||
|
|
COALESCE(SUM(bp.used_hours), 0) * a.internal_cost_rate as profit,
|
||
|
|
|
||
|
|
CASE
|
||
|
|
WHEN SUM(bp.base_amount + COALESCE(bp.overtime_amount, 0)) FILTER (WHERE bp.status = 'billed') > 0
|
||
|
|
THEN ROUND((
|
||
|
|
(SUM(bp.base_amount + COALESCE(bp.overtime_amount, 0)) FILTER (WHERE bp.status = 'billed') -
|
||
|
|
SUM(bp.used_hours) * a.internal_cost_rate) /
|
||
|
|
SUM(bp.base_amount + COALESCE(bp.overtime_amount, 0)) FILTER (WHERE bp.status = 'billed') * 100
|
||
|
|
)::numeric, 1)
|
||
|
|
ELSE 0
|
||
|
|
END as profit_margin_percent
|
||
|
|
|
||
|
|
FROM customer_fixed_price_agreements a
|
||
|
|
LEFT JOIN fixed_price_billing_periods bp ON a.id = bp.agreement_id
|
||
|
|
{where_clause}
|
||
|
|
GROUP BY a.id
|
||
|
|
ORDER BY profit DESC
|
||
|
|
""", params if params else None) or []
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error generating profitability report: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.get("/fixed-price-agreements/reports/monthly-trends")
|
||
|
|
async def get_monthly_trends(months: int = 12):
|
||
|
|
"""
|
||
|
|
Month-over-month trend analysis
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
return execute_query("""
|
||
|
|
SELECT * FROM fixed_price_monthly_trends
|
||
|
|
ORDER BY month DESC
|
||
|
|
LIMIT %s
|
||
|
|
""", (months,)) or []
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error fetching trends: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.get("/fixed-price-agreements/reports/customer-breakdown")
|
||
|
|
async def get_customer_breakdown():
|
||
|
|
"""
|
||
|
|
Per-customer revenue and profitability
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
return execute_query("""
|
||
|
|
SELECT * FROM fixed_price_customer_summary
|
||
|
|
ORDER BY total_revenue DESC
|
||
|
|
""") or []
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error fetching customer breakdown: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.get("/fixed-price-agreements/reports/overtime-analysis")
|
||
|
|
async def get_overtime_analysis():
|
||
|
|
"""
|
||
|
|
Analyze overtime patterns to identify agreements with frequent overruns
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
return execute_query("""
|
||
|
|
SELECT
|
||
|
|
a.id,
|
||
|
|
a.agreement_number,
|
||
|
|
a.customer_name,
|
||
|
|
a.monthly_hours,
|
||
|
|
|
||
|
|
COUNT(bp.id) as total_periods,
|
||
|
|
COUNT(bp.id) FILTER (WHERE bp.overtime_hours > 0) as periods_with_overtime,
|
||
|
|
ROUND((COUNT(bp.id) FILTER (WHERE bp.overtime_hours > 0)::numeric /
|
||
|
|
NULLIF(COUNT(bp.id), 0) * 100), 1) as overtime_frequency_percent,
|
||
|
|
|
||
|
|
AVG(bp.overtime_hours) FILTER (WHERE bp.overtime_hours > 0) as avg_overtime_per_period,
|
||
|
|
MAX(bp.overtime_hours) as max_overtime_single_period,
|
||
|
|
COALESCE(SUM(bp.overtime_hours), 0) as total_overtime_hours,
|
||
|
|
|
||
|
|
COALESCE(SUM(bp.overtime_amount) FILTER (WHERE bp.overtime_approved), 0) as total_overtime_revenue
|
||
|
|
|
||
|
|
FROM customer_fixed_price_agreements a
|
||
|
|
LEFT JOIN fixed_price_billing_periods bp ON a.id = bp.agreement_id
|
||
|
|
WHERE a.status = 'active'
|
||
|
|
GROUP BY a.id
|
||
|
|
HAVING COUNT(bp.id) > 0
|
||
|
|
ORDER BY overtime_frequency_percent DESC, total_overtime_hours DESC
|
||
|
|
""") or []
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error analyzing overtime: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.get("/fixed-price-agreements/{agreement_id}/reports/period-detail")
|
||
|
|
async def get_period_detail_report(agreement_id: int):
|
||
|
|
"""
|
||
|
|
Detailed period-by-period breakdown for single agreement
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
return execute_query("""
|
||
|
|
SELECT
|
||
|
|
bp.id,
|
||
|
|
bp.period_start,
|
||
|
|
bp.period_end,
|
||
|
|
bp.included_hours,
|
||
|
|
bp.used_hours,
|
||
|
|
bp.overtime_hours,
|
||
|
|
bp.base_amount,
|
||
|
|
bp.overtime_amount,
|
||
|
|
bp.overtime_approved,
|
||
|
|
bp.status,
|
||
|
|
bp.economic_invoice_number,
|
||
|
|
|
||
|
|
-- Calculate profit for this period
|
||
|
|
a.internal_cost_rate,
|
||
|
|
bp.used_hours * a.internal_cost_rate as period_cost,
|
||
|
|
(bp.base_amount + COALESCE(bp.overtime_amount, 0)) -
|
||
|
|
(bp.used_hours * a.internal_cost_rate) as period_profit,
|
||
|
|
|
||
|
|
-- Time entry breakdown
|
||
|
|
(SELECT COUNT(*) FROM tmodule_times
|
||
|
|
WHERE fixed_price_agreement_id = a.id
|
||
|
|
AND worked_date BETWEEN bp.period_start AND bp.period_end) as sag_entries,
|
||
|
|
(SELECT COUNT(*) FROM tticket_worklog
|
||
|
|
WHERE fixed_price_agreement_id = a.id
|
||
|
|
AND created_at::date BETWEEN bp.period_start AND bp.period_end) as ticket_entries
|
||
|
|
|
||
|
|
FROM fixed_price_billing_periods bp
|
||
|
|
JOIN customer_fixed_price_agreements a ON bp.agreement_id = a.id
|
||
|
|
WHERE a.id = %s
|
||
|
|
ORDER BY bp.period_start DESC
|
||
|
|
""", (agreement_id,)) or []
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error generating period detail: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|
||
|
|
|
||
|
|
|
||
|
|
@router.get("/fixed-price-agreements/reports/export/csv")
|
||
|
|
async def export_profitability_csv():
|
||
|
|
"""
|
||
|
|
Export full profitability report as CSV
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
data = execute_query("""
|
||
|
|
SELECT
|
||
|
|
a.agreement_number,
|
||
|
|
a.customer_name,
|
||
|
|
a.status,
|
||
|
|
a.monthly_hours,
|
||
|
|
a.hourly_rate,
|
||
|
|
a.overtime_rate,
|
||
|
|
a.internal_cost_rate,
|
||
|
|
a.start_date,
|
||
|
|
perf.total_periods,
|
||
|
|
perf.total_used_hours,
|
||
|
|
perf.total_approved_overtime,
|
||
|
|
perf.total_revenue,
|
||
|
|
perf.total_internal_cost,
|
||
|
|
perf.total_profit,
|
||
|
|
perf.utilization_percent
|
||
|
|
FROM customer_fixed_price_agreements a
|
||
|
|
LEFT JOIN fixed_price_agreement_performance perf ON a.id = perf.id
|
||
|
|
ORDER BY a.customer_name, a.agreement_number
|
||
|
|
""")
|
||
|
|
|
||
|
|
# Generate CSV
|
||
|
|
output = StringIO()
|
||
|
|
if data and len(data) > 0:
|
||
|
|
writer = csv.DictWriter(output, fieldnames=data[0].keys())
|
||
|
|
writer.writeheader()
|
||
|
|
writer.writerows(data)
|
||
|
|
|
||
|
|
return Response(
|
||
|
|
content=output.getvalue(),
|
||
|
|
media_type="text/csv",
|
||
|
|
headers={"Content-Disposition": "attachment; filename=fixed_price_profitability.csv"}
|
||
|
|
)
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
logger.error(f"❌ Error exporting CSV: {e}", exc_info=True)
|
||
|
|
raise HTTPException(status_code=500, detail=str(e))
|