{escape("No Premature Withdrawal" if investment.scheme.category == investment.scheme.Categories.DIAMOND else (investment.scheme.withdrawal_type or "—"))}
Terms & Rules
{rules_html}
Authorised SignatoryKuber Trobe
"""]
for att in attachments:
url = file_url(att)
lower = (att.file.name or "").lower()
if lower.endswith((".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg")):
content = f''
elif lower.endswith(".pdf"):
content = f''
else:
content = f''
pages.append(f"""
KUBER TROBECertificate Attachment
{content}
""")
return f"""Kuber Trobe Investment Certificate
{"".join(pages)}"""
def record_diamond_investment_on_balance_sheet(*, business, investment_date, amount, entered_by):
"""Record Diamond funding in the business Balance Sheet.
The investment is treated as new business funding: the received amount
increases bank balance (asset) and owner capital (equity) by the same
amount, so the Balance Sheet remains balanced. If there is no statement
on the investment date, a new point-in-time statement is copied from the
latest statement on/before that date.
"""
from .models import BalanceSheet, DailyFinancialStatement
amount = money(amount)
previous = BalanceSheet.objects.filter(
business=business,
statement_date__lte=investment_date,
deleted_at__isnull=True,
).order_by("-statement_date", "-id").first()
if previous is None:
raise ValueError("Diamond investment requires a Balance Sheet on or before the investment date.")
# Update the most recent Balance Sheet for this business. Diamond funding
# increases the business equity by the investment amount, so the latest
# statement's calculated Total Equity increases automatically through
# owner_capital. Do not create a separate historical statement merely
# because the investment date differs from the statement date.
sheet = previous
sheet.bank_balance = D(sheet.bank_balance) + amount
sheet.owner_capital = D(sheet.owner_capital) + amount
if not sheet.remarks:
sheet.remarks = ""
sheet.remarks = (
f"{sheet.remarks} | Diamond investment funding +{amount} "
f"recorded on {investment_date}."
).strip(" |")
sheet.entered_by = entered_by
sheet.save()
# The same cash receipt is also reflected in the day's financing cash flow.
financial = DailyFinancialStatement.objects.filter(
business=business,
statement_date=investment_date,
deleted_at__isnull=True,
).first()
if financial:
financial.financing_cash_inflow = D(financial.financing_cash_inflow) + amount
financial.save(update_fields=["financing_cash_inflow", "updated_at"])
return sheet
def build_terms_snapshot(scheme, investment, diamond_valuation_before=None, diamond_sheet=None):
snapshot = {
"category": scheme.category,
"scheme_name": scheme.name,
"tenure_months": scheme.tenure_months,
"annual_interest_rate": str(scheme.annual_interest_rate),
"penalty_rate": str(scheme.penalty_rate),
"withdrawal_type": scheme.withdrawal_type,
"compounding_frequency": scheme.compounding_frequency,
"rules": scheme.rules,
}
if scheme.category == scheme.Categories.PLATINUM:
snapshot["monthly_installment"] = str(investment.monthly_installment)
elif scheme.category == scheme.Categories.DIAMOND:
if diamond_valuation_before is None:
valuation, sheet = latest_business_equity(
investment.business, as_of=investment.investment_date
)
else:
valuation = money(diamond_valuation_before)
sheet = diamond_sheet
amount = D(investment.amount)
post_investment_valuation = valuation + amount
if post_investment_valuation <= 0:
raise ValueError("Diamond post-investment valuation must be greater than zero.")
ownership = (amount / post_investment_valuation) * D("100")
snapshot.update({
"investment_amount_type": "ONE_TIME",
"diamond_valuation_before_investment": str(money(valuation)),
"diamond_valuation_after_investment": str(money(post_investment_valuation)),
"diamond_ownership_percentage": str(ownership),
"diamond_valuation_statement_date": str(sheet.statement_date),
"diamond_valuation_source": "BALANCE_SHEET_TOTAL_EQUITY",
"diamond_maturity_rule": "LATEST_BUSINESS_EQUITY_X_LOCKED_OWNERSHIP_PERCENTAGE_PLUS_LEDGER_INTEREST",
"diamond_premature_withdrawal": False,
})
else:
snapshot["investment_amount_type"] = "ONE_TIME"
return snapshot
def audit(actor, operation, module, obj=None, description="", metadata=None):
from .models import AuditLog
return AuditLog.objects.create(
actor=actor,
operation=operation,
module=module,
object_type=obj.__class__.__name__ if obj else "",
object_id=str(obj.pk) if obj and getattr(obj, "pk", None) else "",
description=description,
metadata=metadata or {},
)
@transaction.atomic
def create_investment_with_snapshot(
*, investor, business, scheme, amount=None, monthly_installment=None,
created_by, investment_date=None
):
from .models import Investment
investment_date = investment_date or timezone.localdate()
if scheme.category == scheme.Categories.PLATINUM:
if monthly_installment is None or D(monthly_installment) <= 0:
raise ValueError("Platinum investment requires a positive monthly_installment.")
amount = None
else:
if amount is None or D(amount) <= 0:
raise ValueError("Silver, Gold and Diamond investments require a positive one-time amount.")
monthly_installment = None
maturity_date = months_after(investment_date, scheme.tenure_months)
# The scheme percentage is authoritative; admin does not type a separate rate.
investor_rate = scheme.annual_interest_rate
diamond_pre_valuation = None
diamond_pre_sheet = None
if scheme.category == scheme.Categories.DIAMOND:
diamond_pre_valuation, diamond_pre_sheet = latest_business_equity(
business, as_of=investment_date
)
obj = Investment.objects.create(
investor=investor,
business=business,
scheme=scheme,
amount=amount,
monthly_installment=monthly_installment,
investor_annual_rate=investor_rate,
investment_date=investment_date,
maturity_date=maturity_date,
created_by=created_by,
)
if scheme.category == scheme.Categories.DIAMOND:
# Diamond is a direct company <-> investor Investment record. It does
# not create KuberBusinessInvestment, but the received funding is
# added to the business's most recent Balance Sheet so Total Equity
# reflects the new Diamond investment.
record_diamond_investment_on_balance_sheet(
business=business,
investment_date=investment_date,
amount=amount,
entered_by=created_by,
)
obj.terms_snapshot = build_terms_snapshot(
scheme,
obj,
diamond_valuation_before=diamond_pre_valuation,
diamond_sheet=diamond_pre_sheet,
)
obj.save(update_fields=["terms_snapshot"])
return obj
@transaction.atomic
def generate_daily_ledger(entry_date=None):
"""
Generate every missing daily ledger entry up to entry_date.
The function is idempotent. If the server was offline for previous
days, running Generate Today backfills those missing dates without
duplicating entries that already exist.
Platinum starts accruing only from the first actual recurring
contribution date, and the daily amount uses all actual contributions
received up to each ledger date.
"""
from .models import KuberBusinessInvestment, Investment, LedgerEntry
entry_date = entry_date or timezone.localdate()
created_ids = []
# ------------------------------------------------------------
# KUBER -> BUSINESS CREDIT PROFIT
# ------------------------------------------------------------
kuber_qs = (
KuberBusinessInvestment.objects
.filter(
deleted_at__isnull=True,
investment_date__lte=entry_date,
)
.select_related("business")
)
for ki in kuber_qs:
current_date = ki.investment_date
end_date = (
min(entry_date, ki.maturity_date)
if ki.maturity_date
else entry_date
)
while current_date <= end_date:
exists = LedgerEntry.objects.filter(
kuber_investment=ki,
entry_date=current_date,
entry_type=LedgerEntry.EntryTypes.CREDIT_PROFIT,
).exists()
if not exists:
amount = daily_business_credit(ki.amount, ki.annual_rate)
description = "Automatic daily Kuber-to-business credit profit."
# The existing ledger constraint allows one CREDIT_PROFIT entry
# per Kuber investment per day. On the maturity date, the daily
# profit and the principal are therefore recorded together in
# the same Credit Profit entry.
if ki.maturity_date and current_date == ki.maturity_date:
amount = money(D(amount) + D(ki.amount))
description = (
"Kuber investment matured: principal plus daily profit "
"credited to business ledger."
)
if amount:
e = LedgerEntry.objects.create(
business=ki.business,
kuber_investment=ki,
entry_date=current_date,
entry_type=LedgerEntry.EntryTypes.CREDIT_PROFIT,
amount=amount,
annual_rate=ki.annual_rate,
description=description,
reference=f"KBI-{ki.pk}-{current_date}",
)
created_ids.append(e.pk)
current_date += timedelta(days=1)
# ------------------------------------------------------------
# INVESTOR SOFT DEBIT
# ------------------------------------------------------------
investments = (
Investment.objects
.filter(
deleted_at__isnull=True,
investment_date__lte=entry_date,
status=Investment.Status.ACTIVE,
)
.select_related("business", "investor", "scheme")
)
for inv in investments:
if inv.scheme.category == inv.scheme.Categories.PLATINUM:
first_contribution = (
inv.recurring_contributions
.filter(
deleted_at__isnull=True,
contribution_date__lte=entry_date,
)
.order_by("contribution_date")
.first()
)
if not first_contribution:
# No actual Platinum payment means no investor interest yet.
continue
start_date = first_contribution.contribution_date
else:
start_date = inv.investment_date
current_date = start_date
end_date = (
min(entry_date, inv.maturity_date)
if inv.maturity_date
else entry_date
)
while current_date <= end_date:
amount = daily_investor_soft_debit(inv, current_date)
description = (
f"Automatic daily {inv.scheme.get_category_display()} "
"investor soft debit."
)
# On maturity, add the original principal to the same Soft Debit
# ledger entry as the final day's accrued return. This preserves
# the existing one-entry-per-day constraint.
if (
inv.maturity_date
and current_date == inv.maturity_date
and inv.scheme.category != inv.scheme.Categories.DIAMOND
):
principal = (
inv.recurring_contributions
.filter(
contribution_date__lte=current_date,
deleted_at__isnull=True,
)
.aggregate(v=Sum("amount"))["v"]
or D("0")
) if inv.scheme.category == inv.scheme.Categories.PLATINUM else (inv.amount or D("0"))
amount = money(D(amount) + D(principal))
description = (
f"{inv.scheme.get_category_display()} investment matured: "
"principal plus final accrued return recorded as investor "
"soft debit."
)
if amount:
exists = LedgerEntry.objects.filter(
investment=inv,
entry_date=current_date,
entry_type=LedgerEntry.EntryTypes.SOFT_DEBIT,
).exists()
if not exists:
e = LedgerEntry.objects.create(
business=inv.business,
investment=inv,
investor=inv.investor,
entry_date=current_date,
entry_type=LedgerEntry.EntryTypes.SOFT_DEBIT,
amount=amount,
annual_rate=inv.investor_annual_rate,
description=description,
reference=f"INV-{inv.pk}-{current_date}",
)
created_ids.append(e.pk)
current_date += timedelta(days=1)
if inv.maturity_date and entry_date >= inv.maturity_date and inv.status == inv.Status.ACTIVE:
inv.status = inv.Status.MATURED
inv.save(update_fields=["status", "updated_at"] if hasattr(inv, "updated_at") else ["status"])
# Agent profit-share ledger is additive to the existing investor/business ledger.
# Import lazily to avoid creating an app import cycle.
try:
from agent_panel.services import generate_daily_agent_ledger
agent_created_ids = generate_daily_agent_ledger(entry_date)
except Exception:
# Never allow the new Agent feature to break the existing ledger job.
agent_created_ids = []
return {
"date": entry_date,
"created_entry_ids": created_ids,
"agent_created_entry_ids": agent_created_ids,
"created_count": len(created_ids),
}
def daily_ledger_job():
return generate_daily_ledger(timezone.localdate())