556 lines
24 KiB
Python
556 lines
24 KiB
Python
from sqlalchemy.sql.expression import text
|
|
|
|
from common.extensions import db
|
|
from datetime import datetime as dt, timezone as tz
|
|
from enum import Enum
|
|
from sqlalchemy.dialects.postgresql import JSONB
|
|
from sqlalchemy.ext.hybrid import hybrid_property
|
|
from dateutil.relativedelta import relativedelta
|
|
|
|
from common.utils.database import Database
|
|
|
|
|
|
class BusinessEventLog(db.Model):
|
|
__bind_key__ = 'public'
|
|
__table_args__ = {'schema': 'public'}
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
timestamp = db.Column(db.DateTime, nullable=False)
|
|
event_type = db.Column(db.String(50), nullable=False)
|
|
tenant_id = db.Column(db.Integer, nullable=False)
|
|
trace_id = db.Column(db.String(50), nullable=False)
|
|
span_id = db.Column(db.String(50))
|
|
span_name = db.Column(db.String(255))
|
|
parent_span_id = db.Column(db.String(50))
|
|
document_version_id = db.Column(db.Integer)
|
|
document_version_file_size = db.Column(db.Float)
|
|
specialist_id = db.Column(db.Integer)
|
|
specialist_type = db.Column(db.String(50))
|
|
specialist_type_version = db.Column(db.String(20))
|
|
chat_session_id = db.Column(db.String(50))
|
|
interaction_id = db.Column(db.Integer)
|
|
environment = db.Column(db.String(20))
|
|
llm_metrics_total_tokens = db.Column(db.Integer)
|
|
llm_metrics_prompt_tokens = db.Column(db.Integer)
|
|
llm_metrics_completion_tokens = db.Column(db.Integer)
|
|
llm_metrics_total_time = db.Column(db.Float)
|
|
llm_metrics_nr_of_pages = db.Column(db.Integer)
|
|
llm_metrics_call_count = db.Column(db.Integer)
|
|
llm_interaction_type = db.Column(db.String(20))
|
|
message = db.Column(db.Text)
|
|
license_usage_id = db.Column(db.Integer, db.ForeignKey('public.license_usage.id'), nullable=True)
|
|
license_usage = db.relationship('LicenseUsage', backref='events')
|
|
|
|
|
|
class License(db.Model):
|
|
__bind_key__ = 'public'
|
|
__table_args__ = {'schema': 'public'}
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
tenant_id = db.Column(db.Integer, db.ForeignKey('public.tenant.id'), nullable=False)
|
|
tier_id = db.Column(db.Integer, db.ForeignKey('public.license_tier.id'),nullable=False) # 'small', 'medium', 'custom'
|
|
start_date = db.Column(db.Date, nullable=False)
|
|
nr_of_periods = db.Column(db.Integer, nullable=False)
|
|
currency = db.Column(db.String(20), nullable=False)
|
|
yearly_payment = db.Column(db.Boolean, nullable=False, default=False)
|
|
basic_fee = db.Column(db.Float, nullable=False)
|
|
max_storage_mb = db.Column(db.Integer, nullable=False)
|
|
additional_storage_price = db.Column(db.Float, nullable=False)
|
|
additional_storage_bucket = db.Column(db.Integer, nullable=False)
|
|
included_embedding_mb = db.Column(db.Integer, nullable=False)
|
|
additional_embedding_price = db.Column(db.Numeric(10, 4), nullable=False)
|
|
additional_embedding_bucket = db.Column(db.Integer, nullable=False)
|
|
included_interaction_tokens = db.Column(db.Integer, nullable=False)
|
|
additional_interaction_token_price = db.Column(db.Numeric(10, 4), nullable=False)
|
|
additional_interaction_bucket = db.Column(db.Integer, nullable=False)
|
|
overage_embedding = db.Column(db.Float, nullable=False, default=0)
|
|
overage_interaction = db.Column(db.Float, nullable=False, default=0)
|
|
additional_storage_allowed = db.Column(db.Boolean, nullable=False, default=False)
|
|
additional_embedding_allowed = db.Column(db.Boolean, nullable=False, default=False)
|
|
additional_interaction_allowed = db.Column(db.Boolean, nullable=False, default=False)
|
|
|
|
# Versioning Information
|
|
created_at = db.Column(db.DateTime, nullable=True, server_default=db.func.now())
|
|
created_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
|
|
updated_at = db.Column(db.DateTime, nullable=True, server_default=db.func.now(), onupdate=db.func.now())
|
|
updated_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
|
|
|
|
tenant = db.relationship('Tenant', back_populates='licenses')
|
|
license_tier = db.relationship('LicenseTier', back_populates='licenses')
|
|
periods = db.relationship('LicensePeriod', back_populates='license',
|
|
order_by='LicensePeriod.period_number',
|
|
cascade='all, delete-orphan')
|
|
|
|
@hybrid_property
|
|
def end_date(self):
|
|
"""
|
|
Berekent de einddatum van de licentie op basis van start_date en nr_of_periods.
|
|
Elke periode is 1 maand, dus einddatum = startdatum + nr_of_periods maanden - 1 dag
|
|
"""
|
|
if self.start_date and self.nr_of_periods:
|
|
return self.start_date + relativedelta(months=self.nr_of_periods) - relativedelta(days=1)
|
|
return None
|
|
|
|
@end_date.expression
|
|
def end_date(cls):
|
|
"""
|
|
SQL expressie versie van de end_date property voor gebruik in queries
|
|
"""
|
|
return db.func.date_add(
|
|
db.func.date_add(
|
|
cls.start_date,
|
|
db.text(f'INTERVAL cls.nr_of_periods MONTH')
|
|
),
|
|
db.text('INTERVAL -1 DAY')
|
|
)
|
|
|
|
def update_configuration(self, **changes):
|
|
"""
|
|
Update license configuration
|
|
These changes will only apply to future periods, not existing ones
|
|
|
|
Args:
|
|
**changes: Dictionary of changes to apply to the license
|
|
|
|
Returns:
|
|
None
|
|
"""
|
|
allowed_fields = [
|
|
'tier_id', 'currency', 'basic_fee', 'max_storage_mb',
|
|
'additional_storage_price', 'additional_storage_bucket',
|
|
'included_embedding_mb', 'additional_embedding_price', 'additional_embedding_bucket',
|
|
'included_interaction_tokens', 'additional_interaction_token_price',
|
|
'additional_interaction_bucket', 'overage_embedding', 'overage_interaction',
|
|
'additional_storage_allowed', 'additional_embedding_allowed',
|
|
'additional_interaction_allowed'
|
|
]
|
|
|
|
# Apply only allowed changes
|
|
for key, value in changes.items():
|
|
if key in allowed_fields:
|
|
setattr(self, key, value)
|
|
|
|
|
|
class LicenseTier(db.Model):
|
|
__bind_key__ = 'public'
|
|
__table_args__ = {'schema': 'public'}
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
name = db.Column(db.String(50), nullable=False)
|
|
version = db.Column(db.String(50), nullable=False)
|
|
start_date = db.Column(db.Date, nullable=False)
|
|
end_date = db.Column(db.Date, nullable=True)
|
|
basic_fee_d = db.Column(db.Float, nullable=True)
|
|
basic_fee_e = db.Column(db.Float, nullable=True)
|
|
max_storage_mb = db.Column(db.Integer, nullable=False)
|
|
additional_storage_price_d = db.Column(db.Numeric(10, 4), nullable=False)
|
|
additional_storage_price_e = db.Column(db.Numeric(10, 4), nullable=False)
|
|
additional_storage_bucket = db.Column(db.Integer, nullable=False)
|
|
included_embedding_mb = db.Column(db.Integer, nullable=False)
|
|
additional_embedding_price_d = db.Column(db.Numeric(10, 4), nullable=False)
|
|
additional_embedding_price_e = db.Column(db.Numeric(10, 4), nullable=False)
|
|
additional_embedding_bucket = db.Column(db.Integer, nullable=False)
|
|
included_interaction_tokens = db.Column(db.Integer, nullable=False)
|
|
additional_interaction_token_price_d = db.Column(db.Numeric(10, 4), nullable=False)
|
|
additional_interaction_token_price_e = db.Column(db.Numeric(10, 4), nullable=False)
|
|
additional_interaction_bucket = db.Column(db.Integer, nullable=False)
|
|
standard_overage_embedding = db.Column(db.Float, nullable=False, default=0)
|
|
standard_overage_interaction = db.Column(db.Float, nullable=False, default=0)
|
|
|
|
# Versioning Information
|
|
created_at = db.Column(db.DateTime, nullable=True, server_default=db.func.now())
|
|
created_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
|
|
updated_at = db.Column(db.DateTime, nullable=True, server_default=db.func.now(), onupdate=db.func.now())
|
|
updated_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
|
|
|
|
licenses = db.relationship('License', back_populates='license_tier')
|
|
partner_services = db.relationship('PartnerServiceLicenseTier', back_populates='license_tier')
|
|
|
|
|
|
class PartnerServiceLicenseTier(db.Model):
|
|
__bind_key__ = 'public'
|
|
__table_args__ = {'schema': 'public'}
|
|
|
|
partner_service_id = db.Column(db.Integer, db.ForeignKey('public.partner_service.id'), primary_key=True,
|
|
nullable=False)
|
|
license_tier_id = db.Column(db.Integer, db.ForeignKey('public.license_tier.id'), primary_key=True,
|
|
nullable=False)
|
|
|
|
# Versioning Information
|
|
created_at = db.Column(db.DateTime, nullable=True, server_default=db.func.now())
|
|
created_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
|
|
updated_at = db.Column(db.DateTime, nullable=True, server_default=db.func.now(), onupdate=db.func.now())
|
|
updated_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
|
|
|
|
license_tier = db.relationship('LicenseTier', back_populates='partner_services')
|
|
partner_service = db.relationship('PartnerService', back_populates='license_tiers')
|
|
|
|
|
|
class PeriodStatus(Enum):
|
|
UPCOMING = "UPCOMING" # The period is still in the future
|
|
PENDING = "PENDING" # The period is active, but prepaid is not yet received
|
|
ACTIVE = "ACTIVE" # The period is active and prepaid has been received
|
|
COMPLETED = "COMPLETED" # The period has been completed, but not yet invoiced
|
|
INVOICED = "INVOICED" # The period has been completed and invoiced, but overage payment still pending
|
|
CLOSED = "CLOSED" # The period has been closed, invoiced and fully paid
|
|
|
|
|
|
class LicensePeriod(db.Model):
|
|
__bind_key__ = 'public'
|
|
__table_args__ = {'schema': 'public'}
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
license_id = db.Column(db.Integer, db.ForeignKey('public.license.id'), nullable=False)
|
|
tenant_id = db.Column(db.Integer, db.ForeignKey('public.tenant.id'), nullable=False)
|
|
|
|
# Period identification
|
|
period_number = db.Column(db.Integer, nullable=False)
|
|
period_start = db.Column(db.Date, nullable=False)
|
|
period_end = db.Column(db.Date, nullable=False)
|
|
|
|
# License configuration snapshot - copied from license when period is created
|
|
currency = db.Column(db.String(20), nullable=False)
|
|
basic_fee = db.Column(db.Float, nullable=False)
|
|
max_storage_mb = db.Column(db.Integer, nullable=False)
|
|
additional_storage_price = db.Column(db.Float, nullable=False)
|
|
additional_storage_bucket = db.Column(db.Integer, nullable=False)
|
|
included_embedding_mb = db.Column(db.Integer, nullable=False)
|
|
additional_embedding_price = db.Column(db.Numeric(10, 4), nullable=False)
|
|
additional_embedding_bucket = db.Column(db.Integer, nullable=False)
|
|
included_interaction_tokens = db.Column(db.Integer, nullable=False)
|
|
additional_interaction_token_price = db.Column(db.Numeric(10, 4), nullable=False)
|
|
additional_interaction_bucket = db.Column(db.Integer, nullable=False)
|
|
|
|
# Allowance flags - can be changed from False to True within a period
|
|
additional_storage_allowed = db.Column(db.Boolean, nullable=False, default=False)
|
|
additional_embedding_allowed = db.Column(db.Boolean, nullable=False, default=False)
|
|
additional_interaction_allowed = db.Column(db.Boolean, nullable=False, default=False)
|
|
|
|
# Status tracking
|
|
status = db.Column(db.Enum(PeriodStatus), nullable=False, default=PeriodStatus.UPCOMING)
|
|
|
|
# State transition timestamps
|
|
upcoming_at = db.Column(db.DateTime, nullable=True)
|
|
pending_at = db.Column(db.DateTime, nullable=True)
|
|
active_at = db.Column(db.DateTime, nullable=True)
|
|
completed_at = db.Column(db.DateTime, nullable=True)
|
|
invoiced_at = db.Column(db.DateTime, nullable=True)
|
|
closed_at = db.Column(db.DateTime, nullable=True)
|
|
|
|
# Standard audit fields
|
|
created_at = db.Column(db.DateTime, server_default=db.func.now())
|
|
updated_at = db.Column(db.DateTime, server_default=db.func.now(), onupdate=db.func.now())
|
|
created_by = db.Column(db.Integer, db.ForeignKey('public.user.id'))
|
|
updated_by = db.Column(db.Integer, db.ForeignKey('public.user.id'))
|
|
|
|
# Relationships
|
|
license = db.relationship('License', back_populates='periods')
|
|
license_usage = db.relationship('LicenseUsage',
|
|
uselist=False, # This makes it one-to-one
|
|
back_populates='license_period',
|
|
cascade='all, delete-orphan')
|
|
payments = db.relationship('Payment', back_populates='license_period')
|
|
invoices = db.relationship('Invoice', back_populates='license_period',
|
|
cascade='all, delete-orphan')
|
|
|
|
def update_allowance(self, allowance_type, allow_value, user_id=None):
|
|
"""
|
|
Update an allowance flag within a period
|
|
Only allows transitioning from False to True
|
|
|
|
Args:
|
|
allowance_type: One of 'storage', 'embedding', or 'interaction'
|
|
allow_value: The new value (must be True)
|
|
user_id: User ID performing the update
|
|
|
|
Raises:
|
|
ValueError: If trying to change from True to False, or invalid allowance type
|
|
"""
|
|
field_name = f"additional_{allowance_type}_allowed"
|
|
|
|
# Verify valid field
|
|
if not hasattr(self, field_name):
|
|
raise ValueError(f"Invalid allowance type: {allowance_type}")
|
|
|
|
# Get current value
|
|
current_value = getattr(self, field_name)
|
|
|
|
# Only allow False -> True transition
|
|
if current_value is True and allow_value is True:
|
|
# Already True, no change needed
|
|
return
|
|
elif allow_value is False:
|
|
raise ValueError(f"Cannot change {field_name} from {current_value} to False")
|
|
|
|
# Update the field
|
|
setattr(self, field_name, True)
|
|
self.updated_at = dt.now(tz.utc)
|
|
if user_id:
|
|
self.updated_by = user_id
|
|
|
|
@property
|
|
def prepaid_invoice(self):
|
|
"""Get the prepaid invoice for this period"""
|
|
return Invoice.query.filter_by(
|
|
license_period_id=self.id,
|
|
invoice_type=PaymentType.PREPAID
|
|
).first()
|
|
|
|
@property
|
|
def overage_invoice(self):
|
|
"""Get the overage invoice for this period"""
|
|
return Invoice.query.filter_by(
|
|
license_period_id=self.id,
|
|
invoice_type=PaymentType.POSTPAID
|
|
).first()
|
|
|
|
@property
|
|
def prepaid_payment(self):
|
|
"""Get the prepaid payment for this period"""
|
|
return Payment.query.filter_by(
|
|
license_period_id=self.id,
|
|
payment_type=PaymentType.PREPAID
|
|
).first()
|
|
|
|
@property
|
|
def overage_payment(self):
|
|
"""Get the overage payment for this period"""
|
|
return Payment.query.filter_by(
|
|
license_period_id=self.id,
|
|
payment_type=PaymentType.POSTPAID
|
|
).first()
|
|
|
|
@property
|
|
def all_invoices(self):
|
|
"""Get all invoices for this period"""
|
|
return self.invoices
|
|
|
|
@property
|
|
def all_payments(self):
|
|
"""Get all payments for this period"""
|
|
return self.payments
|
|
|
|
def transition_status(self, new_status: PeriodStatus, user_id: int = None):
|
|
"""Transition to a new status with proper validation and logging"""
|
|
if not self.can_transition_to(new_status):
|
|
raise ValueError(f"Invalid status transition from {self.status} to {new_status}")
|
|
|
|
self.status = new_status
|
|
self.updated_at = dt.now(tz.utc)
|
|
if user_id:
|
|
self.updated_by = user_id
|
|
|
|
# Set appropriate timestamps
|
|
if new_status == PeriodStatus.ACTIVE and not self.prepaid_received_at:
|
|
self.prepaid_received_at = dt.now(tz.utc)
|
|
elif new_status == PeriodStatus.COMPLETED:
|
|
self.completed_at = dt.now(tz.utc)
|
|
elif new_status == PeriodStatus.INVOICED:
|
|
self.invoiced_at = dt.now(tz.utc)
|
|
elif new_status == PeriodStatus.CLOSED:
|
|
self.closed_at = dt.now(tz.utc)
|
|
|
|
@property
|
|
def is_overdue(self):
|
|
"""Check if a prepaid payment is overdue"""
|
|
return (self.status == PeriodStatus.PENDING and
|
|
self.period_start <= dt.now(tz.utc).date())
|
|
|
|
def can_transition_to(self, new_status: PeriodStatus) -> bool:
|
|
"""Check if a status transition is valid"""
|
|
valid_transitions = {
|
|
PeriodStatus.UPCOMING: [PeriodStatus.ACTIVE, PeriodStatus.PENDING],
|
|
PeriodStatus.PENDING: [PeriodStatus.ACTIVE],
|
|
PeriodStatus.ACTIVE: [PeriodStatus.COMPLETED],
|
|
PeriodStatus.COMPLETED: [PeriodStatus.INVOICED, PeriodStatus.CLOSED],
|
|
PeriodStatus.INVOICED: [PeriodStatus.CLOSED],
|
|
PeriodStatus.CLOSED: []
|
|
}
|
|
return new_status in valid_transitions.get(self.status, [])
|
|
|
|
def __repr__(self):
|
|
return f'<LicensePeriod {self.id}: License {self.license_id}, Period {self.period_number}>'
|
|
|
|
|
|
class LicenseUsage(db.Model):
|
|
__bind_key__ = 'public'
|
|
__table_args__ = {'schema': 'public'}
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
tenant_id = db.Column(db.Integer, db.ForeignKey('public.tenant.id'), nullable=False)
|
|
storage_mb_used = db.Column(db.Float, default=0)
|
|
embedding_mb_used = db.Column(db.Float, default=0)
|
|
embedding_prompt_tokens_used = db.Column(db.Integer, default=0)
|
|
embedding_completion_tokens_used = db.Column(db.Integer, default=0)
|
|
embedding_total_tokens_used = db.Column(db.Integer, default=0)
|
|
interaction_prompt_tokens_used = db.Column(db.Integer, default=0)
|
|
interaction_completion_tokens_used = db.Column(db.Integer, default=0)
|
|
interaction_total_tokens_used = db.Column(db.Integer, default=0)
|
|
license_period_id = db.Column(db.Integer, db.ForeignKey('public.license_period.id'), nullable=False)
|
|
|
|
# Standard audit fields
|
|
created_at = db.Column(db.DateTime, server_default=db.func.now())
|
|
updated_at = db.Column(db.DateTime, server_default=db.func.now(), onupdate=db.func.now())
|
|
created_by = db.Column(db.Integer, db.ForeignKey('public.user.id'))
|
|
updated_by = db.Column(db.Integer, db.ForeignKey('public.user.id'))
|
|
|
|
license_period = db.relationship('LicensePeriod', back_populates='license_usage')
|
|
|
|
def recalculate_storage(self):
|
|
Database(self.tenant_id).switch_schema()
|
|
# Perform a SUM operation to get the total file size from document_versions
|
|
total_storage = db.session.execute(text(f"""
|
|
SELECT SUM(file_size)
|
|
FROM document_version
|
|
""")).scalar()
|
|
|
|
self.storage_mb_used = total_storage
|
|
|
|
|
|
class PaymentType(Enum):
|
|
PREPAID = "PREPAID"
|
|
POSTPAID = "POSTPAID"
|
|
|
|
|
|
class PaymentStatus(Enum):
|
|
PENDING = "PENDING"
|
|
PAID = "PAID"
|
|
FAILED = "FAILED"
|
|
CANCELLED = "CANCELLED"
|
|
|
|
|
|
class Payment(db.Model):
|
|
__bind_key__ = 'public'
|
|
__table_args__ = {'schema': 'public'}
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
license_period_id = db.Column(db.Integer, db.ForeignKey('public.license_period.id'), nullable=True)
|
|
tenant_id = db.Column(db.Integer, db.ForeignKey('public.tenant.id'), nullable=False)
|
|
|
|
# Payment details
|
|
payment_type = db.Column(db.Enum(PaymentType), nullable=False)
|
|
amount = db.Column(db.Numeric(10, 2), nullable=False)
|
|
currency = db.Column(db.String(3), nullable=False)
|
|
description = db.Column(db.Text, nullable=True)
|
|
|
|
# Status tracking
|
|
status = db.Column(db.Enum(PaymentStatus), nullable=False, default=PaymentStatus.PENDING)
|
|
|
|
# External provider information
|
|
external_payment_id = db.Column(db.String(255), nullable=True)
|
|
payment_method = db.Column(db.String(50), nullable=True) # credit_card, bank_transfer, etc.
|
|
provider_data = db.Column(JSONB, nullable=True) # Provider-specific data
|
|
|
|
# Payment information
|
|
paid_at = db.Column(db.DateTime, nullable=True)
|
|
|
|
# Standard audit fields
|
|
created_at = db.Column(db.DateTime, server_default=db.func.now())
|
|
created_by = db.Column(db.Integer, db.ForeignKey('public.user.id'))
|
|
updated_at = db.Column(db.DateTime, server_default=db.func.now(), onupdate=db.func.now())
|
|
updated_by = db.Column(db.Integer, db.ForeignKey('public.user.id'))
|
|
|
|
# Relationships
|
|
license_period = db.relationship('LicensePeriod', back_populates='payments')
|
|
invoice = db.relationship('Invoice', back_populates='payment', uselist=False)
|
|
|
|
@property
|
|
def is_overdue(self):
|
|
"""Check if payment is overdue"""
|
|
if self.status != PaymentStatus.PENDING:
|
|
return False
|
|
|
|
# For prepaid payments, check if period start has passed
|
|
if (self.payment_type == PaymentType.PREPAID and
|
|
self.license_period_id):
|
|
return self.license_period.period_start <= dt.now(tz.utc).date()
|
|
|
|
# For postpaid, check against due date (would be on invoice)
|
|
return False
|
|
|
|
def __repr__(self):
|
|
return f'<Payment {self.id}: {self.payment_type} {self.amount} {self.currency}>'
|
|
|
|
|
|
class InvoiceStatus(Enum):
|
|
DRAFT = "DRAFT"
|
|
SENT = "SENT"
|
|
PAID = "PAID"
|
|
OVERDUE = "OVERDUE"
|
|
CANCELLED = "CANCELLED"
|
|
|
|
|
|
class Invoice(db.Model):
|
|
__bind_key__ = 'public'
|
|
__table_args__ = {'schema': 'public'}
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
license_period_id = db.Column(db.Integer, db.ForeignKey('public.license_period.id'), nullable=False)
|
|
payment_id = db.Column(db.Integer, db.ForeignKey('public.payment.id'), nullable=True)
|
|
tenant_id = db.Column(db.Integer, db.ForeignKey('public.tenant.id'), nullable=False)
|
|
|
|
# Invoice details
|
|
invoice_type = db.Column(db.Enum(PaymentType), nullable=False)
|
|
invoice_number = db.Column(db.String(50), unique=True, nullable=False)
|
|
invoice_date = db.Column(db.Date, nullable=False)
|
|
due_date = db.Column(db.Date, nullable=False)
|
|
|
|
# Financial details
|
|
amount = db.Column(db.Numeric(10, 2), nullable=False)
|
|
currency = db.Column(db.String(3), nullable=False)
|
|
tax_amount = db.Column(db.Numeric(10, 2), default=0)
|
|
|
|
# Descriptive fields
|
|
description = db.Column(db.Text, nullable=True)
|
|
status = db.Column(db.Enum(InvoiceStatus), nullable=False, default=InvoiceStatus.DRAFT)
|
|
|
|
# Timestamps
|
|
sent_at = db.Column(db.DateTime, nullable=True)
|
|
paid_at = db.Column(db.DateTime, nullable=True)
|
|
|
|
# Standard audit fields
|
|
created_at = db.Column(db.DateTime, server_default=db.func.now())
|
|
created_by = db.Column(db.Integer, db.ForeignKey('public.user.id'))
|
|
updated_at = db.Column(db.DateTime, server_default=db.func.now(), onupdate=db.func.now())
|
|
updated_by = db.Column(db.Integer, db.ForeignKey('public.user.id'))
|
|
|
|
# Relationships
|
|
license_period = db.relationship('LicensePeriod', back_populates='invoices')
|
|
payment = db.relationship('Payment', back_populates='invoice')
|
|
|
|
def __repr__(self):
|
|
return f'<Invoice {self.invoice_number}: {self.amount} {self.currency}>'
|
|
|
|
|
|
class LicenseChangeLog(db.Model):
|
|
"""
|
|
Log of changes to license configurations
|
|
Used for auditing and tracking when/why license details changed
|
|
"""
|
|
__bind_key__ = 'public'
|
|
__table_args__ = {'schema': 'public'}
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
license_id = db.Column(db.Integer, db.ForeignKey('public.license.id'), nullable=False)
|
|
changed_at = db.Column(db.DateTime, nullable=False, default=lambda: dt.now(tz.utc))
|
|
|
|
# What changed
|
|
field_name = db.Column(db.String(100), nullable=False)
|
|
old_value = db.Column(db.String(255), nullable=True)
|
|
new_value = db.Column(db.String(255), nullable=False)
|
|
|
|
# Why it changed
|
|
reason = db.Column(db.Text, nullable=True)
|
|
|
|
# Standard audit fields
|
|
created_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
|
|
|
|
# Relationships
|
|
license = db.relationship('License', backref=db.backref('change_logs', order_by='LicenseChangeLog.changed_at'))
|
|
|
|
def __repr__(self):
|
|
return f'<LicenseChangeLog: {self.license_id} {self.field_name} {self.old_value} -> {self.new_value}>'
|
|
|
|
|
|
|