Odoo 19 for Real Estate:
Property Listings, Lease Management & Commission Tracking

class RealEstateListing(models.Model):
    _name = 'real.estate.listing'
    _description = 'Property Listing'
    _inherit = ['mail.thread', 'mail.activity.mixin']
    _order = 'create_date desc'

    property_id = fields.Many2one('real.estate.property', required=True, tracking=True)
    unit_id = fields.Many2one(
        'real.estate.unit', domain="[('property_id', '=', property_id)]",
    )
    listing_type = fields.Selection([
        ('rent', 'For Rent'), ('sale', 'For Sale'),
    ], required=True, tracking=True)
    asking_price = fields.Monetary(currency_field='currency_id', tracking=True)
    monthly_rent = fields.Monetary(currency_field='currency_id', tracking=True)
    currency_id = fields.Many2one(related='property_id.currency_id')
    agent_id = fields.Many2one(
        'hr.employee', string='Assigned Agent',
        domain="[('department_id.name', '=', 'Sales')]", tracking=True,
    )
    date_listed = fields.Date(string='Date Listed')
    date_closed = fields.Date(string='Date Closed')
    days_on_market = fields.Integer(compute='_compute_days_on_market', store=True)
    state = fields.Selection([
        ('draft', 'Draft'), ('review', 'Under Review'),
        ('published', 'Published'), ('under_offer', 'Under Offer'),
        ('closed', 'Closed'), ('expired', 'Expired'),
    ], default='draft', tracking=True)
    virtual_tour_url = fields.Char(string='Virtual Tour URL')

    @api.depends('date_listed', 'date_closed')
    def _compute_days_on_market(self):
        today = fields.Date.today()
        for rec in self:
            if rec.date_listed:
                end = rec.date_closed or today
                rec.days_on_market = (end - rec.date_listed).days
            else:
                rec.days_on_market = 0

    def action_publish(self):
        for rec in self:
            if not rec.property_id.image:
                raise ValidationError("Cannot publish without a property photo.")
            rec.write({'state': 'published', 'date_listed': fields.Date.today()})
            rec.property_id.state = 'available'

from dateutil.relativedelta import relativedelta


class RealEstateLease(models.Model):
    _name = 'real.estate.lease'
    _description = 'Lease Agreement'
    _inherit = ['mail.thread', 'mail.activity.mixin']
    _order = 'date_start desc'

    name = fields.Char(
        string='Lease Reference', required=True, copy=False,
        default=lambda self: self.env['ir.sequence'].next_by_code('real.estate.lease'),
    )
    property_id = fields.Many2one('real.estate.property', required=True, tracking=True)
    unit_id = fields.Many2one(
        'real.estate.unit', domain="[('property_id', '=', property_id)]",
    )
    tenant_id = fields.Many2one('res.partner', string='Tenant', required=True, tracking=True)
    agent_id = fields.Many2one('hr.employee', string='Leasing Agent', tracking=True)
    date_start = fields.Date(string='Lease Start', required=True, tracking=True)
    date_end = fields.Date(string='Lease End', required=True, tracking=True)
    monthly_rent = fields.Monetary(
        string='Monthly Rent', required=True, currency_field='currency_id', tracking=True,
    )
    security_deposit = fields.Monetary(currency_field='currency_id')
    deposit_paid = fields.Boolean(string='Deposit Received', tracking=True)
    payment_day = fields.Integer(string='Rent Due Day', default=1)
    escalation_pct = fields.Float(string='Annual Escalation %', default=3.0)
    currency_id = fields.Many2one(related='property_id.currency_id')
    state = fields.Selection([
        ('draft', 'Draft'), ('active', 'Active'),
        ('renewal', 'Up for Renewal'), ('terminated', 'Terminated'),
        ('expired', 'Expired'),
    ], default='draft', tracking=True)
    invoice_ids = fields.One2many('account.move', 'lease_id', string='Invoices')
    total_invoiced = fields.Monetary(
        compute='_compute_total_invoiced', store=True, currency_field='currency_id',
    )

    @api.depends('invoice_ids.amount_total', 'invoice_ids.state')
    def _compute_total_invoiced(self):
        for rec in self:
            posted = rec.invoice_ids.filtered(lambda i: i.state == 'posted')
            rec.total_invoiced = sum(posted.mapped('amount_total'))

    def action_activate(self):
        for rec in self:
            rec.state = 'active'
            if rec.unit_id:
                rec.unit_id.write({
                    'state': 'occupied',
                    'tenant_id': rec.tenant_id.id,
                })
            else:
                rec.property_id.state = 'leased'

    def action_terminate(self):
        for rec in self:
            rec.state = 'terminated'
            if rec.unit_id:
                rec.unit_id.write({
                    'state': 'vacant',
                    'tenant_id': False,
                })
            else:
                rec.property_id.state = 'available'

    @api.model
    def _cron_check_renewals(self):
        """Flag leases expiring within 60 days."""
        threshold = fields.Date.today() + relativedelta(days=60)
        leases = self.search([
            ('state', '=', 'active'),
            ('date_end', '<=', threshold),
        ])
        for lease in leases:
            lease.state = 'renewal'
            lease.activity_schedule(
                'mail.mail_activity_data_todo',
                date_deadline=lease.date_end
                    - relativedelta(days=30),
                summary=f'Lease renewal due: '
                    f'{lease.tenant_id.name}',
                user_id=lease.agent_id.user_id.id
                    if lease.agent_id else
                    self.env.user.id,
            )

def _get_current_rent(self):
    """Apply annual escalation to base rent."""
    if not self.date_start:
        return self.monthly_rent
    today = fields.Date.today()
    years = relativedelta(today, self.date_start).years
    escalation = (1 + self.escalation_pct / 100) ** years
    return round(self.monthly_rent * escalation, 2)

def _generate_rent_invoice(self):
    """Create a single month's rent invoice for this lease."""
    rent = self._get_current_rent()
    invoice = self.env['account.move'].create({
        'move_type': 'out_invoice',
        'partner_id': self.tenant_id.id,
        'lease_id': self.id,
        'invoice_date': fields.Date.today(),
        'invoice_date_due': fields.Date.today().replace(
            day=self.payment_day
        ),
        'invoice_line_ids': [(0, 0, {
            'name': f"Rent: {self.property_id.name}"
                    f"{' - Unit ' + self.unit_id.unit_number if self.unit_id else ''}"
                    f" ({fields.Date.today().strftime('%B %Y')})",
            'quantity': 1,
            'price_unit': rent,
            'account_id': self.env['account.account'].search([
                ('code', '=', '400100'),
            ], limit=1).id,
        })],
    })
    return invoice

@api.model
def _cron_generate_monthly_invoices(self):
    """Scheduled action: generate rent invoices for all active leases."""
    today = fields.Date.today()
    active_leases = self.search([
        ('state', 'in', ['active', 'renewal']),
        ('date_start', '<=', today),
        ('date_end', '>=', today),
    ])
    invoices = self.env['account.move']
    for lease in active_leases:
        # Prevent duplicate invoices for the same month
        existing = self.env['account.move'].search([
            ('lease_id', '=', lease.id),
            ('invoice_date', '>=', today.replace(day=1)),
            ('invoice_date', '<=', today),
        ], limit=1)
        if not existing:
            invoices |= lease._generate_rent_invoice()
    return invoices