Prepare ERP source for Gitea deployment
This commit is contained in:
A R R R Associates
@@ -0,0 +1,337 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from datetime import date, datetime, timezone
|
||||
from typing import Iterable
|
||||
|
||||
from sqlalchemy import func, select
|
||||
from sqlalchemy.orm import Session, selectinload
|
||||
|
||||
from app.modules.services.models import (
|
||||
ClientServiceSubscription,
|
||||
ServiceCatalogue,
|
||||
ServiceDueDateExtension,
|
||||
ServiceDueDateRule,
|
||||
)
|
||||
|
||||
DUE_PERIOD_TYPES = [
|
||||
("yearly", "Yearly / Annual"),
|
||||
("monthly", "Monthly"),
|
||||
("quarterly", "Quarterly"),
|
||||
("one_time", "One Time"),
|
||||
("event_based", "Event Based"),
|
||||
("renewal_based", "Renewal Before Expiry"),
|
||||
("custom", "Custom / Manual"),
|
||||
]
|
||||
|
||||
DUE_YEAR_BASIS_CHOICES = [
|
||||
("assessment_year_start", "Assessment year start year"),
|
||||
("financial_year_start", "Financial year start year"),
|
||||
("financial_year_end", "Financial year end year"),
|
||||
("calendar_year", "Calendar year from period"),
|
||||
]
|
||||
|
||||
DUE_DATE_SOURCE_RULE = "rule"
|
||||
DUE_DATE_SOURCE_EXTENSION = "extension"
|
||||
DUE_DATE_SOURCE_MANUAL = "manual"
|
||||
|
||||
|
||||
def parse_optional_date(value: str | None) -> date | None:
|
||||
value = (value or "").strip()
|
||||
if not value:
|
||||
return None
|
||||
return date.fromisoformat(value)
|
||||
|
||||
|
||||
def _parse_year_pair(value: str | None) -> tuple[int, int] | None:
|
||||
value = (value or "").strip()
|
||||
match = re.match(r"^(\d{4})\s*-\s*(\d{2}|\d{4})$", value)
|
||||
if not match:
|
||||
return None
|
||||
start = int(match.group(1))
|
||||
end_raw = match.group(2)
|
||||
end = int(end_raw) if len(end_raw) == 4 else int(str(start)[:2] + end_raw)
|
||||
return start, end
|
||||
|
||||
|
||||
def _month_add(year: int, month: int, offset: int) -> tuple[int, int]:
|
||||
index = (year * 12 + (month - 1)) + int(offset or 0)
|
||||
return index // 12, index % 12 + 1
|
||||
|
||||
|
||||
def _safe_date(year: int, month: int, day: int) -> date | None:
|
||||
try:
|
||||
return date(int(year), int(month), int(day))
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def _period_month_from_label(financial_year: str | None, period_label: str | None) -> tuple[int, int] | None:
|
||||
label = (period_label or "").strip().lower()
|
||||
fy = _parse_year_pair(financial_year)
|
||||
|
||||
iso_match = re.match(r"^(\d{4})[-/](\d{1,2})$", label)
|
||||
if iso_match:
|
||||
return int(iso_match.group(1)), int(iso_match.group(2))
|
||||
|
||||
month_names = {
|
||||
"apr": 4, "april": 4, "may": 5, "jun": 6, "june": 6, "jul": 7, "july": 7,
|
||||
"aug": 8, "august": 8, "sep": 9, "sept": 9, "september": 9, "oct": 10, "october": 10,
|
||||
"nov": 11, "november": 11, "dec": 12, "december": 12, "jan": 1, "january": 1,
|
||||
"feb": 2, "february": 2, "mar": 3, "march": 3,
|
||||
}
|
||||
if label in month_names and fy:
|
||||
month = month_names[label]
|
||||
year = fy[0] if month >= 4 else fy[1]
|
||||
return year, month
|
||||
return None
|
||||
|
||||
|
||||
def _quarter_end_from_label(financial_year: str | None, period_label: str | None) -> tuple[int, int] | None:
|
||||
label = (period_label or "").strip().lower().replace(" ", "")
|
||||
fy = _parse_year_pair(financial_year)
|
||||
if not fy:
|
||||
return None
|
||||
mapping = {
|
||||
"q1": (fy[0], 6), "quarter1": (fy[0], 6), "apr-jun": (fy[0], 6),
|
||||
"q2": (fy[0], 9), "quarter2": (fy[0], 9), "jul-sep": (fy[0], 9),
|
||||
"q3": (fy[0], 12), "quarter3": (fy[0], 12), "oct-dec": (fy[0], 12),
|
||||
"q4": (fy[1], 3), "quarter4": (fy[1], 3), "jan-mar": (fy[1], 3),
|
||||
}
|
||||
return mapping.get(label)
|
||||
|
||||
|
||||
def calculate_due_date(
|
||||
rule: ServiceDueDateRule | None,
|
||||
*,
|
||||
financial_year: str | None,
|
||||
assessment_year: str | None = None,
|
||||
period_label: str | None = None,
|
||||
expiry_date: date | None = None,
|
||||
) -> date | None:
|
||||
"""Calculate a statutory due date from a catalogue due-date rule.
|
||||
|
||||
The function is intentionally conservative. If the rule needs a period label
|
||||
and the engagement does not yet carry one, it returns None instead of
|
||||
guessing. This preserves existing engagement creation behaviour.
|
||||
"""
|
||||
if not rule or not getattr(rule, "is_active", True):
|
||||
return None
|
||||
day = getattr(rule, "due_day", None)
|
||||
|
||||
period_type = (getattr(rule, "period_type", None) or "yearly").strip().lower()
|
||||
due_month = getattr(rule, "due_month", None)
|
||||
month_offset = int(getattr(rule, "due_month_offset", None) or 0)
|
||||
|
||||
if period_type in {"renewal_based", "before_expiry", "expiry_based"}:
|
||||
if not expiry_date:
|
||||
return None
|
||||
days_before = int(getattr(rule, "renewal_days_before_expiry", None) or 0)
|
||||
from datetime import timedelta
|
||||
return expiry_date - timedelta(days=days_before)
|
||||
|
||||
if not day:
|
||||
return None
|
||||
|
||||
if period_type in {"yearly", "one_time"}:
|
||||
if not due_month:
|
||||
return None
|
||||
basis = (getattr(rule, "due_year_basis", None) or "assessment_year_start").strip().lower()
|
||||
fy = _parse_year_pair(financial_year)
|
||||
ay = _parse_year_pair(assessment_year)
|
||||
if basis == "financial_year_start" and fy:
|
||||
year = fy[0]
|
||||
elif basis == "financial_year_end" and fy:
|
||||
year = fy[1]
|
||||
elif ay:
|
||||
year = ay[0]
|
||||
elif fy:
|
||||
year = fy[1]
|
||||
else:
|
||||
return None
|
||||
return _safe_date(year, int(due_month), int(day))
|
||||
|
||||
if period_type == "monthly":
|
||||
period = _period_month_from_label(financial_year, period_label)
|
||||
if not period:
|
||||
return None
|
||||
year, month = _month_add(period[0], period[1], month_offset)
|
||||
return _safe_date(year, month, int(day))
|
||||
|
||||
if period_type == "quarterly":
|
||||
period = _quarter_end_from_label(financial_year, period_label)
|
||||
if not period:
|
||||
return None
|
||||
year, month = _month_add(period[0], period[1], month_offset)
|
||||
return _safe_date(year, month, int(day))
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def get_active_due_rule_for_catalogue(db: Session, *, catalogue_id: int) -> ServiceDueDateRule | None:
|
||||
return db.execute(
|
||||
select(ServiceDueDateRule)
|
||||
.where(
|
||||
ServiceDueDateRule.service_catalogue_id == catalogue_id,
|
||||
ServiceDueDateRule.is_active.is_(True),
|
||||
)
|
||||
.order_by(ServiceDueDateRule.sort_order.asc(), ServiceDueDateRule.id.asc())
|
||||
).scalars().first()
|
||||
|
||||
|
||||
def list_due_rules(db: Session, *, catalogue_id: int, include_inactive: bool = True) -> list[ServiceDueDateRule]:
|
||||
query = select(ServiceDueDateRule).where(ServiceDueDateRule.service_catalogue_id == catalogue_id)
|
||||
if not include_inactive:
|
||||
query = query.where(ServiceDueDateRule.is_active.is_(True))
|
||||
return db.execute(query.order_by(ServiceDueDateRule.sort_order.asc(), ServiceDueDateRule.id.asc())).scalars().all()
|
||||
|
||||
|
||||
def get_due_rule(db: Session, *, rule_id: int, catalogue_id: int | None = None) -> ServiceDueDateRule | None:
|
||||
query = select(ServiceDueDateRule).where(ServiceDueDateRule.id == rule_id)
|
||||
if catalogue_id:
|
||||
query = query.where(ServiceDueDateRule.service_catalogue_id == catalogue_id)
|
||||
return db.execute(query).scalar_one_or_none()
|
||||
|
||||
|
||||
def list_due_extensions(db: Session, *, catalogue_id: int, tenant_id: int | None = None, limit: int = 20) -> list[ServiceDueDateExtension]:
|
||||
query = (
|
||||
select(ServiceDueDateExtension)
|
||||
.options(selectinload(ServiceDueDateExtension.due_rule))
|
||||
.where(ServiceDueDateExtension.service_catalogue_id == catalogue_id)
|
||||
)
|
||||
if tenant_id:
|
||||
query = query.where(ServiceDueDateExtension.tenant_id == tenant_id)
|
||||
return db.execute(
|
||||
query.order_by(ServiceDueDateExtension.id.desc()).limit(limit)
|
||||
).scalars().all()
|
||||
|
||||
|
||||
def apply_due_date_rule_to_subscription(
|
||||
db: Session,
|
||||
subscription: ClientServiceSubscription,
|
||||
*,
|
||||
force: bool = False,
|
||||
) -> date | None:
|
||||
if getattr(subscription, "is_locked", False):
|
||||
return getattr(subscription, "current_due_date", None)
|
||||
rule = get_active_due_rule_for_catalogue(db, catalogue_id=subscription.service_catalogue_id)
|
||||
rule_type = (getattr(rule, "period_type", None) or "").strip().lower() if rule else ""
|
||||
# For normal statutory rules, preserve an already calculated/extended due date.
|
||||
# For renewal-based rules, recalculate when expiry_date changes, unless the due date was manually overridden/extended.
|
||||
if getattr(subscription, "current_due_date", None) and not force:
|
||||
if rule_type not in {"renewal_based", "before_expiry", "expiry_based"}:
|
||||
return subscription.current_due_date
|
||||
if getattr(subscription, "due_date_source", None) in {DUE_DATE_SOURCE_EXTENSION, DUE_DATE_SOURCE_MANUAL}:
|
||||
return subscription.current_due_date
|
||||
calculated = calculate_due_date(
|
||||
rule,
|
||||
financial_year=subscription.financial_year,
|
||||
assessment_year=subscription.assessment_year,
|
||||
period_label=getattr(subscription, "period_label", None),
|
||||
expiry_date=getattr(subscription, "expiry_date", None),
|
||||
)
|
||||
if calculated:
|
||||
subscription.due_date_rule_id = rule.id if rule else None
|
||||
subscription.original_due_date = calculated
|
||||
subscription.current_due_date = calculated
|
||||
subscription.due_date_source = DUE_DATE_SOURCE_RULE
|
||||
return calculated
|
||||
|
||||
|
||||
def _matching_extension_query(
|
||||
*,
|
||||
tenant_id: int,
|
||||
catalogue_id: int,
|
||||
rule_id: int | None,
|
||||
financial_year: str,
|
||||
assessment_year: str | None,
|
||||
period_label: str | None,
|
||||
):
|
||||
query = select(ServiceDueDateExtension).where(
|
||||
ServiceDueDateExtension.tenant_id == tenant_id,
|
||||
ServiceDueDateExtension.service_catalogue_id == catalogue_id,
|
||||
ServiceDueDateExtension.financial_year == financial_year,
|
||||
)
|
||||
if rule_id:
|
||||
query = query.where(ServiceDueDateExtension.due_date_rule_id == rule_id)
|
||||
if assessment_year:
|
||||
query = query.where(ServiceDueDateExtension.assessment_year == assessment_year)
|
||||
if period_label:
|
||||
query = query.where(ServiceDueDateExtension.period_label == period_label)
|
||||
else:
|
||||
query = query.where((ServiceDueDateExtension.period_label.is_(None)) | (ServiceDueDateExtension.period_label == ""))
|
||||
return query
|
||||
|
||||
|
||||
def create_due_date_extension(
|
||||
db: Session,
|
||||
*,
|
||||
tenant_id: int,
|
||||
catalogue_id: int,
|
||||
due_date_rule_id: int | None,
|
||||
financial_year: str,
|
||||
assessment_year: str | None,
|
||||
period_label: str | None,
|
||||
extended_due_date: date,
|
||||
notification_reference: str | None,
|
||||
notification_date: date | None,
|
||||
remarks: str | None,
|
||||
user_id: int,
|
||||
) -> tuple[ServiceDueDateExtension, int, int]:
|
||||
rule = get_due_rule(db, rule_id=due_date_rule_id, catalogue_id=catalogue_id) if due_date_rule_id else get_active_due_rule_for_catalogue(db, catalogue_id=catalogue_id)
|
||||
latest = db.execute(
|
||||
_matching_extension_query(
|
||||
tenant_id=tenant_id,
|
||||
catalogue_id=catalogue_id,
|
||||
rule_id=rule.id if rule else None,
|
||||
financial_year=financial_year,
|
||||
assessment_year=assessment_year,
|
||||
period_label=period_label,
|
||||
).order_by(ServiceDueDateExtension.extension_sequence.desc(), ServiceDueDateExtension.id.desc())
|
||||
).scalars().first()
|
||||
|
||||
base_due = calculate_due_date(rule, financial_year=financial_year, assessment_year=assessment_year, period_label=period_label)
|
||||
previous_due = latest.extended_due_date if latest else base_due
|
||||
sequence = int((latest.extension_sequence if latest else 0) or 0) + 1
|
||||
|
||||
extension = ServiceDueDateExtension(
|
||||
tenant_id=tenant_id,
|
||||
service_catalogue_id=catalogue_id,
|
||||
due_date_rule_id=rule.id if rule else None,
|
||||
financial_year=financial_year,
|
||||
assessment_year=assessment_year,
|
||||
period_label=(period_label or "").strip() or None,
|
||||
previous_due_date=previous_due,
|
||||
extended_due_date=extended_due_date,
|
||||
extension_sequence=sequence,
|
||||
notification_reference=(notification_reference or "").strip() or None,
|
||||
notification_date=notification_date,
|
||||
remarks=(remarks or "").strip() or None,
|
||||
created_by_user_id=user_id,
|
||||
updated_by_user_id=user_id,
|
||||
)
|
||||
db.add(extension)
|
||||
db.flush()
|
||||
|
||||
updated = skipped_locked = 0
|
||||
sub_query = select(ClientServiceSubscription).where(
|
||||
ClientServiceSubscription.tenant_id == tenant_id,
|
||||
ClientServiceSubscription.service_catalogue_id == catalogue_id,
|
||||
ClientServiceSubscription.financial_year == financial_year,
|
||||
)
|
||||
if assessment_year:
|
||||
sub_query = sub_query.where(ClientServiceSubscription.assessment_year == assessment_year)
|
||||
subscriptions = db.execute(sub_query).scalars().all()
|
||||
for sub in subscriptions:
|
||||
if getattr(sub, "is_locked", False):
|
||||
skipped_locked += 1
|
||||
continue
|
||||
if rule:
|
||||
sub.due_date_rule_id = rule.id
|
||||
if not getattr(sub, "original_due_date", None):
|
||||
sub.original_due_date = previous_due or base_due
|
||||
sub.current_due_date = extended_due_date
|
||||
sub.due_date_source = DUE_DATE_SOURCE_EXTENSION
|
||||
sub.updated_by_user_id = user_id
|
||||
updated += 1
|
||||
return extension, updated, skipped_locked
|
||||
Reference in New Issue
Block a user