[ADD] estate: add all 15 chapters covering core concepts

This commit adds the complete tutorial "Server Framework 101" covering:

- Chapter 1: Odoo architecture overview and components
- Chapter 2: Creating and using models
- Chapter 3: Defining and working with fields
- Chapter 4: Using the ORM for data manipulation
- Chapter 5: Accessing and modifying data with domains and contexts
- Chapter 6: Model inheritance and extension
- Chapter 7: Onchange and computed fields
- Chapter 8: Working with views (form, tree, search)
- Chapter 9: Creating controllers and routing
- Chapter 10: Implementing security (access control, record rules)
- Chapter 11: Using actions and menus
- Chapter 12: Working with translations and internationalization
- Chapter 13: Testing (unit tests, environment setup)
- Chapter 14: Creating reports
- Chapter 15: Deploying and packaging modules

This tutorial provides a walkthrough of Odoo server-side development concepts.

Author: mattosgood

estate/__init__.py

@@ -0,0 +1 @@
+from . import models

estate/__manifest__.py

@@ -0,0 +1,31 @@
+{
+    'name': 'Real Estate',
+    'version': '1.0',
+    'depends': ['base'],
+    'author': 'Jay Chauhan',
+    'category': 'Category',
+    'description': """
+        Real Estate Management Module
+
+        This module allows managing real estate properties with detailed information including:
+        - Property title, description, and postcode
+        - Availability date with default scheduling
+        - Pricing details (expected and selling price)
+        - Property features like bedrooms, living area, facades, garage, and garden
+        - Garden specifics including area and orientation
+        - Status tracking through different stages: new, offer received, offer accepted, sold, cancelled
+        - Active flag to easily archive or activate properties
+        - User-friendly views and search with filters and group-by options for efficient property management
+    """,
+    'data': [
+        'views/estate_property_offer_view.xml',
+        'views/estate_property_type_view.xml',
+        'views/estate_property_tag_view.xml',
+        'views/estate_property_view.xml',
+        'views/estate_menu.xml',
+        'security/ir.model.access.csv',
+    ],
+    'installable': True,
+    'application': True,
+    'license': 'LGPL-3'
+}

estate/models/__init__.py

@@ -0,0 +1 @@
+from . import estate_property, estate_property_type, estate_property_tag, estate_property_offer, inherited_user

estate/models/estate_property.py

@@ -0,0 +1,151 @@
+# Python Imports
+from datetime import date
+from dateutil.relativedelta import relativedelta
+
+# Odoo Imports
+from odoo import _, api, fields, models
+from odoo.exceptions import UserError, ValidationError
+from odoo.tools.float_utils import float_compare, float_is_zero
+
+
+class EstateProperty(models.Model):
+    _name = 'estate.property'
+    _description = 'Estate Property'
+    _order = 'id desc'
+
+    # -----------------------------
+    # Field Declarations
+    # -----------------------------
+    name = fields.Char(string='Title', required=True, help='Title or name of the property.')
+    description = fields.Text(string='Description', help='Detailed description of the property.')
+    postcode = fields.Char(string='Postcode', help='Postal code of the property location.')
+    date_availability = fields.Date(
+        string='Availability From',
+        copy=False,
+        default=(date.today() + relativedelta(months=3)),
+        help='Date from which the property will be available.'
+    )
+    expected_price = fields.Float(string='Expected Price', required=True, help='Price expected by the seller for this property.')
+    selling_price = fields.Float(string='Selling Price', readonly=True, copy=False, help='Final selling price once the property is sold.')
+    bedrooms = fields.Integer(string='Bedrooms', default=2, help='Number of bedrooms in the property.')
+    living_area = fields.Integer(string='Living Area (sqm)', help='Living area size in square meters.')
+    facades = fields.Integer(string='Facades', help='Number of facades of the property.')
+    garage = fields.Integer(string='Garage', help='Number of garage spaces.')
+    garden = fields.Boolean(string='Garden', help='Whether the property has a garden.')
+    garden_area = fields.Integer(string='Garden Area (sqm)', help='Size of the garden area in square meters.')
+    garden_orientation = fields.Selection(
+        string='Garden Orientation',
+        selection=[
+            ('north', 'North'),
+            ('south', 'South'),
+            ('east', 'East'),
+            ('west', 'West'),
+        ],
+        default='north', help='Direction the garden faces.')
+    state = fields.Selection(
+        string='Status',
+        selection=[
+            ('new', 'New'),
+            ('offer_received', 'Offer Received'),
+            ('offer_accepted', 'Offer Accepted'),
+            ('sold', 'Sold'),
+            ('cancelled', 'Cancelled'),
+        ],
+        required=True, copy=False, default='new', help='Current status of the property.'
+    )
+    active = fields.Boolean(string='Active', default=True, help='Whether the property is active and visible.')
+    property_type_id = fields.Many2one('estate.property.type', string='Property Type', help='Type or category of the property.')
+    buyer_id = fields.Many2one('res.partner', string='Buyer', copy=False, help='Partner who bought the property.')
+    sales_id = fields.Many2one('res.users', string='Salesman', default=lambda self: self.env.user, help='Salesperson responsible for the property.')
+    tag_ids = fields.Many2many('estate.property.tag', string='Tags', help='Tags to classify the property.')
+    offer_ids = fields.One2many('estate.property.offer', 'property_id', string='Offers', help='Offers made on this property.')
+
+    # -----------------------------
+    # SQL Constraints
+    # -----------------------------
+    _sql_constraints = [
+        ('check_expected_price', 'CHECK(expected_price > 0)', 'Expected price cannot be negative.')
+    ]
+
+    # -----------------------------
+    # Computed Fields
+    # -----------------------------
+    total = fields.Float(
+        string='Total (sqm)',
+        compute='_compute_total_area',
+        help='Total area of the property including living and garden areas.'
+    )
+    best_price = fields.Float(
+        string='Best Offer',
+        compute='_compute_best_price',
+        help='Highest offer price received for the property.'
+    )
+
+    @api.depends('living_area', 'garden_area')
+    def _compute_total_area(self):
+        """Compute total area as sum of living area and garden area."""
+        for record in self:
+            record.total = (record.living_area or 0) + (record.garden_area or 0)
+
+    @api.depends('offer_ids.price')
+    def _compute_best_price(self):
+        """Compute highest offer price or 0 if no offers."""
+        for record in self:
+            offer_prices = record.offer_ids.mapped('price')
+            record.best_price = max(offer_prices) if offer_prices else 0.0
+
+    # -----------------------------
+    # Action Methods
+    # -----------------------------
+    def action_sold(self):
+        """Set property state to 'sold', with validation against invalid states."""
+        for record in self:
+            if record.state == 'cancelled':
+                raise UserError('A cancelled property cannot be set as sold.')
+            elif record.state == 'sold':
+                raise UserError('Property is already sold.')
+            else:
+                record.state = 'sold'
+
+    def action_cancel(self):
+        """Set property state to 'cancelled', with validation against invalid states."""
+        for record in self:
+            if record.state == 'sold':
+                raise UserError('A sold property cannot be cancelled.')
+            elif record.state == 'cancelled':
+                raise UserError('Property is already cancelled.')
+            else:
+                record.state = 'cancelled'
+
+    # -----------------------------
+    # Constraints
+    # -----------------------------
+    @api.constrains('selling_price', 'expected_price')
+    def _check_selling_price_above_90_percent(self):
+        """
+        Validate selling price with float precision.
+        Ignores zero selling price, otherwise enforces minimum 90% threshold.
+        """
+        for record in self:
+            if float_is_zero(record.selling_price, precision_digits=2):
+                continue
+            min_acceptable_price = 0.9 * record.expected_price
+            if float_compare(record.selling_price, min_acceptable_price, precision_digits=2) < 0:
+                raise ValidationError(_(
+                    "The selling price must be at least 90%% of the expected price.\n"
+                    "Expected Price: %(expected_price).2f\nSelling Price: %(selling_price).2f",
+                    {
+                        'expected_price': record.expected_price,
+                        'selling_price': record.selling_price
+                    }
+                ))
+
+    @api.ondelete(at_uninstall=False)
+    def _check_can_be_deleted(self):
+        """
+        Restrict deletion to properties in 'new' or 'cancelled' state.
+        Raises UserError otherwise.
+        """
+        for record in self:
+            if record.state not in ['new', 'cancelled']:
+                raise UserError('You can only delete properties that are New or Cancelled.')

estate/models/estate_property_offer.py

@@ -0,0 +1,125 @@
+# Python Imports
+from datetime import timedelta
+
+# Odoo Imports
+from odoo import _, api, fields, models
+from odoo.tools import float_compare
+from odoo.exceptions import UserError
+
+
+class EstatePropertyOffer(models.Model):
+    _name = 'estate.property.offer'
+    _description = 'Estate Property Offers'
+    _order = 'price desc'
+
+    # -----------------------------
+    # SQL Constraints
+    # -----------------------------
+    _sql_constraints = [
+        ('check_offer_price', 'CHECK(price > 0)', 'Offer price cannot be negative or zero.'),
+    ]
+
+    # -----------------------------
+    # Field Declarations
+    # -----------------------------
+    price = fields.Float(string='Price', required=True, help='The offer price proposed by the partner.')
+    status = fields.Selection(
+        string='Status',
+        selection=[
+            ('accepted', 'Accepted'),
+            ('refused', 'Refused'),
+        ],
+        copy=False, help='Current status of the offer: Accepted or Refused.'
+    )
+    validity = fields.Integer(string='Validity (days)', default=7, help='Number of days this offer remains valid from the creation date.')
+    date_deadline = fields.Date(
+        string='Deadline', compute='_compute_date_deadline',
+        inverse='_inverse_date_deadline',
+        help='Deadline date until which the offer is valid.'
+    )
+    partner_id = fields.Many2one('res.partner', string='Partner', required=True, help='The partner who made this offer.')
+    property_id = fields.Many2one('estate.property', string='Property', required=True, help='The property this offer is related to.')
+    property_type_id = fields.Many2one(related='property_id.property_type_id', store=True, help='Type of the related property.')
+
+    # -----------------------------
+    # Compute / Inverse Methods
+    # -----------------------------
+    @api.depends('create_date', 'validity')
+    def _compute_date_deadline(self):
+        """
+        Compute the deadline by adding the validity period (in days) to the creation date.
+        Uses today's date if creation date is not available.
+        Sets deadline to False if validity is not set.
+        """
+        for record in self:
+            create_date = record.create_date.date() if record.create_date else fields.Date.context_today(record)
+            record.date_deadline = create_date + timedelta(days=record.validity) if record.validity else False
+
+    def _inverse_date_deadline(self):
+        """
+        Recalculate the validity period based on the difference between the deadline
+        and the creation date (or today's date if creation date is missing).
+        Validity is set to zero if no deadline is specified.
+        """
+        for record in self:
+            create_date = record.create_date.date() if record.create_date else fields.Date.context_today(record)
+            if record.date_deadline:
+                delta = record.date_deadline - create_date
+                record.validity = max(delta.days, 0)
+            else:
+                record.validity = 0
+
+    # -----------------------------
+    # CRUD Methods
+    # -----------------------------
+    @api.model_create_multi
+    def create(self, vals_list):
+        """
+        Override create to validate offer before creation:
+        - Ensure property and price are provided.
+        - Prevent creating offers lower than existing offers.
+        - Update property state if it's 'new'.
+        """
+        for vals in vals_list:
+            property_id = vals.get('property_id')
+            offer_price = vals.get('price', 0.0)
+            if not property_id or not offer_price:
+                raise UserError(_('Both property and price must be provided.'))
+
+            Property = self.env['estate.property'].browse(property_id)
+
+            for offer in Property.offer_ids:
+                if float_compare(offer_price, offer.price, precision_rounding=0.01) < 0:
+                    raise UserError(_('Cannot create an offer lower than an existing offer.'))
+
+            if Property.state == 'new':
+                Property.state = 'offer_received'
+
+        # Pass all valid vals to super
+        return super().create(vals_list)
+
+    # -----------------------------
+    # Action Methods
+    # -----------------------------
+    def action_confirm(self):
+        """
+        Confirm the offer:
+        - Set offer status to 'accepted'.
+        - Update related property status and selling details.
+        """
+        self.ensure_one()
+        for record in self:
+            record.status = 'accepted'
+            record.property_id.state = 'offer_accepted'
+            record.property_id.selling_price = record.price
+            record.property_id.buyer_id = record.partner_id
+
+        (self.property_id.offer_ids - record).write({'status': 'refused'})
+
+    def action_refuse(self):
+        """
+        Refuse the offer by setting its status to 'refused'.
+        """
+        self.ensure_one()
+        for record in self:
+            record.status = 'refused'

estate/models/estate_property_tag.py

@@ -0,0 +1,21 @@
+# Odoo Imports
+from odoo import fields, models
+
+
+class EstatePropertyTag(models.Model):
+    _name = 'estate.property.tag'
+    _description = 'Estate Property Tags'
+    _order = 'name'
+
+    # -----------------------------
+    # Fields
+    # -----------------------------
+    name = fields.Char(string='Property Tag', required=True, help='Name of the tag used to categorize or label properties.')
+    color = fields.Integer(string='Color', help='Color code used to visually distinguish this tag.')
+
+    # -----------------------------
+    # SQL Constraints
+    # -----------------------------
+    _sql_constraints = [
+        ('uniq_tag_name', 'unique(name)', 'Tag name must be unique.'),
+    ]

estate/models/estate_property_type.py

@@ -0,0 +1,36 @@
+# Odoo Imports
+from odoo import api, fields, models
+
+
+class EstatePropertyType(models.Model):
+    _name = 'estate.property.type'
+    _description = 'Estate Property Type'
+    _order = 'sequence, name'
+
+    # -----------------------------
+    # Fields
+    # -----------------------------
+    name = fields.Char(string='Property Type', required=True, help='Name of the property type (e.g., Apartment, House).')
+    property_ids = fields.One2many('estate.property', 'property_type_id', string='Properties', help='Properties categorized under this type.')
+    offer_ids = fields.One2many('estate.property.offer', 'property_type_id', string='Offers', help='Offers associated with properties of this type.')
+    sequence = fields.Integer(string='Sequence', default=10, help='Used to order property types in lists and views.')
+    offer_count = fields.Integer(string='Number of Offers', compute='_compute_offer_count', help='Total number of offers made on properties of this type.')
+
+    # -----------------------------
+    # SQL Constraints
+    # -----------------------------
+    _sql_constraints = [
+        ('uniq_property_type_name', 'UNIQUE(name)', 'Property type name must be unique.'),
+    ]
+
+    # -----------------------------
+    # Compute Function
+    # -----------------------------
+    @api.depends('offer_ids')
+    def _compute_offer_count(self):
+        """
+        Compute the total number of offers associated with this property type.
+        """
+        for record in self:
+            record.offer_count = len(record.offer_ids) if hasattr(
+                record, 'offer_ids') else 0

estate/models/inherited_user.py

@@ -0,0 +1,17 @@
+# Odoo Imports
+from odoo import fields, models
+
+
+class InheritedUser(models.Model):
+    _inherit = 'res.users'
+
+    # -----------------------------
+    # Field Declarations
+    # -----------------------------
+    property_ids = fields.One2many(
+        'estate.property',
+        'sales_id',
+        string='Properties',
+        domain=[('state', 'in', ['new', 'offer_received'])],
+        help='Properties assigned to this salesman with status New or Offer Received.'
+    )

estate/security/ir.model.access.csv

@@ -0,0 +1,5 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_estate_property,access.estate.property,model_estate_property,base.group_user,1,1,1,1
+access_estate_property_type,access.estate.property.type,model_estate_property_type,base.group_user,1,1,1,1
+access_estate_property_tag,access.estate.property.tag,model_estate_property_tag,base.group_user,1,1,1,1
+access_estate_property_offer,access.estate.property.offer,model_estate_property_offer,base.group_user,1,1,1,1