l10n.gr suite API for partners

The accountant wants every product category to carry a fixed myDATA expense category, so purchases of that category are classified the same way every time.

# Customer need: each product category books its purchases under one myDATA
# expense category, chosen once by the accountant.
# depends: ['l10n_gr_nt_aade_tables']
# The suite tables are reached through the ORM, never imported from odoo.addons.
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError


class ProductCategory(models.Model):
    _inherit = 'product.category'

    x_expense_category_id = fields.Many2one(
        'aade.expense.category', string='myDATA expense category',
        domain=[('l10n_gr_allow_null_e3', '=', False)])

    @api.constrains('x_expense_category_id')
    def _check_x_expense_category(self):
        # the domain guards the form only; imports go through this check
        for categ in self.filtered('x_expense_category_id'):
            if categ.x_expense_category_id.l10n_gr_allow_null_e3:
                raise ValidationError(_('%s is valid without an E3 code: choose a category for regular purchases.',
                                        categ.x_expense_category_id.display_name))

A customer moving from a legacy ERP needs its own cost codes mapped to the official E3 expense codes before the first purchase is booked in Odoo.

# Customer need: the legacy ERP coded costs with its own codes; before go-live,
# map each one to the E3 code the accountant chose.
# Run in odoo-bin shell from the console (env is given). x_legacy_code and
# x_expense_type_id are your own fields on product.category;
# your module's depends: ['l10n_gr_nt_aade_tables']
MAPPING = {  # legacy cost code -> E3 code, as agreed with the accountant
    'K100': 'E3_102_001',
    'K200': 'E3_102_002',
}
E3 = env['aade.expense.type']
for legacy_code, e3_code in MAPPING.items():
    e3 = E3.search([('code', '=', e3_code)], limit=1)
    if not e3:
        print('Unknown E3 code', e3_code, 'for', legacy_code)
        continue
    categs = env['product.category'].search([('x_legacy_code', '=', legacy_code)])
    categs.write({'x_expense_type_id': e3.id})
    print(legacy_code, '->', e3.display_name, '(%s categories)' % len(categs))
env.cr.commit()

A company that sells through an e-shop and through wholesale wants each sales team linked to its myDATA income category, so revenue can be reviewed per category.

# Customer need: the e-shop team and the wholesale team must be reported under
# their own myDATA income category; the accountant groups invoices by it.
# depends: ['l10n_gr_nt_aade_tables', 'sale']
# The suite tables are reached through the ORM, never imported from odoo.addons.
from odoo import fields, models


class CrmTeam(models.Model):
    _inherit = 'crm.team'

    x_income_category_id = fields.Many2one(
        'aade.income.category', string='myDATA income category',
        domain=[('l10n_gr_allow_null_e3', '=', False)])


class AccountMove(models.Model):
    _inherit = 'account.move'

    # stored, so the accountant can group and pivot invoices by it
    x_income_category_id = fields.Many2one(
        related='team_id.x_income_category_id', store=True,
        string='Team income category')

During a migration from a legacy ERP, the partner keeps a reviewable table that turns each old revenue code into a myDATA income category and E3 code.

# Customer need: migrating from a legacy ERP whose revenue codes must become a
# myDATA category + E3 code; keep the mapping as data the accountant can review.
# depends: ['l10n_gr_nt_aade_tables']  (add an ir.model.access line for acme.income.map)
from odoo import fields, models


class AcmeIncomeMap(models.Model):
    _name = 'acme.income.map'
    _description = 'Legacy revenue code to myDATA classification'

    legacy_code = fields.Char(required=True, index=True)
    category_id = fields.Many2one('aade.income.category', required=True)
    type_id = fields.Many2one('aade.income.type', string='E3 code')
    e3_code = fields.Char(related='type_id.code')

    _legacy_code_uniq = models.Constraint('UNIQUE(legacy_code)', 'One mapping per legacy code.')

    def _incomplete(self):
        # categories valid without an E3 code may go without one; all others need one
        return self.filtered(
            lambda m: not m.type_id and not m.category_id.l10n_gr_allow_null_e3)

At month end the accountant wants a dashboard with how many documents of each AADE type were issued, to cross-check against the myDATA summary.

# Customer need: the accountant's month-end dashboard counts the documents of
# each AADE type (1.1, 2.1, 11.1 ...) posted in the period.
# depends: ['l10n_gr_nt_chart_ext']  (journal field; brings l10n_gr_nt_aade_tables)
from odoo import models


class AccountMove(models.Model):
    _inherit = 'account.move'

    def acme_documents_by_type(self, date_from, date_to):
        groups = self._read_group(
            [('state', '=', 'posted'), ('company_id', '=', self.env.company.id),
             ('date', '>=', date_from), ('date', '<=', date_to),
             ('journal_id.l10n_gr_invoice_type_id', '!=', False)],
            ['journal_id'], ['__count'])
        counts = {}
        for journal, count in groups:
            # read only: never create or edit document types
            doc_type = journal.l10n_gr_invoice_type_id
            counts[doc_type] = counts.get(doc_type, 0) + count
        # keyed by record, so a type archived after posting is still counted
        return [(t.code, t.name, n) for t, n in
                sorted(counts.items(), key=lambda kv: (kv[0].sequence, kv[0].code))]

Warehouse staff transferring goods between the company's own branches should only see the movement purposes that apply to internal transfers.

# Customer need: the warehouse moves stock between the customer's own branches
# and must pick a movement purpose; offer only purposes for internal moves.
# depends: ['l10n_gr_nt_aade_tables', 'stock']  (add an ir.model.access line for the wizard)
from odoo import _, fields, models


class AcmeBranchTransfer(models.TransientModel):
    _name = 'acme.branch.transfer'
    _description = 'Transfer between own branches'

    picking_id = fields.Many2one('stock.picking', required=True)
    purpose_id = fields.Many2one(
        'aade.move.purpose', required=True,
        # the accountant sets scope and active from the UI: filter, never hard-code ids
        domain=[('scope', 'in', ('internal', 'both'))])

    def action_confirm(self):
        self.ensure_one()
        self.picking_id.message_post(
            body=_('Movement purpose: %(code)s %(name)s',
                   code=self.purpose_id.code, name=self.purpose_id.name))
        return {'type': 'ir.actions.act_window_close'}

The accountant needs the month's net sales split by myDATA VAT category to reconcile them with the periodic VAT return.

# Customer need: a monthly dashboard of sales net value per VAT category, so the
# accountant can cross-check it with the VAT return.
# depends: ['l10n_gr_nt_aade_tables']
from odoo import models


class AccountMoveLine(models.Model):
    _inherit = 'account.move.line'

    def acme_sales_by_vat_category(self, date_from, date_to):
        base_domain = [
            ('parent_state', '=', 'posted'), ('company_id', '=', self.env.company.id),
            ('move_id.move_type', 'in', ('out_invoice', 'out_refund')),
            ('date', '>=', date_from), ('date', '<=', date_to),
            ('display_type', '=', 'product')]
        result = []
        for cat in self.env['aade.vat.category'].search([]):  # ordered by code
            lines = self.search(base_domain + [('tax_ids.aade_vat_category_id', '=', cat.id)])
            if lines:
                # sales are credits: negate the balance to show positive net value
                result.append((cat.display_name, cat.percent, -sum(lines.mapped('balance'))))
        return result

A customer that buys VAT-free under a specific exemption must never get an order confirmed with a tax that cites a different exemption reason.

# Customer need: a shipping customer buys VAT-free under an exemption certificate;
# block orders whose taxes carry a different exemption reason.
# depends: ['l10n_gr_nt_aade_tables', 'sale']
from odoo import _, fields, models
from odoo.exceptions import UserError


class ResPartner(models.Model):
    _inherit = 'res.partner'

    x_vat_exemption_id = fields.Many2one('aade.vat.exemption.category', string='VAT exemption reason')


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    def action_confirm(self):
        for order in self:
            reason = order.partner_id.commercial_partner_id.x_vat_exemption_id
            if not reason:
                continue
            wrong = order.order_line.filtered(
                lambda l: not l.display_type and reason not in l.tax_ids.aade_vat_exemption_category_id)
            if wrong:
                raise UserError(_('%(lines)s: use a tax with exemption %(reason)s.',
                                  lines=', '.join(wrong.mapped('product_id.display_name')),
                                  reason=reason.display_name))
        return super().action_confirm()

A partner building the customer's own invoice layout must print the legal exemption wording that is in force today on every VAT-exempt invoice.

<!-- Customer need: a custom invoice layout must print the exemption reason with
     the current (Law 5144/2024) wording, never a repealed article. -->
<!-- depends: ['l10n_gr_nt_aade_tables', 'account'] -->
<odoo>
  <template id="acme_invoice_exemption_note" inherit_id="account.report_invoice_document">
    <xpath expr="//div[hasclass('page')]" position="inside">
      <t t-set="acme_reasons" t-value="o.invoice_line_ids.tax_ids.aade_vat_exemption_category_id"/>
      <div t-if="acme_reasons" class="mt-3 small">
        <strong>VAT exemption:</strong>
        <ul class="list-unstyled mb-0">
          <!-- l10n_gr_printed_reason() works on one record, hence the loop -->
          <li t-foreach="acme_reasons" t-as="r">
            <span t-out="r.code"/> - <span t-out="r.l10n_gr_printed_reason()"/>
          </li>
        </ul>
      </div>
    </xpath>
  </template>
</odoo>

The purchasing team wants to see on each freelancer's bill how much will be withheld, using the official AADE withholding code and rate.

# Customer need: purchasing wants freelancers' service bills to show the expected
# withholding before the accountant posts them (preview only; the withholding
# itself is applied by the suite's tax at payment).
# depends: ['l10n_gr_nt_aade_tables']
from odoo import api, fields, models


class ResPartner(models.Model):
    _inherit = 'res.partner'

    x_withheld_tax_id = fields.Many2one('aade.withheld.tax', string='Usual withholding')


class AccountMove(models.Model):
    _inherit = 'account.move'

    x_expected_withholding = fields.Monetary(compute='_compute_x_expected_withholding')

    @api.depends('commercial_partner_id.x_withheld_tax_id', 'amount_untaxed', 'move_type', 'currency_id')
    def _compute_x_expected_withholding(self):
        for move in self:
            wht = move.commercial_partner_id.x_withheld_tax_id
            if not wht or move.move_type != 'in_invoice':
                move.x_expected_withholding = 0.0
            elif wht.fixed_amount:  # value is an amount, not a rate
                move.x_expected_withholding = wht.value
            else:
                move.x_expected_withholding = move.currency_id.round(move.amount_untaxed * wht.value / 100)

After a migration, the partner wants a weekly check that flags any VAT tax without a myDATA VAT category before invoices using it reach the filing deadline.

# Customer need: after a migration some VAT taxes were created by hand; every week
# before the filing deadline, flag VAT taxes still missing a myDATA VAT category.
# Scheduled action (ir.cron), Python code on model account.tax;
# module installed: l10n_gr_nt_aade_tables. Server-action code takes no imports.
missing = model.search([
    ('company_id', 'in', env.companies.ids),
    ('mydata_type', '=', '0'),
    ('type_tax_use', 'in', ('sale', 'purchase')),
    ('aade_vat_category_id', '=', False),
])
if missing:
    used = env['account.move.line'].search_count(
        [('tax_ids', 'in', missing.ids), ('parent_state', '=', 'posted')])
    log('VAT taxes without myDATA VAT category: %s (on %s posted lines)'
        % (', '.join(missing.mapped('name')), used), level='warning')
# Fix from the tax form; for category 7 (exempt) set aade_vat_exemption_category_id
# in the same write, or the suite's constraint rejects it.

An exporting company's accountant needs each quarter's VAT-exempt sales totalled per exemption reason to match the VAT return.

# Customer need: an exporter's accountant reconciles exempt sales per exemption
# reason with the VAT return each quarter.
# depends: ['l10n_gr_nt_aade_tables']
from odoo import models


class AccountMoveLine(models.Model):
    _inherit = 'account.move.line'

    def acme_exempt_sales_by_reason(self, date_from, date_to):
        lines = self.search([
            ('parent_state', '=', 'posted'), ('company_id', '=', self.env.company.id),
            ('move_id.move_type', 'in', ('out_invoice', 'out_refund')),
            ('date', '>=', date_from), ('date', '<=', date_to),
            ('tax_ids.aade_vat_exemption_category_id', '!=', False)])
        totals = {}
        for line in lines:
            for reason in line.tax_ids.aade_vat_exemption_category_id:
                totals[reason] = totals.get(reason, 0.0) - line.balance
        return [(r.code, r.l10n_gr_printed_reason(), amount)
                for r, amount in sorted(totals.items(), key=lambda kv: kv[0].code)]

The collections team needs a list of posted invoices that carry a withholding tax, so it can request the withholding certificate from each client.

# Customer need: collections must chase the client's withholding certificate for
# every invoice that carries a withholding tax; give them a filter for it.
# depends: ['l10n_gr_nt_aade_tables']
from odoo import api, fields, models


class AccountMove(models.Model):
    _inherit = 'account.move'

    x_has_withholding = fields.Boolean(
        compute='_compute_x_has_withholding', store=True, string='Has withholding')

    @api.depends('invoice_line_ids.tax_ids.mydata_type')
    def _compute_x_has_withholding(self):
        for move in self:
            # '1' = Withholding Tax in the myDATA tax family
            move.x_has_withholding = any(
                t.mydata_type == '1' for t in move.invoice_line_ids.tax_ids)

# In a search view: <filter name="withholding" string="With withholding"
#     domain="[('x_has_withholding', '=', True), ('state', '=', 'posted')]"/>

A supplier to hospitals and ministries wants every public-sector invoice to create a payment follow-up for the collections team, because public bodies pay late.

# Customer need: public bodies pay late; every posted B2G invoice gets a
# follow-up activity for the collections team 60 days after the invoice date.
# depends: ['l10n_gr_nt_b2g']
from datetime import timedelta

from odoo import _, models


class AccountMove(models.Model):
    _inherit = 'account.move'

    def _post(self, soft=True):
        posted = super()._post(soft=soft)
        for move in posted.filtered('b2g'):
            move.activity_schedule(
                'mail.mail_activity_data_todo',
                date_deadline=(move.invoice_date or move.date) + timedelta(days=60),
                summary=_('Check payment by the public body'),
                user_id=move.invoice_user_id.id or self.env.uid)
        return posted

A hospital supplier must capture the buyer reference the hospital gives on every order, so the invoice is not blocked at posting.

# Customer need: hospitals give a department/requisition reference with each
# order; it must reach the invoice, which cannot be posted without it.
# depends: ['l10n_gr_nt_b2g', 'sale']
from odoo import _, models
from odoo.exceptions import UserError


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    def action_confirm(self):
        for order in self:
            if (order.partner_id.commercial_partner_id.b2g_party_identification
                    and not order.client_order_ref):
                raise UserError(_('%s is for a public body: fill in the customer reference.', order.name))
        return super().action_confirm()

    def _prepare_invoice(self):
        vals = super()._prepare_invoice()
        if self.client_order_ref:
            vals['b2g_buyer_reference'] = self.client_order_ref
        return vals

A company that wins public tenders wants the contract's ΑΔΑΜ entered once on the order and carried to every invoice issued under it.

# Customer need: tenders produce a contract with an ΑΔΑΜ; sales enter it once on
# the order and every invoice of the order carries it (0 when there is none).
# depends: ['l10n_gr_nt_b2g', 'sale']
from odoo import fields, models


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    x_adam = fields.Char(
        string='Contract ΑΔΑΜ', copy=False,
        help='Leave empty when the sale has no contract; the invoice then gets 0.')

    def _prepare_invoice(self):
        vals = super()._prepare_invoice()
        vals['b2g_contract_document_reference'] = (self.x_adam or '0').strip().upper()
        return vals

A supplier to a ministry with several contracting authorities under one tax number needs each invoice to carry the authority code of the delivery address.

# Customer need: one ministry (one tax number) has several contracting
# authorities; each delivery address carries its own code, and the invoice must
# use the code of the address the goods went to.
# depends: ['l10n_gr_nt_b2g', 'sale']
from odoo import models


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    def _prepare_invoice(self):
        vals = super()._prepare_invoice()
        # the company partner keeps its own code too: that is what marks the move as B2G
        code = self.partner_shipping_id.b2g_party_identification
        if code:
            vals['b2g_party_identification'] = code
        return vals

A partner importing a list of public-body customers must clean the authority codes, which often contain Greek look-alike letters, before the field accepts them.

# Customer need: importing public-body customers from a tender list where codes
# were typed with Greek letters that look Latin (Ε, Ο, Α ...); normalise first,
# because the field accepts only Latin capitals, digits and dots.
# Run in odoo-bin shell from the console (env is given); module installed: l10n_gr_nt_b2g
import re

GREEK_TO_LATIN = str.maketrans('ΑΒΕΖΗΙΚΜΝΟΡΤΥΧ', 'ABEZHIKMNOPTYX')
rows = [  # (tax number, authority code) as received
    ('094000001', '1032.Ε00400.0001'),
    ('094000002', '1045.e00210.0003'),
]
for vat, raw in rows:
    code = raw.strip().upper().translate(GREEK_TO_LATIN)
    if not re.fullmatch(r'[A-Z0-9.]+', code):
        print('Skipped, still invalid:', raw)
        continue
    partner = env['res.partner'].search(
        [('vat', 'in', (vat, 'EL' + vat)), ('is_company', '=', True)], limit=1)
    if partner:
        partner.b2g_party_identification = code
    else:
        print('No customer with tax number', vat)
env.cr.commit()

A business that sells both goods and services wants service-only orders invoiced automatically from the Service Invoice series.

# Customer need: a company that sells goods and services must issue service-only
# orders as Service Invoices (2.1) from that series, not the goods series.
# depends: ['l10n_gr_nt_chart_ext', 'sale']
from odoo import models


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    def _prepare_invoice(self):
        vals = super()._prepare_invoice()
        lines = self.order_line.filtered(lambda l: not l.display_type)
        if lines and all(l.product_id.type == 'service' for l in lines):
            # read only: the document type is set on the journal form, never from code
            journal = self.env['account.journal'].search([
                ('company_id', '=', self.company_id.id), ('type', '=', 'sale'),
                ('l10n_gr_invoice_type_id.code', '=', '2.1')], limit=1)
            if journal:
                vals['journal_id'] = journal.id
        return vals

A beverage distributor needs the recycling fees it collected each month, net of credit notes, to file its monthly fee declaration.

# Customer need: a beverage distributor declares the recycling fees it collected
# each month; the accountant wants the monthly totals, credit notes deducted.
# depends: ['l10n_gr_nt_chart_ext']
from odoo import models


class AccountMove(models.Model):
    _inherit = 'account.move'

    def acme_fees_by_month(self, year):
        domain = [
            ('company_id', '=', self.env.company.id), ('state', '=', 'posted'),
            ('move_type', 'in', ('out_invoice', 'out_refund')),
            ('invoice_date', '>=', f'{year}-01-01'), ('invoice_date', '<=', f'{year}-12-31'),
            ('l10n_gr_fees_total', '!=', 0)]
        result = {}
        for month, move_type, total in self._read_group(
                domain, ['invoice_date:month', 'move_type'], ['l10n_gr_fees_total:sum']):
            sign = -1 if move_type == 'out_refund' else 1
            result[month] = result.get(month, 0.0) + sign * total
        return result

A company with a passenger-car fleet wants to stop vendor bills for fuel or rentals from being posted with deductible VAT.

# Customer need: fuel and rentals for passenger cars carry non-deductible VAT;
# stop a vendor bill from being posted with deductible VAT on such costs.
# depends: ['l10n_gr_nt_chart_ext']
from odoo import _, fields, models
from odoo.exceptions import UserError


class ProductCategory(models.Model):
    _inherit = 'product.category'

    x_passenger_car_cost = fields.Boolean(string='Passenger car cost')


class AccountMove(models.Model):
    _inherit = 'account.move'

    def action_post(self):
        for move in self.filtered(lambda m: m.move_type in ('in_invoice', 'in_refund')):
            wrong = move.invoice_line_ids.filtered(
                lambda l: l.product_id.categ_id.x_passenger_car_cost
                and l.tax_ids.filtered(lambda t: t.mydata_type == '0' and t.l10n_gr_deductible))
            if wrong:
                raise UserError(_('%(bill)s: use the non-deductible VAT on %(lines)s.',
                                  bill=move.display_name,
                                  lines=', '.join(wrong.mapped('product_id.display_name'))))
        return super().action_post()

During a product migration the partner needs each legacy VAT code mapped to the right sale and purchase tax, even if users have renamed the taxes.

# Customer need: migrating products from a legacy ERP whose VAT codes are 1/2/3;
# map them to taxes by localization code, not by name (users rename taxes).
# Run in odoo-bin shell from the console (env is given); module installed: l10n_gr_nt_chart_ext
LEGACY_TO_CODES = {  # legacy VAT code -> (sale tax code, purchase tax code)
    '1': ('VAT-S-24', 'VAT-P-24'),
    '2': ('VAT-S-13', 'VAT-P-13'),
    '3': ('VAT-S-6', 'VAT-P-6'),
}
Tax = env['account.tax']
company_domain = Tax._check_company_domain(env.company)
products = [('ACME-001', '1'), ('ACME-002', '2')]  # (internal reference, legacy VAT code)
for ref, legacy in products:
    sale_code, purchase_code = LEGACY_TO_CODES[legacy]
    sale_tax = Tax.search([*company_domain, ('l10n_gr_tax_code', '=', sale_code)], limit=1)
    purchase_tax = Tax.search([*company_domain, ('l10n_gr_tax_code', '=', purchase_code)], limit=1)
    product = env['product.template'].search([('default_code', '=', ref)], limit=1)
    if product and sale_tax and purchase_tax:
        product.write({'taxes_id': [(6, 0, sale_tax.ids)],
                       'supplier_taxes_id': [(6, 0, purchase_tax.ids)]})
    else:
        print('Not mapped:', ref, legacy)
env.cr.commit()

Before go-live the partner wants a reminder listing every per-unit fee the accountant has not yet verified, with how many products use it.

# Customer need: before go-live the accountant confirms every per-unit fee
# (amount, AADE code, account); list the fees nobody has verified yet.
# Scheduled action (ir.cron), Python code on model l10n_gr.fee;
# module installed: l10n_gr_nt_chart_ext. Server-action code takes no imports.
unverified = model.search([
    ('company_id', 'in', env.companies.ids),
    ('l10n_gr_verified', '=', False),
])
for fee in unverified:
    used_by = env['product.template'].search_count([('l10n_gr_fee_id', '=', fee.id)])
    log('Fee "%s" (%s %s, %s) not verified, used by %s products' % (
        fee.name, fee.amount, 'per unit' if fee.per_unit else '% of net value',
        fee.company_id.name, used_by), level='warning')
# Read only here: the suite manages tax_id and l10n_gr_tax_group_id of each fee.

A beverage distributor importing its supplier catalogue needs every plastic-bottle product to carry the recycling fee automatically.

# Customer need: the supplier catalogue marks which items are plastic bottles;
# those products must carry the company's recycling fee from the first sale.
# Run in odoo-bin shell from the console (env is given); module installed: l10n_gr_nt_chart_ext
company = env.company
fee = env['l10n_gr.fee'].search([
    ('company_id', '=', company.id), ('l10n_gr_tax_type', '=', 'fees_category'),
    ('name', 'ilike', 'recycl')], limit=1)
assert fee, 'Create the recycling fee for %s first' % company.name
catalogue = [('BTL-500', True), ('BTL-1500', True), ('CAN-330', False)]  # (reference, plastic bottle)
refs = [ref for ref, plastic in catalogue if plastic]
# the fee belongs to one company: link it only to that company's (or shared) products
products = env['product.template'].search([
    ('default_code', 'in', refs), ('company_id', 'in', (company.id, False))])
products.write({'l10n_gr_fee_id': fee.id})
print('%s products now carry %s' % (len(products), fee.name))
env.cr.commit()

A retailer that also sells installation services needs those services classified as services income in myDATA, although they share the goods' income account.

# Customer need: installation services post to the same income account as the
# goods, but myDATA wants them as services income (category1_3); override only them.
# Run in odoo-bin shell from the console (env is given); module installed: l10n_gr_nt_chart_ext
services = env['aade.income.category'].search([('code', '=', 'category1_3')], limit=1)
assert services, 'category1_3 not found'
products = env['product.template'].search([
    ('type', '=', 'service'),
    ('categ_id.name', '=', 'Installation'),
    ('l10n_gr_income_category_id', '=', False),  # keep any override already set
])
products.write({'l10n_gr_income_category_id': services.id})
print('%s installation services now classified as %s' % (len(products), services.display_name))
# Empty override = the income account's classification, right for every other product.
env.cr.commit()

A wholesaler on an island migrating its customers needs the reduced island VAT status carried over only for the customers that qualify.

# Customer need: a wholesaler on Rhodes migrates customers from its old ERP,
# which flagged island businesses; carry the flag so the reduced rate applies
# only to those customers.
# Run in odoo-bin shell from the console (env is given); module installed: l10n_gr_nt_chart_ext
LEGACY_STATUS = {'N': 'normal', 'I': 'taxable', 'L': 'legal_person'}
rows = [('094000001', 'I'), ('094000002', 'N'), ('094000003', 'L')]  # (tax number, legacy flag)
Partner = env['res.partner']
for vat, flag in rows:
    partner = Partner.search([('vat', 'in', (vat, 'EL' + vat))], limit=1).commercial_partner_id
    if not partner:
        print('Not found:', vat)
        continue
    # commercial field: set it on the company, Odoo copies it to its addresses
    partner.l10n_gr_reduced_vat_status = LEGACY_STATUS[flag]
env.cr.commit()

A seller of Article 45 goods wants quotations to qualifying buyers to state up front that VAT on those goods will be reverse charged.

<!-- Customer need: quotations to Article 45 buyers must tell the buyer that the
     VAT of Article 45 goods is reverse charged, before the invoice arrives. -->
<!-- depends: ['l10n_gr_nt_chart_ext', 'sale'] -->
<odoo>
  <template id="acme_quote_art45_note" inherit_id="sale.report_saleorder_document">
    <xpath expr="//div[hasclass('page')]" position="inside">
      <p t-if="doc.partner_id.commercial_partner_id.l10n_gr_vat45_buyer" class="mt-3 small">
        Article 45 goods on this quotation are invoiced with reverse charge of VAT;
        the other goods keep their VAT.
      </p>
    </xpath>
  </template>
</odoo>

A company moving to the new chart of accounts needs its opening balances, exported from the old ERP by old account code, booked on the matching new accounts.

# Customer need: opening balances come from the old ERP keyed by the old ΕΓΛΣ
# codes; book them as one draft opening entry on the new accounts.
# Run in odoo-bin shell from the console (env is given); module installed: l10n_gr_nt_chart_import
from odoo import Command, fields

balances = [('38.00.00', 1520.40), ('38.03.00', 820.40), ('40.00.00', -2340.80)]  # (old code, debit - credit)
Account = env['account.account']
lines, missing = [], []
for old_code, amount in balances:
    acc = Account.search([('company_ids', 'in', env.company.id),
                          ('l10n_gr_legacy_code', '=', old_code)], limit=1)
    if not acc:
        missing.append(old_code)
        continue
    lines.append(Command.create({'account_id': acc.id, 'name': 'Opening balance',
                                 'debit': max(amount, 0.0), 'credit': max(-amount, 0.0)}))
assert not missing, 'No account for old codes: %s' % missing
journal = env['account.journal'].search([('type', '=', 'general'), ('company_id', '=', env.company.id)], limit=1)
move = env['account.move'].create({
    'move_type': 'entry', 'journal_id': journal.id, 'date': fields.Date.to_date('2027-01-01'),
    'ref': 'Opening balances from legacy ERP', 'line_ids': lines})
print('Draft opening entry', move.id, '- the accountant reviews and posts it')
env.cr.commit()

A trader whose EU supplier ships directly to an EU customer needs those sales marked as triangular so they land in the right column of the recapitulative statement.

# Customer need: a Greek trader buys from an Italian supplier and the goods ship
# straight to a German customer; those invoices go to column 6 of the VIES statement.
# depends: ['l10n_gr_nt_ec_purchase', 'sale']
from odoo import fields, models


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    x_triangular = fields.Boolean(
        string='Triangular (shipped from another EU state)', copy=False,
        help="Set when the goods travel from the supplier's EU state straight to the customer.")

    def _prepare_invoice(self):
        vals = super()._prepare_invoice()
        eu = self.env.ref('base.europe').country_ids
        country = self.partner_id.commercial_partner_id.country_id
        # posting also needs an intra-EU tax on the lines: use the EU fiscal position
        vals['l10n_gr_triangular'] = bool(
            self.x_triangular and country in eu and country.code != 'GR')
        return vals

A small business under the VAT exemption regime must not confirm any order that still charges VAT on a line.

# Customer need: a VAT-exempt small business must never charge VAT; stop an
# order that still carries a VAT tax on any line.
# depends: ['l10n_gr_nt_guard_partner_rule', 'sale']
from odoo import _, models
from odoo.exceptions import UserError


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    def action_confirm(self):
        for order in self.filtered(lambda o: o.company_id.l10n_gr_vat_exempt_small_entity):
            taxed = order.order_line.filtered(
                lambda l: l.tax_ids.filtered(lambda t: t.mydata_type == '0' and t.amount))
            if taxed:
                raise UserError(_('%(company)s is a VAT-exempt small business: remove VAT from %(lines)s.',
                                  company=order.company_id.name,
                                  lines=', '.join(taxed.mapped('product_id.display_name'))))
        return super().action_confirm()

The customer's invoice that also serves as delivery note prints the delivery-note number, the vehicle and the current delivery status.

<!-- depends: ['l10n_gr_nt_movement'] -->
<!-- Customer need: the printed invoice that is also the delivery note shows the note, the truck and where the goods are -->
<template id="report_invoice_acme_movement" inherit_id="account.report_invoice_document">
    <xpath expr="//div[@id='informations']" position="inside">
        <t t-set="movement" t-value="o.l10n_gr_movement_id"/>
        <div class="col" t-if="movement" name="acme_movement">
            <strong>Delivery note</strong>
            <div t-field="movement.name"/>
            <div t-if="movement.current_vehicle_id">
                Vehicle: <span t-field="movement.current_vehicle_id.license_plate"/>
            </div>
            <div t-if="movement.status_id">
                Status: <span t-field="movement.status_id"/>
            </div>
        </div>
    </xpath>
</template>

A warehouse system stores its own shipment reference on every delivery note and pulls the notes that are still open.

# depends: ['l10n_gr_nt_movement']
# Customer need: the 3PL's WMS keeps its own shipment reference on each delivery note
# The l10n.gr API is reached through the ORM (_inherit), never by importing from odoo.addons.l10n_gr_*
from odoo import api, fields, models


class L10nGrMovement(models.Model):
    _inherit = 'l10n_gr.movement'

    acme_wms_ref = fields.Char(string='WMS Shipment', copy=False, index=True)

    @api.model
    def acme_open_issued(self, company):
        """Issued delivery notes not yet final, for the WMS sync (2 cancelled and 8 completed are final)."""
        return self.search([
            ('company_id', '=', company.id),
            ('role', '=', 'issuer'),
            ('status_id.code', 'not in', (2, 8)),
        ], order='id desc')

Received delivery notes whose lines carry the supplier's old ERP codes are matched to the right products automatically.

# depends: ['l10n_gr_nt_movement']
# Customer need: suppliers still print the item codes of the old ERP; match them before the standard rules
from odoo import fields, models


class ProductTemplate(models.Model):
    _inherit = 'product.template'

    acme_legacy_code = fields.Char(string='Legacy ERP Code', index=True)


class L10nGrMovement(models.Model):
    _inherit = 'l10n_gr.movement'

    def _l10n_gr_match_product(self, code, name):
        self.ensure_one()
        if code:
            product = self.env['product.product'].search([
                ('acme_legacy_code', '=', code.strip()),
                ('company_id', 'in', (False, self.company_id.id)),
            ], limit=1)
            if product:
                return product
        # standard order: supplier code, barcode, internal reference, exact name
        return super()._l10n_gr_match_product(code, name)

An external WMS or EDI hub is notified as soon as a delivery is completed, fails or starts returning.

# depends: ['l10n_gr_nt_movement']
# Customer need: the 3PL's WMS is told at once when a delivery fails, completes or returns
import logging

import requests

from odoo import models

_logger = logging.getLogger(__name__)

NOTIFY = {7: 'failed', 8: 'completed', 9: 'returning'}


class L10nGrMovement(models.Model):
    _inherit = 'l10n_gr.movement'

    def _l10n_gr_on_status_change(self, old, new):
        super()._l10n_gr_on_status_change(old, new)  # the suite's own reactions first
        url = self.env['ir.config_parameter'].sudo().get_param('acme.wms_webhook_url')
        if self.role != 'issuer' or new not in NOTIFY or not url:
            return
        try:  # the declaration is already made: never raise from here
            with self.env.cr.savepoint():
                requests.post(url, timeout=10, json={
                    'delivery_note': self.name, 'picking': self.picking_id.name, 'event': NOTIFY[new],
                }).raise_for_status()
        except Exception:
            _logger.exception('WMS notification failed for %s', self.name)

A dispatch screen counts the deliveries still on the road per truck of the company's fleet.

# depends: ['l10n_gr_nt_movement']
# Customer need: the dispatcher sees how many deliveries each truck is still carrying
from odoo import api, models


class L10nGrMovement(models.Model):
    _inherit = 'l10n_gr.movement'

    @api.model
    def acme_loads_per_vehicle(self):
        groups = self._read_group(
            [('role', '=', 'issuer'),
             ('status_id.code', '=', 3),  # in transit
             ('current_vehicle_id', '!=', False),
             ('company_id', 'in', self.env.companies.ids)],
            groupby=['current_vehicle_id'],
            aggregates=['__count'],
        )
        return [{'plate': vehicle.license_plate, 'deliveries': count} for vehicle, count in groups]

Management tracks on-time delivery by comparing when goods were handed over with the planned date of the transfer.

# depends: ['l10n_gr_nt_movement']
# Customer need: a punctuality report of deliveries handed over more than a day after the planned date
from datetime import timedelta

from odoo import api, fields, models


class L10nGrMovement(models.Model):
    _inherit = 'l10n_gr.movement'

    acme_late = fields.Boolean(string='Late Delivery', compute='_compute_acme_late', store=True)

    @api.depends('delivered_at', 'status_id', 'picking_id.scheduled_date')
    def _compute_acme_late(self):
        for movement in self:
            planned = movement.picking_id.scheduled_date
            # delivered_at is also set by a failed delivery: count only goods handed over (5, 8)
            movement.acme_late = bool(
                planned and movement.delivered_at
                and movement.status_id.code in (5, 8)
                and movement.delivered_at > planned + timedelta(days=1)
            )

The logistics manager receives a monthly report of full, partial and failed deliveries per driver.

# depends: ['l10n_gr_nt_movement']
# Customer need: a monthly driver report of confirmed delivery outcomes (full, partial, failed)
# Events are read only (the suite and the driver device write them): the report lives on the movement
from dateutil.relativedelta import relativedelta

from odoo import api, models


class L10nGrMovement(models.Model):
    _inherit = 'l10n_gr.movement'

    @api.model
    def acme_driver_month(self, month_start):
        groups = self.env['l10n_gr.movement.event']._read_group(
            [('state', '=', 'confirmed'),
             ('outcome', '!=', False),
             ('local_ts', '>=', month_start),
             ('local_ts', '<', month_start + relativedelta(months=1))],
            groupby=['user_id', 'outcome'],
            aggregates=['__count'],
        )
        report = {}
        for user, outcome, count in groups:
            report.setdefault(user.name or '-', {'FULL': 0, 'PARTIAL': 0, 'NONE': 0})[outcome] = count
        return report

The e-shop's shipping email gives the buyer a link to follow the delivery, only when such a link exists.

<!-- depends: ['l10n_gr_nt_movement'] -->
<!-- Customer need: the e-shop's 'order shipped' email carries the delivery tracking link when there is one -->
<record id="mail_template_acme_shipped" model="mail.template">
    <field name="name">Acme: order shipped</field>
    <field name="model_id" ref="stock.model_stock_picking"/>
    <field name="subject">Your order {{ object.origin }} is on its way</field>
    <field name="email_to">{{ object.partner_id.email }}</field>
    <field name="body_html" type="html">
<div>
    <p>Dear <t t-out="object.partner_id.name"/>,</p>
    <p>Your order <t t-out="object.origin"/> has left our warehouse.</p>
    <!-- empty until the suite has created the access token: never send a blank link -->
    <t t-set="track" t-value="object.l10n_gr_movement_id.l10n_gr_track_url"/>
    <p t-if="track">Follow the delivery: <a t-att-href="track">track your order</a></p>
</div>
    </field>
</record>

Sales staff see on each sales order the AADE status of its deliveries without opening the transfers.

# depends: ['l10n_gr_nt_movement', 'sale_stock']
# Customer need: sales staff see on the order whether the goods have reached the customer
from odoo import fields, models


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    acme_delivery_status = fields.Char(string='Delivery Status', compute='_compute_acme_delivery_status')

    def _compute_acme_delivery_status(self):
        # search movements by transfer: picking.l10n_gr_movement_id is not stored
        movements = self.env['l10n_gr.movement'].search([
            ('role', '=', 'issuer'),
            ('picking_id', 'in', self.picking_ids.ids),
        ], order='id desc')
        for order in self:
            mine = movements.filtered(lambda m: m.picking_id in order.picking_ids)
            order.acme_delivery_status = ', '.join(mine.mapped('status_id.name')) or False

Vehicles kept in the Fleet app are created or archived as movement vehicles automatically.

# depends: ['l10n_gr_nt_movement', 'fleet']
# Customer need: trucks registered in Fleet become movement vehicles without retyping the plate
from odoo import fields, models


class FleetVehicle(models.Model):
    _inherit = 'fleet.vehicle'

    acme_movement_vehicle_id = fields.Many2one('l10n_gr.movement.vehicle', copy=False, readonly=True)

    def acme_sync_movement_vehicle(self):
        Vehicle = self.env['l10n_gr.movement.vehicle'].with_context(active_test=False)
        for car in self.filtered('license_plate'):
            company = car.company_id or self.env.company
            # the register stores plates in capitals without spaces or dashes
            plate = car.license_plate.upper().replace(' ', '').replace('-', '')
            vehicle = Vehicle.search([('license_plate', '=', plate), ('company_id', '=', company.id)], limit=1)
            if not vehicle:
                vehicle = Vehicle.create({'license_plate': plate, 'company_id': company.id})
            vehicle.active = car.active  # archive, never delete: past events refer to it
            car.acme_movement_vehicle_id = vehicle

The office gets an end-of-day summary of loaded, sold, returned and remaining quantities on each van-sales route.

# depends: ['l10n_gr_nt_movement']
# Customer need: at the end of the day the office sees what is still on the van, per product
from markupsafe import Markup

from odoo import _, models


class StockPickingBatch(models.Model):
    _inherit = 'stock.picking.batch'

    def acme_post_van_stock(self):
        for route in self.filtered(lambda r: r.l10n_gr_route_kind == 'van_sales'):
            lines = self.env['l10n_gr.route.load.line'].search([('batch_id', '=', route.id)])
            rows = [
                _('%(product)s: loaded %(loaded)s, sold %(sold)s, returned %(ret)s, on van %(left)s %(uom)s',
                  product=line.product_id.display_name, loaded=line.quantity, sold=line.sold_qty,
                  ret=line.returned_qty, left=line.available_qty, uom=line.uom_id.name)
                for line in lines if line.available_qty
            ]
            body = Markup('<br/>').join(rows) if rows else _('Nothing left on the van.')
            route.message_post(body=body)

A planning module creates distribution routes from the day's ready deliveries, so the suite issues one delivery note per stop.

# depends: ['l10n_gr_nt_movement']
# Customer need: the route planner turns the day's ready deliveries into a distribution route in one click
from odoo import Command, _, models
from odoo.exceptions import UserError


class StockPicking(models.Model):
    _inherit = 'stock.picking'

    def acme_create_distribution_route(self):
        pickings = self.filtered(
            lambda p: p.picking_type_code == 'outgoing' and p.state == 'assigned' and not p.batch_id)
        if not pickings:
            raise UserError(_('No ready deliveries to plan.'))
        if len(pickings.company_id) > 1:
            raise UserError(_('Plan one company at a time.'))
        # set the kind at creation; never change it once the route is loaded
        return self.env['stock.picking.batch'].create({
            'l10n_gr_route_kind': 'distribution',
            'company_id': pickings.company_id.id,
            'picking_ids': [Command.set(pickings.ids)],
        })

An EDI despatch advice sent to a retail chain includes the delivery-note number and status of the transfer.

# depends: ['l10n_gr_nt_movement']
# Customer need: the supermarket chain's EDI despatch advice must carry the AADE delivery-note number
from odoo import models


class StockPicking(models.Model):
    _inherit = 'stock.picking'

    def acme_edi_desadv_payload(self):
        self.ensure_one()
        movement = self.l10n_gr_movement_id  # computed, not stored: read it, never search on it
        return {
            'despatch_number': self.name,
            'order_reference': self.origin,
            'delivery_note': movement.name or None,
            'aade_status': movement.status_id.code or None,
            'vehicle': movement.current_vehicle_id.license_plate or None,
            'lines': [
                {'gtin': m.product_id.barcode, 'qty': m.quantity, 'uom': m.product_uom.name}
                for m in self.move_ids
            ],
        }

Each van-sales route shows how many sales were completed at its stops, for comparison between routes.

# depends: ['l10n_gr_nt_movement']
# Customer need: the sales manager compares how many stops each van-sales route actually served
from odoo import fields, models


class StockPickingBatch(models.Model):
    _inherit = 'stock.picking.batch'

    acme_stop_count = fields.Integer(string='Stops Served', compute='_compute_acme_stop_count')

    def _compute_acme_stop_count(self):
        # stops are linked through l10n_gr_route_id, not as members of the batch
        counts = dict(self.env['stock.picking']._read_group(
            [('l10n_gr_route_id', 'in', self.ids), ('state', '=', 'done')],
            groupby=['l10n_gr_route_id'],
            aggregates=['__count'],
        ))
        for route in self:
            route.acme_stop_count = counts.get(route, 0)

A daily check flags deliveries whose proof was signed far from the customer's address or without a device position.

# depends: ['l10n_gr_nt_movement_mobile']
# Customer need: the logistics manager reviews deliveries signed far from the address or without a position
# Proofs are read only (the driver device creates them): the check lives on the movement
from datetime import timedelta

from odoo import _, api, fields, models


class L10nGrMovement(models.Model):
    _inherit = 'l10n_gr.movement'

    @api.model
    def _cron_acme_flag_far_deliveries(self, max_distance=500):
        proofs = self.env['l10n_gr.movement.proof'].search([
            ('local_ts', '>=', fields.Datetime.now() - timedelta(days=1)),
            '|', ('without_position', '=', True), ('distance_m', '>', max_distance),
        ])
        for proof in proofs:
            where = _('no position') if proof.without_position else _('%s m from the address', proof.distance_m)
            proof.movement_id.activity_schedule(
                'mail.mail_activity_data_todo',
                summary=_('Check delivery proof'),
                note=_('Signed by %(name)s, %(where)s.', name=proof.signer_name or '-', where=where),
                user_id=proof.movement_id.picking_id.user_id.id or self.env.user.id,
            )

The dispatch module assigns each route to a specific driver so that only that driver sees it on the device.

# depends: ['l10n_gr_nt_movement_mobile']
# Customer need: dispatch assigns each route to the driver on shift before the van leaves
from odoo import _, models
from odoo.exceptions import UserError


class StockPickingBatch(models.Model):
    _inherit = 'stock.picking.batch'

    def acme_assign_driver(self, employee):
        for route in self:
            if not route.l10n_gr_route_kind:
                raise UserError(_('%s is not a route.', route.name))
            if employee.company_id != route.company_id:
                raise UserError(_('%(driver)s does not work for %(company)s.',
                                  driver=employee.name, company=route.company_id.name))
        # only this driver sees the routes on the driver device
        self.l10n_gr_driver_id = employee

Expense accounts the partner adds for the customer are linked at install time to the right line of the tax add-back statement.

# depends: ['l10n_gr_nt_mydata_adjust']
# Customer need: the customer's own entertainment sub-accounts feed line 2011 of the tax add-back statement
# __manifest__.py: 'post_init_hook': 'post_init_hook'


def post_init_hook(env):
    kfa_line = env['l10n_gr.kfa.line'].search([('code', '=', '2011'), ('is_total', '=', False)], limit=1)
    if not kfa_line:
        return
    accounts = env['account.account'].search([
        ('code', '=like', '64.98.05.%'),  # the customer's entertainment sub-accounts
        ('l10n_gr_kfa_line_id', '=', False),
    ])
    # applies to add-back entries created from now on, not to entries already posted
    accounts.write({'l10n_gr_kfa_line_id': kfa_line.id})

A scheduled check refreshes the E3-against-myDATA comparison and gives the accountant a to-do when the return would be refused.

# depends: ['l10n_gr_nt_mydata_adjust']
# Customer need: before the income tax return, the accountant is warned when books and myDATA disagree
from odoo import _, api, fields, models


class ResCompany(models.Model):
    _inherit = 'res.company'

    @api.model
    def _cron_acme_e3_watch(self):
        accountants = self.env.ref('account.group_account_manager').all_user_ids
        checks = self.env['l10n_gr.e3.check'].search([('year', '=', fields.Date.today().year - 1)])
        for check in checks:
            check.action_refresh()
            expense_judged = not check.expense_pending_aade
            if not (check.income_breach or (expense_judged and check.expense_breach)):
                continue
            user = accountants.filtered(lambda u: check.company_id in u.company_ids)[:1]
            # settlement entries stay with the accountant, from the screen
            check.company_id.partner_id.activity_schedule(
                'mail.mail_activity_data_todo',
                summary=_('E3 vs myDATA %s', check.year),
                note=check.status,
                user_id=(user or self.env.user).id,
            )

During migration, the legacy ERP's mapping of expense accounts to add-back lines is loaded by line code.

# odoo-bin shell snippet, run through the console (staging first)
# depends: ['l10n_gr_nt_mydata_adjust']
# Customer need: carry the legacy ERP's add-back mapping (account -> form line code) into Odoo
import csv
import io

MAPPING = """account;kfa
64.98.05.0000;2011
"""  # exported from the legacy ERP, one row per expense account

for row in csv.DictReader(io.StringIO(MAPPING), delimiter=';'):
    line = env['l10n_gr.kfa.line'].search([('code', '=', row['kfa']), ('is_total', '=', False)], limit=1)
    account = env['account.account'].search([('code', '=', row['account'])], limit=1)
    if not (line and account):
        print('skipped', row)
        continue
    account.l10n_gr_kfa_line_id = line
env.cr.commit()

The year-end management pack includes the tax add-back total, the E3 amount and any documents still missing an add-back entry.

# depends: ['l10n_gr_nt_mydata_adjust']
# Customer need: the CFO's year-end pack shows the add-back total, E3 box 455 and whether they agree
from odoo import _, models
from odoo.exceptions import UserError


class ResCompany(models.Model):
    _inherit = 'res.company'

    def acme_kfa_year_summary(self, year):
        self.ensure_one()
        report = self.env['l10n_gr.kfa.report'].search(
            [('year', '=', year), ('company_id', '=', self.id)], limit=1)
        if not report:
            raise UserError(_('No tax add-back statement for %s yet.', year))
        report.action_compute()
        return {
            'total': report.amount_total,
            'e3_455': report.e3_amount,
            'off_balance': report.e3_reconcile_amount,
            'agrees': report.e3_matches,
            'note': report.e3_status,
            'documents_without_add_back': report.l10n_gr_pending_count,
        }

Products are grouped into accounting categories that match the customer's catalogue, so invoice lines offer the right classifications.

# depends: ['l10n_gr_nt_mydata_base']
# Customer need: a furniture maker separates own production from traded goods so the right income classifications are offered
# __manifest__.py: 'post_init_hook': 'post_init_hook'

CATEGORIES = [
    ('Own production', 'consu', 'Furniture'),
    ('Traded goods', 'consu', 'Accessories'),
    ('Installation services', 'service', 'Services'),
]


def post_init_hook(env):
    company = env.company
    for name, ptype, product_categ in CATEGORIES:
        category = env['aade.accounting.category'].search(
            [('name', '=', name), ('company_id', '=', company.id)], limit=1)
        if not category:
            category = env['aade.accounting.category'].create(
                {'name': name, 'product_type': ptype, 'company_id': company.id})
        env['product.template'].search([('categ_id.name', '=', product_categ)]).write(
            {'aade_accounting_category_id': category.id})
    # the accountant sets each category's classifications from the screen

A migration from a legacy ERP translates its payment codes into the AADE payment methods.

# depends: ['l10n_gr_nt_mydata_base']
# Customer need: invoices migrated from the legacy ERP keep how they were paid, as AADE payment methods (table 8.12)
from odoo import api, models

LEGACY_TO_AADE = {
    'ΜΕΤ': 3,  # cash
    'ΤΡΑ': 1,  # domestic bank account
    'ΚΑΡ': 7,  # POS / e-POS
    'ΕΠΙ': 4,  # cheque
}


class AccountMove(models.Model):
    _inherit = 'account.move'

    @api.model
    def acme_aade_method_for(self, legacy_code):
        code = LEGACY_TO_AADE.get((legacy_code or '').strip().upper(), 5)  # unknown: on credit
        method = self.env['aade.payment.method'].search([('code', '=', code)], limit=1)
        return method  # shipped data: read it, never create or change records

rules = self.env['aade.withholding.rule'].search([('company_id', '=', self.env.company.id), ('active', '=', True)])
rates = {r.code: r.rate for r in rules}

A new e-shop payment method is mapped to the AADE payment method it must be declared as.

<!-- depends: ['l10n_gr_nt_mydata_base', 'payment'] -->
<!-- Customer need: the IRIS instant-payment method added for the e-shop is declared to AADE as IRIS (code 8) -->
<record id="payment_method_acme_iris" model="payment.method">
    <field name="name">IRIS</field>
    <field name="code">acme_iris</field>
    <field name="image" type="base64" file="acme_custom/static/img/iris.png"/>
    <field name="aade_payment_method_id" model="aade.payment.method" search="[('code', '=', 8)]"/>
</record>

Products imported from the legacy ERP get their accounting category from the old product group.

# odoo-bin shell snippet, run through the console (staging first)
# depends: ['l10n_gr_nt_mydata_base']
# Customer need: products migrated from the legacy ERP arrive with their myDATA accounting category
LEGACY_GROUP_TO_CATEGORY = {'ΕΜΠ': 'Traded goods', 'ΠΡΟ': 'Own production', 'ΥΠΗ': 'Installation services'}
ROWS = [('A-1001', 'ΕΜΠ'), ('P-2040', 'ΠΡΟ'), ('S-0003', 'ΥΠΗ')]  # (internal ref, legacy group)

categories = {
    c.name: c for c in env['aade.accounting.category'].search([('company_id', '=', env.company.id)])
}
for ref, group in ROWS:
    product = env['product.template'].search([('default_code', '=', ref)], limit=1)
    category = categories.get(LEGACY_GROUP_TO_CATEGORY.get(group))
    if not (product and category):
        print('skipped', ref, group)
        continue
    # keep it consistent with the income account: the account decides what is written
    product.aade_accounting_category_id = category
env.cr.commit()

An importer of intra-community goods loads TARIC codes from supplier price lists in the 10-digit form the documents need.

# depends: ['l10n_gr_nt_mydata_base']
# Customer need: supplier price lists print TARIC codes with dots and spaces; store them clean, report bad ones
import re

from odoo import api, models


class ProductTemplate(models.Model):
    _inherit = 'product.template'

    @api.model
    def acme_set_taric_codes(self, rows):
        """rows: iterable of (internal reference, TARIC as printed). Returns the refs not set."""
        skipped = []
        for ref, raw in rows:
            taric = re.sub(r'\D', '', raw or '')
            if len(taric) == 8:
                taric += '00'  # 8-digit CN code with no TARIC subdivision
            product = self.search([('default_code', '=', ref)], limit=1)
            if product and len(taric) == 10:  # anything else fails the field's validation
                product.l10n_gr_taric_no = taric
            else:
                skipped.append(ref)
        return skipped

A supplier to the public sector cannot confirm an order for a public body until every product has its CPV code.

# depends: ['l10n_gr_nt_mydata_base', 'sale']
# Customer need: orders for public bodies cannot be confirmed while a product lacks its CPV code
from odoo import _, models
from odoo.exceptions import UserError


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    def action_confirm(self):
        public = self.env.ref('acme_custom.partner_tag_public_body', raise_if_not_found=False)
        for order in self:
            if not public or public not in order.partner_id.commercial_partner_id.category_id:
                continue
            missing = order.order_line.filtered(lambda l: l.product_id and not l.product_id.peppol_cpv)
            if missing:
                raise UserError(_('Add a CPV code to: %s', ', '.join(missing.product_id.mapped('display_name'))))
        return super().action_confirm()

Sales staff are warned while quoting that a consumer order at or above the cash limit must be paid electronically.

# depends: ['l10n_gr_nt_mydata_base', 'sale']
# Customer need: sales staff learn at quotation time that a retail order must be paid electronically
from odoo import _, api, models
from odoo.tools import format_amount


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    @api.onchange('order_line', 'partner_id')
    def _onchange_acme_cash_limit(self):
        company = self.company_id
        limit = company.l10n_gr_cash_limit_retail  # 0 means the check is off
        retail = not self.partner_id.commercial_partner_id.vat
        if not limit or not retail or self.currency_id != company.currency_id:
            return
        if self.amount_total >= limit:  # measured on the whole document, VAT included
            return {'warning': {
                'title': _('Electronic payment required'),
                'message': _('Retail orders of %s or more cannot be paid in cash, not even in part.',
                             format_amount(self.env, limit, company.currency_id)),
            }}

A custom document layout prints the licence number of the certified e-invoicing provider the company issues through.

<!-- depends: ['l10n_gr_nt_mydata_base'] -->
<!-- Customer need: the customer's own document layout must still print the provider's licence number -->
<template id="acme_external_layout_licence" inherit_id="web.external_layout_standard">
    <xpath expr="//div[@t-field='company.report_footer']" position="after">
        <div t-if="company.l10n_gr_provider_licence" class="small text-muted">
            Αρ. άδειας ΥΠΑΗΕΣ: <span t-field="company.l10n_gr_provider_licence"/>
        </div>
    </xpath>
</template>

Anonymous daily sales from an external till are booked as drafts on the company's retail contact.

# depends: ['l10n_gr_nt_mydata_base']
# Customer need: daily anonymous sales from the shop's external till are booked on the company's retail contact
from odoo import Command, _, api, models
from odoo.exceptions import UserError


class AccountMove(models.Model):
    _inherit = 'account.move'

    @api.model
    def acme_create_retail_draft(self, lines, company=None):
        """lines: iterable of (product, quantity, unit price on the same tax basis as the product's taxes)."""
        company = company or self.env.company
        if not company.retail_partner_id:
            raise UserError(_('Set the retail contact of %s first.', company.name))
        return self.with_company(company).create({
            'move_type': 'out_invoice',
            'partner_id': company.retail_partner_id.id,
            'invoice_line_ids': [
                Command.create({'product_id': p.id, 'quantity': q, 'price_unit': price})
                for p, q, price in lines
            ],
        })  # stays draft: the accountant posts it

A company that self-bills its suppliers attaches each signed agreement from its document workflow and lists suppliers still without one.

# depends: ['l10n_gr_nt_mydata_base']
# Customer need: an olive-oil mill self-bills its farmers; the scanned agreement lands on the farmer
from odoo import _, api, models
from odoo.exceptions import UserError


class ResPartner(models.Model):
    _inherit = 'res.partner'

    def acme_set_self_billing_agreement(self, attachment):
        self.ensure_one()
        if attachment.mimetype != 'application/pdf':
            raise UserError(_('The self-billing agreement must be a signed PDF.'))
        supplier = self.commercial_partner_id
        supplier.l10n_gr_self_invoicing_agreement = attachment.datas
        supplier.message_post(body=_('Self-billing agreement attached.'))

    @api.model
    def acme_farmers_without_agreement(self):
        tag = self.env.ref('acme_custom.partner_tag_farmer')
        return self.search([
            ('category_id', 'in', tag.ids),
            ('l10n_gr_self_invoicing_agreement', '=', False),
        ])

A custom unit of measure used on invoices is mapped to the AADE quantity type it is declared with.

<!-- depends: ['l10n_gr_nt_mydata_base', 'uom'] -->
<!-- Customer need: a building-materials trader sells by the pallet of 40 pieces; the unit must map to an AADE quantity type (8.13) -->
<record id="uom_acme_pallet" model="uom.uom">
    <field name="name">Pallet (40)</field>
    <field name="relative_factor">40</field>
    <field name="relative_uom_id" ref="uom.product_uom_unit"/>
    <!-- 7: pieces, other cases -->
    <field name="aade_unit_id" model="aade.unit.measure" search="[('code', '=', 7)]"/>
</record>

Company-card transactions imported as expenses arrive with their myDATA expense category already set.

# depends: ['l10n_gr_nt_mydata_expense']
# Customer need: company-card transactions imported nightly arrive already classified for myDATA
from odoo import api, fields, models

# the form onchange does not run for code: set the category ourselves (merchant category code -> AADE)
MCC_TO_CATEGORY = {
    '5541': 'category2_4',  # fuel: general expenses with VAT deduction
    '5812': 'category2_5',  # restaurants: general expenses without VAT deduction
}


class HrExpense(models.Model):
    _inherit = 'hr.expense'

    @api.model
    def acme_import_card_line(self, employee, product, txn):
        return self.create({
            'name': txn['merchant'],
            'employee_id': employee.id,
            'product_id': product.id,
            'total_amount_currency': txn['amount'],
            'date': fields.Date.to_date(txn['date']),
            'payment_mode': 'company_account',
            # empty: the user picks the category before the expense can be sent
            'classification_category': MCC_TO_CATEGORY.get(txn['mcc'], False),
        })

A custom invoice layout prints the fees, stamp duty or withholdings applied to the whole document.

<!-- depends: ['l10n_gr_nt_mydata_invoice'] -->
<!-- Customer need: the customer's invoice layout lists document-level fees and stamp duty under the totals -->
<template id="report_invoice_acme_document_taxes" inherit_id="account.report_invoice_document">
    <xpath expr="//div[@id='total']" position="after">
        <table t-if="o.invoice_tax_ids" class="table table-sm mt-2">
            <thead>
                <tr><th>Document tax</th><th class="text-end">Base</th><th class="text-end">Amount</th></tr>
            </thead>
            <tbody>
                <tr t-foreach="o.invoice_tax_ids" t-as="tax_line">
                    <td t-field="tax_line.tax_id.name"/>
                    <td class="text-end" t-field="tax_line.base_amount"/>
                    <td class="text-end" t-field="tax_line.amount"/>
                </tr>
            </tbody>
        </table>
    </xpath>
</template>

A retail business analyses its sales by hour of issue, in local time.

# depends: ['l10n_gr_nt_mydata_invoice']
# Customer need: the shop's BI tool needs sales per hour of issue, in Greek local time
import pytz

from odoo import api, models


class AccountMove(models.Model):
    _inherit = 'account.move'

    @api.model
    def acme_sales_per_hour(self, date_from, date_to):
        tz = pytz.timezone('Europe/Athens')  # the issuer's time zone; invoice_time is stored in UTC
        moves = self.search([
            ('move_type', '=', 'out_invoice'), ('state', '=', 'posted'),
            ('invoice_time', '!=', False),
            ('invoice_date', '>=', date_from), ('invoice_date', '<=', date_to),
        ])
        hours = {}
        for move in moves:
            hour = pytz.utc.localize(move.invoice_time).astimezone(tz).hour
            hours[hour] = hours.get(hour, 0.0) + move.amount_total_signed
        return dict(sorted(hours.items()))

A scheduled action flags documents with unclassified lines in time for the accountant to fix them before the myDATA deadline.

# depends: ['l10n_gr_nt_mydata_invoice']
# Customer need: before the monthly myDATA deadline the accountant gets a to-do for every document with unclassified lines
from dateutil.relativedelta import relativedelta

from odoo import _, api, fields, models


class AccountMove(models.Model):
    _inherit = 'account.move'

    @api.model
    def _cron_acme_missing_classification(self):
        summary = _('myDATA classification missing')
        start = fields.Date.start_of(fields.Date.today() - relativedelta(months=1), 'month')
        lines = self.env['account.move.line'].search([
            ('parent_state', '=', 'posted'),
            ('move_id.move_type', 'in', ('out_invoice', 'out_refund', 'in_invoice', 'in_refund')),
            ('display_type', '=', 'product'),
            ('date', '>=', start),
            ('classification_category', '=', False),
        ])
        for move in lines.move_id:
            if move.activity_ids.filtered(lambda a: a.summary == summary):
                continue
            move.activity_schedule('mail.mail_activity_data_todo', summary=summary,
                                   user_id=move.invoice_user_id.id or self.env.user.id)

Invoices that also serve as delivery notes for sample orders carry the sampling purpose instead of sale.

# depends: ['l10n_gr_nt_mydata_invoice', 'sale']
# Customer need: invoices for orders tagged 'Samples' move the goods with purpose 3 (sampling), not 1 (sale)
from odoo import models


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    def _create_invoices(self, grouped=False, final=False, date=None):
        moves = super()._create_invoices(grouped=grouped, final=final, date=date)
        tag = self.env.ref('acme_custom.sale_tag_samples', raise_if_not_found=False)
        sampling = self.env['aade.move.purpose'].search([('code', '=', 3)], limit=1)
        if not (tag and sampling):
            return moves
        for move in moves.filtered(lambda m: m.state == 'draft'):
            if tag in move.line_ids.sale_line_ids.order_id.tag_ids:
                move.move_purpose_id = sampling  # draft value: the user can still change it
        return moves

Invoices for e-shop orders are filled with the AADE payment method the customer actually used online.

# depends: ['l10n_gr_nt_mydata_invoice', 'sale']
# Customer need: e-shop invoices declare how the customer actually paid instead of 'on credit'
from odoo import Command, models


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    def _create_invoices(self, grouped=False, final=False, date=None):
        moves = super()._create_invoices(grouped=grouped, final=final, date=date)
        for move in moves.filtered(lambda m: m.state == 'draft' and not m.payment_line_ids):
            orders = move.line_ids.sale_line_ids.order_id
            tx = orders.transaction_ids.filtered(lambda t: t.state == 'done')[:1]
            aade_method = tx.payment_method_id.aade_payment_method_id
            if aade_method:
                # a declaration only: the payment itself is still registered with Pay
                move.payment_line_ids = [Command.create({
                    'aade_payment_method_id': aade_method.id,
                    'amount': move.amount_total,
                })]
        return moves

Vendor bills received through myDATA that match no purchase order are sent to the buyer for review.

# depends: ['l10n_gr_nt_mydata_invoice', 'purchase']
# Customer need: bills that arrive through myDATA without a purchase order go to the buyer for review
from odoo import _, api, models


class AccountMove(models.Model):
    _inherit = 'account.move'

    @api.model
    def _cron_acme_review_received_bills(self):
        bills = self.search([
            ('received_from_mydata', '=', True),  # set by the suite, never written here
            ('move_type', '=', 'in_invoice'),
            ('state', '=', 'draft'),
            '!', ('invoice_line_ids.purchase_line_id', '!=', False),  # no line linked to a PO
            ('activity_ids', '=', False),
        ])
        for bill in bills:
            bill.activity_schedule(
                'mail.mail_activity_data_todo',
                summary=_('Bill from myDATA without purchase order'),
                user_id=bill.invoice_user_id.id or self.env.user.id,
            )

At year end, each freelancer receives a statement of fees and tax withheld, per withholding rule.

# depends: ['l10n_gr_nt_mydata_invoice']
# Customer need: at year end each freelancer gets a statement of the tax withheld from their fees
from odoo import models


class ResPartner(models.Model):
    _inherit = 'res.partner'

    def acme_withholding_statement(self, year):
        self.ensure_one()
        bills = self.env['account.move'].search([
            ('commercial_partner_id', '=', self.commercial_partner_id.id),
            ('move_type', '=', 'in_invoice'),
            ('state', '=', 'posted'),
            ('date', '>=', f'{year}-01-01'), ('date', '<=', f'{year}-12-31'),
        ])
        totals = {}
        for line in bills.withholding_line_ids:
            row = totals.setdefault(line.rule_id.name, {'base': 0.0, 'amount': 0.0})
            row['base'] += line.base_amount
            row['amount'] += line.amount
        return totals

The accountant sees per month how much tax the company withheld from suppliers and how much its customers withheld from it.

# depends: ['l10n_gr_nt_mydata_invoice']
# Customer need: the accountant plans the monthly payment of withheld tax (bills) and tracks what customers withheld (invoices)
from odoo import api, models


class AccountMove(models.Model):
    _inherit = 'account.move'

    @api.model
    def acme_withheld_per_month(self, year):
        groups = self._read_group(
            [('move_type', 'in', ('in_invoice', 'out_invoice')),
             ('state', '=', 'posted'),
             ('date', '>=', f'{year}-01-01'), ('date', '<=', f'{year}-12-31'),
             ('withholding_total', '!=', 0)],
            groupby=['move_type', 'date:month'],
            aggregates=['withholding_total:sum'],
        )
        # in_invoice: withheld by us, to pay; out_invoice: withheld by customers
        return [(move_type, month.strftime('%m/%Y'), total) for move_type, month, total in groups]

The shop owner wants the closing note of every Point of Sale session to show how many receipts and how many invoices were issued, with their totals.

# Customer need: the shop owner wants each session's closing note to split receipts from invoices.
# depends: ['point_of_sale', 'l10n_gr_nt_mydata_pos']
# The suite field is reached through the ORM; never import from odoo.addons.l10n_gr_*.
from markupsafe import Markup

from odoo import _, models


class PosSession(models.Model):
    _inherit = 'pos.session'

    def _acme_totals_by_document_kind(self):
        self.ensure_one()
        orders = self.order_ids.filtered(lambda o: o.state != 'cancel')
        # Related and not stored: group in Python, read_group cannot use it.
        return [
            (kind or _('No fiscal document yet'), len(group), sum(group.mapped('amount_total')))
            for kind, group in orders.grouped('l10n_gr_document_type_name').items()
        ]

    def action_pos_session_closing_control(self, *args, **kwargs):
        res = super().action_pos_session_closing_control(*args, **kwargs)
        # A cash difference can return a wizard instead of closing: note only closed sessions.
        for session in self.filtered(lambda s: s.state == 'closed'):
            rows = session._acme_totals_by_document_kind()
            session.message_post(body=Markup('<br/>').join('%s: %s / %.2f' % row for row in rows))
        return res

The accountant gets a reminder on every vendor bill from myDATA whose expense classification is still pending five days before the deadline.

# Customer need: the accountant gets a to-do on every myDATA bill not yet classified, 5 days before its deadline.
# depends: ['l10n_gr_nt_mydata_received']
# Run it from an ir.cron on model account.move, code: model._cron_acme_classification_reminder()
from odoo import _, api, fields, models


class AccountMove(models.Model):
    _inherit = 'account.move'

    @api.model
    def _cron_acme_classification_reminder(self):
        today = fields.Date.context_today(self)
        docs = self.env['l10n_gr.mydata.received.doc'].search([
            ('state', '=', 'matched'),  # linked to a bill, not classified yet
            ('move_id.l10n_gr_classification_deadline', '>=', today),
            ('move_id.l10n_gr_classification_deadline', '<=', fields.Date.add(today, days=5)),
        ])
        for bill in docs.move_id.filtered(lambda m: not m.activity_ids):
            bill.activity_schedule(
                'mail.mail_activity_data_todo',
                date_deadline=bill.l10n_gr_classification_deadline,
                summary=_('Expense classification due'),
                user_id=bill.invoice_user_id.id or self.env.user.id,
            )

The finance manager wants every supplier document marked as ignored to carry a written reason, so nothing declared by a supplier is dropped silently.

# Customer need: the finance manager wants a written reason whenever a supplier document is ignored instead of billed.
# depends: ['l10n_gr_nt_mydata_received']
# The model is extended through _inherit; never import from odoo.addons.l10n_gr_*.
from odoo import _, fields, models
from odoo.exceptions import UserError


class ReceivedDoc(models.Model):
    _inherit = 'l10n_gr.mydata.received.doc'

    x_ignore_reason = fields.Char(string='Reason ignored', tracking=True)

    def write(self, vals):
        # super() first: the suite re-evaluates the linked bill's classification mode there.
        res = super().write(vals)
        if vals.get('state') == 'ignored' and self.filtered(lambda d: not d.x_ignore_reason):
            # Raising rolls back the whole write, the state included.
            raise UserError(_('Write why this document needs no vendor bill before ignoring it.'))
        return res

# Add x_ignore_reason to the form with an xpath on the suite's form view.

Before closing the month, the accountant sees the net and VAT amounts that suppliers declared on documents not yet entered as bills, grouped by the supplier's income category and VAT category.

# Customer need: at month end the accountant sees what still-unbilled supplier documents declare, by income and VAT category.
# depends: ['l10n_gr_nt_mydata_received']
from odoo import api, models


class ReceivedLine(models.Model):
    _inherit = 'l10n_gr.mydata.received.line'

    @api.model
    def _acme_unbilled_summary(self, date_from, date_to):
        groups = self._read_group(
            [
                ('company_id', '=', self.env.company.id),
                ('doc_id.state', '=', 'new'),
                ('doc_id.issue_date', '>=', date_from),
                ('doc_id.issue_date', '<=', date_to),
                ('rec_type', '!=', 6),  # gift vouchers are not classified by the recipient
            ],
            ['issuer_income_category', 'vat_category'],
            ['net_value:sum', 'vat_amount:sum'],
        )
        return [
            {'income_category': cat or '-', 'vat_category': vat or '-', 'net': net, 'vat': tax}
            for cat, vat, net, tax in groups
        ]

After a merger of tax offices, the back office gets a to-do for each customer still filed under an abolished office, to confirm the new office with the customer.

# Customer need: after an AADE merger, the back office reviews the customers still filed under an abolished tax office.
# depends: ['l10n_gr_nt_partner']
# Offices are read through the ORM (self.env['l10n_gr.doy']); never import from odoo.addons.l10n_gr_*.
from odoo import _, api, models


class ResPartner(models.Model):
    _inherit = 'res.partner'

    @api.model
    def _acme_review_abolished_offices(self):
        abolished = self.env['l10n_gr.doy'].with_context(active_test=False).search([
            ('active', '=', False),
            ('superseded_by_id', '!=', False),
        ])
        partners = self.search([('l10n_gr_doy_id', 'in', abolished.ids), ('is_company', '=', True)])
        for partner in partners:
            office = partner.l10n_gr_doy_id
            # Do not rewrite the office here: confirm with the customer, then update the contact.
            partner.activity_schedule(
                'mail.mail_activity_data_todo',
                summary=_('Tax office %(old)s was merged into %(new)s',
                          old=office.name,
                          new=office.l10n_gr_current_service().name),  # follows repeated mergers
            )
        return partners

During the migration from the legacy ERP, customers are imported with their tax office matched from free text, and the names that match no office are listed for manual review.

# Customer need: load the customers exported from the legacy ERP, where the tax office is free text such as "Δ.Ο.Υ. Α' ΑΘΗΝΩΝ".
# depends: ['l10n_gr_nt_partner']
# Reached through the ORM (self.env['l10n_gr.doy']); never import from odoo.addons.l10n_gr_*.
from odoo import api, models


class ResPartner(models.Model):
    _inherit = 'res.partner'

    @api.model
    def _acme_import_legacy_customers(self, rows):
        """rows: dicts with afm, name, doy. Returns the office names that were not found."""
        Doy = self.env['l10n_gr.doy']
        greece = self.env.ref('base.gr')
        unmatched = set()
        for row in rows:
            doy = Doy._l10n_gr_find_by_name(row['doy']) if row.get('doy') else Doy
            if row.get('doy') and not doy:
                unmatched.add(row['doy'])  # leave it empty, never create an office from text
            self.create({
                'name': row['name'],
                'is_company': True,
                'country_id': greece.id,
                'vat': 'EL%s' % row['afm'],
                'l10n_gr_doy_id': doy.id,
            })
        return sorted(unmatched)

An EDI integration with a retail chain receives customer master data with the tax office's TAXIS code, and falls back to the office name when the code is missing.

# Customer need: the retail chain's EDI customer master sends the TAXIS code of the tax office, sometimes only its name.
# depends: ['l10n_gr_nt_partner']
from odoo import api, models


class ResPartner(models.Model):
    _inherit = 'res.partner'

    @api.model
    def _acme_doy_from_edi(self, code, name):
        # Archived offices count: the chain's master data may predate a merger.
        Doy = self.env['l10n_gr.doy'].with_context(active_test=False)
        code = str(code or '').strip()  # the code is a Char; EDI may send it as a number
        doy = Doy.search([('code', '=', code)], limit=1) if code else Doy
        if not doy and name:
            doy = Doy._l10n_gr_find_by_name(name)
        return doy

    def _acme_apply_edi_master(self, payload):
        for partner in self:
            doy = self._acme_doy_from_edi(payload.get('TaxOfficeCode'), payload.get('TaxOffice'))
            if doy:
                # The office belongs to the business: write it on the commercial entity.
                partner.commercial_partner_id.l10n_gr_doy_id = doy

The accountant sees on the contact both the tax office printed on its documents and the office that serves it today, so correspondence goes to the right office.

# Customer need: next to the stored tax office, the accountant sees the office that serves the customer today, for letters and filings.
# depends: ['l10n_gr_nt_partner']
from odoo import api, fields, models


class ResPartner(models.Model):
    _inherit = 'res.partner'

    x_doy_today_id = fields.Many2one(
        'l10n_gr.doy',
        string='Tax office serving today',
        compute='_compute_x_doy_today_id',
    )

    @api.depends('l10n_gr_doy_id', 'l10n_gr_doy_id.superseded_by_id')
    def _compute_x_doy_today_id(self):
        for partner in self:
            office = partner.l10n_gr_doy_id
            # One record at a time; the stored office stays as printed on past documents.
            partner.x_doy_today_id = office.l10n_gr_current_service() if office else False

A custom quotation layout prints the company's legal form, ΓΕΜΗ number and website only where its legal form requires them.

<!-- Customer need: the customer's own quotation layout prints the ΓΕΜΗ number and the legal form only when the company's legal form requires them. -->
<!-- depends: ['sale', 'l10n_gr_nt_partner'] -->
<template id="acme_quotation_company_indications" inherit_id="sale.report_saleorder_document">
    <xpath expr="//div[hasclass('page')]" position="inside">
        <t t-set="acme_company" t-value="doc.company_id.partner_id"/>
        <t t-set="acme_form" t-value="acme_company.l10n_gr_legal_form_id"/>
        <div class="small text-muted mt-4">
            <span t-out="acme_company.l10n_gr_display_name()"/>
            <t t-if="acme_form.require_legal_form_label"> · <span t-out="acme_form.name"/></t>
            <t t-if="acme_form.require_gemi and acme_company.l10n_gr_gemi">
                · ΓΕΜΗ <span t-out="acme_company.l10n_gr_gemi"/>
            </t>
            <t t-if="acme_form.require_website and acme_company.website">
                · <span t-out="acme_company.website"/>
            </t>
        </div>
    </xpath>
</template>

The order confirmation sent by EDI to a supermarket chain carries the seller's and the buyer's VAT numbers in the plain form the chain expects.

# Customer need: the supermarket chain's EDI order response must carry both VAT numbers without the EL prefix.
# depends: ['sale', 'l10n_gr_nt_partner']
from odoo import fields, models


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    def _acme_edi_order_response(self):
        self.ensure_one()
        return {
            'SenderVat': self.company_id.l10n_gr_aade_vat(),
            'ReceiverVat': self.partner_id.commercial_partner_id.l10n_gr_aade_vat(),
            'OrderRef': self.client_order_ref or self.name,
            'ResponseDate': fields.Date.to_string(fields.Date.context_today(self)),
            'Lines': [
                {'Ean': line.product_id.barcode, 'Qty': line.product_uom_qty}
                for line in self.order_line.filtered(lambda l: not l.display_type)
            ],
        }

The customer statement of account, a custom report, shows the company's VAT number and tax office exactly as its invoices do.

<!-- Customer need: the customer's statement of account (a custom report) prints the company's ΑΦΜ and ΔΟΥ as the invoices do. -->
<!-- depends: ['account', 'l10n_gr_nt_partner'] -->
<!-- t-call it from the statement template, where o is the customer record. -->
<template id="acme_statement_company_block">
    <t t-set="acme_company" t-value="o.company_id or res_company"/>
    <div class="small mb-3">
        <strong t-out="acme_company.partner_id.l10n_gr_display_name()"/><br/>
        <span t-out="acme_company.partner_id.l10n_gr_full_address()"/><br/>
        ΑΦΜ <span t-out="acme_company.l10n_gr_aade_vat()"/>
        <t t-if="acme_company.l10n_gr_doy_id">
            · ΔΟΥ <span t-out="acme_company.l10n_gr_doy_id.name"/>
        </t>
    </div>
</template>

Before the first invoice is issued, the consultant checks with one button which indications required by law are still missing from the company's documents.

# Customer need: before go-live, a button in the company form tells the consultant which mandatory indications are still missing.
# depends: ['l10n_gr_nt_partner']
from odoo import _, models
from odoo.exceptions import UserError


class ResCompany(models.Model):
    _inherit = 'res.company'

    def action_acme_go_live_check(self):
        problems = []
        for company in self:
            problems += [
                '%s: %s (%s)' % (company.name, indication, basis)
                for indication, basis in company.l10n_gr_missing_indications()
            ]
        if problems:
            raise UserError(_('Complete these before the first invoice:\n%s', '\n'.join(problems)))
        return {
            'type': 'ir.actions.client',
            'tag': 'display_notification',
            'params': {'message': _('All mandatory indications are set.'), 'type': 'success'},
        }

A custom document footer prints the company's capital only when, and as, its legal form requires, for example both subscribed and paid-up capital for an ΑΕ.

<!-- Customer need: the customer's custom document footer prints the share capital only in the form the law accepts for its legal form. -->
<!-- depends: ['web', 'l10n_gr_nt_partner'] -->
<!-- t-call it from your own external layout, where company is set. -->
<template id="acme_footer_capital">
    <t t-set="acme_capital" t-value="company.l10n_gr_print_capital()"/>
    <div t-if="acme_capital" class="small">
        <t t-foreach="acme_capital" t-as="cap">
            <span t-out="cap[0]"/>:
            <span t-out="cap[1]"
                  t-options="{'widget': 'monetary', 'display_currency': company.currency_id}"/>
            <t t-if="not cap_last"> · </t>
        </t>
    </div>
</template>

Every night, EU business customers whose VAT number VIES could not confirm when they were created are checked again, so intra-community invoices are not held up.

# Customer need: EU customers that VIES could not confirm on the day they were created are checked again every night.
# depends: ['l10n_gr_nt_partner']
# Run it from an ir.cron on model res.partner, code: model._cron_acme_recheck_vies()
import logging

from odoo import api, models
from odoo.exceptions import UserError

_logger = logging.getLogger(__name__)


class ResPartner(models.Model):
    _inherit = 'res.partner'

    @api.model
    def _cron_acme_recheck_vies(self, limit=50):
        eu = self.env.ref('base.europe').country_ids.filtered(lambda c: c.code != 'GR')
        candidates = self.search([('is_company', '=', True), ('vat', '!=', False), ('country_id', 'in', eu.ids)])
        # l10n_gr_vies_state is computed, not stored: filter in Python.
        todo = candidates.filtered(lambda p: p.l10n_gr_vies_state == 'unconfirmed')[:limit]
        try:
            todo.action_l10n_gr_check_vies()
        except UserError as error:  # VAT verification disabled in Accounting settings
            _logger.warning('VIES re-check skipped: %s', error)

The bulk supplier payment file for the bank lists each supplier's VAT number in the plain form the bank requires.

# Customer need: the bank's bulk-payment file needs each supplier's ΑΦΜ without the EL prefix.
# depends: ['account', 'l10n_gr_nt_partner']
import csv
import io

from odoo import models


class AccountPayment(models.Model):
    _inherit = 'account.payment'

    def _acme_bank_file(self):
        out = io.StringIO()
        writer = csv.writer(out, delimiter=';')
        for pay in self.filtered(lambda p: p.payment_type == 'outbound'):
            supplier = pay.partner_id.commercial_partner_id
            writer.writerow([
                supplier.l10n_gr_aade_vat(),
                supplier.l10n_gr_display_name()[:70],
                pay.partner_bank_id.acc_number or '',
                '%.2f' % pay.amount,
                pay.memo or pay.name,
            ])
        return out.getvalue()

The courier label printed from each delivery shows the customer's registered name, the same name its invoices carry.

<!-- Customer need: the courier label printed from each delivery shows the customer's registered name, not the trade name. -->
<!-- depends: ['stock', 'l10n_gr_nt_partner'] -->
<record id="acme_report_courier_label" model="ir.actions.report">
    <field name="name">Courier label</field>
    <field name="model">stock.picking</field>
    <field name="report_type">qweb-pdf</field>
    <field name="report_name">acme_custom.courier_label</field>
    <field name="binding_model_id" ref="stock.model_stock_picking"/>
</record>
<template id="courier_label">
    <t t-call="web.basic_layout">
        <div t-foreach="docs" t-as="o" class="page">
            <t t-set="customer" t-value="o.partner_id.commercial_partner_id"/>
            <h3 t-out="customer.l10n_gr_display_name()"/>
            <div t-out="o.partner_id.l10n_gr_full_address()"/>
            <div>ΑΦΜ <span t-out="customer.l10n_gr_aade_vat()"/></div>
            <div t-out="o.name"/>
        </div>
    </t>
</template>

A sales order for a Greek business cannot be confirmed until the customer's tax office is filled in, so the invoice never goes out without it.

# Customer need: a sale order for a Greek business is not confirmed until its tax office is set, because the invoice must print it.
# depends: ['sale', 'l10n_gr_nt_partner']
from odoo import _, models
from odoo.exceptions import UserError


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    def action_confirm(self):
        for order in self:
            # The office belongs to the business, so read it on the commercial entity.
            customer = order.partner_invoice_id.commercial_partner_id
            if (customer.is_company and customer.country_id.code == 'GR'
                    and customer.vat and not customer.l10n_gr_doy_id):
                raise UserError(_(
                    'Set the tax office of %s before confirming: the invoice must print it.',
                    customer.display_name,
                ))
        return super().action_confirm()

The footer of the customer's online shop shows the company's registered name, address on one line, VAT number, tax office and ΓΕΜΗ number.

<!-- Customer need: the e-shop footer shows the seller's legal identity, with the registered address on one line. -->
<!-- depends: ['website', 'l10n_gr_nt_partner'] -->
<template id="acme_website_legal_footer" inherit_id="website.layout">
    <xpath expr="//footer" position="inside">
        <t t-set="acme_seller" t-value="res_company.partner_id"/>
        <div class="container small text-center py-2">
            <span t-out="acme_seller.l10n_gr_display_name()"/> ·
            <span t-out="acme_seller.l10n_gr_full_address()"/> ·
            ΑΦΜ <span t-out="res_company.l10n_gr_aade_vat()"/>
            <t t-if="res_company.l10n_gr_doy_id">
                · ΔΟΥ <span t-out="res_company.l10n_gr_doy_id.name"/>
            </t>
            <t t-if="acme_seller.l10n_gr_gemi">
                · ΓΕΜΗ <span t-out="acme_seller.l10n_gr_gemi"/>
            </t>
        </div>
    </xpath>
</template>

The integration with a courier sends each delivery's street with its number as one value, without repeating a number that is already in the street.

# Customer need: the courier's API wants street with number, postcode and city as separate values.
# depends: ['stock', 'l10n_gr_nt_partner']
from odoo import _, models
from odoo.exceptions import UserError


class StockPicking(models.Model):
    _inherit = 'stock.picking'

    def _acme_courier_payload(self):
        self.ensure_one()
        recipient = self.partner_id
        if not (recipient.street and recipient.zip and recipient.city):
            raise UserError(_('The delivery address of %s is incomplete.', self.name))
        return {
            'name': recipient.commercial_partner_id.l10n_gr_display_name(),
            'street': recipient.l10n_gr_full_street(),  # the number is added once, never twice
            'postcode': recipient.zip,
            'city': recipient.city,
            'phone': recipient.phone or '',
            'reference': self.name,
        }

The CRM synchronisation stores each customer's ΓΕΜΗ number after cleaning it, and records a note on the contact when the number already belongs to another business.

# Customer need: the CRM sync writes the ΓΕΜΗ number it receives, cleaned, and reports duplicates instead of stopping the sync.
# depends: ['l10n_gr_nt_partner']
import re

from odoo import _, models
from odoo.exceptions import ValidationError


class ResPartner(models.Model):
    _inherit = 'res.partner'

    def _acme_sync_gemi(self, raw):
        self.ensure_one()
        digits = re.sub(r'\D', '', raw or '')
        if len(digits) != 12:
            return False
        business = self.commercial_partner_id  # a company and its branches share the number
        try:
            with self.env.cr.savepoint():
                business.l10n_gr_gemi = digits
        except ValidationError as error:  # already used by another business
            business.message_post(body=_('ΓΕΜΗ %(gemi)s not saved: %(error)s', gemi=digits, error=error))
            return False
        return True

During the migration from a legacy ERP, each customer's legal form, kept there as text, is set on the contact so documents print the right indications.

# Customer need: the legacy ERP stores the legal form as text (ΑΕ, Ε.Π.Ε., ΙΚΕ, ΟΕ, ΕΕ, Ατομική); the migration maps it to the Greek legal forms.
# depends: ['l10n_gr_nt_partner']
from odoo import api, models

# Keys are the legacy text without dots or spaces, in capitals.
LEGACY_FORMS = {
    'ΑΕ': 'ae', 'ΕΠΕ': 'epe', 'ΙΚΕ': 'ike', 'ΟΕ': 'oe', 'ΕΕ': 'ee',
    'ΑΤΟΜΙΚΗ': 'individual', 'ΑΤΟΜΙΚΉ': 'individual',
}


class ResPartner(models.Model):
    _inherit = 'res.partner'

    @api.model
    def _acme_migrate_legal_forms(self, rows):
        """rows: (afm, legacy legal form text) pairs from the legacy export."""
        forms = {f.code: f for f in self.env['l10n_gr.legal.form'].search([])}
        for afm, legacy in rows:
            key = ''.join((legacy or '').replace('.', '').split()).upper()
            code = LEGACY_FORMS.get(key)
            partner = self.search([('vat', 'in', [afm, 'EL' + afm]), ('is_company', '=', True)], limit=1)
            if partner and code in forms:
                partner.l10n_gr_legal_form_id = forms[code]

During the migration, each customer keeps its trade name as the contact name and its registered name for documents, as the legacy ERP held them.

# Customer need: the legacy ERP keeps «επωνυμία» and «διακριτικός τίτλος» apart; Odoo keeps the trade name as name, the registered name for documents.
# depends: ['l10n_gr_nt_partner']
from odoo import api, models


class ResPartner(models.Model):
    _inherit = 'res.partner'

    @api.model
    def _acme_migrate_names(self, rows):
        """rows: dicts with afm, eponymia, titlos from the legacy export."""
        for row in rows:
            afm = row['afm']
            partner = self.search([('vat', 'in', [afm, 'EL' + afm]), ('is_company', '=', True)], limit=1)
            if not partner:
                continue
            legal = (row.get('eponymia') or '').strip()
            trade = (row.get('titlos') or '').strip()
            partner.write({
                'name': trade or legal or partner.name,
                # Empty when it equals the trade name: documents then print the name.
                'l10n_gr_legal_name': legal if legal and legal != trade else False,
            })

An invoice without VAT to an EU business is posted only once VIES has validated the customer's VAT number, with one fresh check if it was not confirmed before.

# Customer need: an intra-community invoice without VAT is not posted for a customer that VIES has not validated.
# depends: ['account', 'l10n_gr_nt_partner']
from odoo import _, models
from odoo.exceptions import UserError


class AccountMove(models.Model):
    _inherit = 'account.move'

    def action_post(self):
        eu = self.env.ref('base.europe').country_ids
        for move in self.filtered(lambda m: m.move_type == 'out_invoice'):
            customer = move.commercial_partner_id
            zero_vat = not move.invoice_line_ids.tax_ids.filtered(lambda t: t.amount)
            if customer.country_id in eu and customer.country_id.code != 'GR' and zero_vat:
                if customer.l10n_gr_vies_state == 'unconfirmed':
                    customer.action_l10n_gr_check_vies()  # VIES may have been down that day
                if customer.l10n_gr_vies_state != 'valid':
                    raise UserError(_(
                        '%s is not validated in VIES: an invoice without VAT needs a valid EU VAT number.',
                        customer.display_name,
                    ))
        return super().action_post()

An exporting company prints the legal Greek title of each invoice with its English name next to it when the customer does not read Greek.

# Customer need: an exporter wants the printed title in Greek with the English name next to it for foreign customers.
# depends: ['l10n_gr_nt_report_layout']
# Extend through _inherit and super(); never import from odoo.addons.l10n_gr_*.
from odoo import models

# By AADE document type, so a retail receipt is never called an invoice.
ENGLISH_TITLES = {
    '1.1': 'Sales Invoice', '1.2': 'Sales Invoice, Intra-Community Supply',
    '1.3': 'Sales Invoice, Export', '2.1': 'Service Invoice',
    '2.2': 'Service Invoice, Intra-Community', '2.3': 'Service Invoice, Third Country',
    '5.1': 'Credit Note',
}


class AccountMove(models.Model):
    _inherit = 'account.move'

    def _l10n_gr_document_title(self):
        title = super()._l10n_gr_document_title()
        # False means keep Odoo's own title (drafts, non-Greek companies): leave it alone.
        if not title:
            return title
        english = ENGLISH_TITLES.get(self._l10n_gr_invoice_type().code)
        if english and not (self.partner_id.lang or '').startswith('el'):
            return '%s / %s' % (title, english)
        return title

Staff cannot post a retail receipt for a business customer with a VAT number, so such customers always receive an invoice.

# Customer need: a retail receipt must not be posted for a business customer with a VAT number; staff must use an invoice series.
# depends: ['l10n_gr_nt_report_layout']
from odoo import _, models
from odoo.exceptions import UserError


class AccountMove(models.Model):
    _inherit = 'account.move'

    def action_post(self):
        for move in self.filtered(lambda m: m.move_type == 'out_invoice'):
            kind = move._l10n_gr_invoice_type()
            customer = move.commercial_partner_id
            # Test for truth: the method returns an empty record or False when nothing applies.
            if kind and kind.code.startswith('11.') and customer.is_company and customer.vat:
                raise UserError(_(
                    '%(doc)s is a retail document (%(kind)s) but %(customer)s is a business: use an invoice series.',
                    doc=move.display_name,
                    kind=kind.display_name,
                    customer=customer.display_name,
                ))
        return super().action_post()

A company with a central warehouse and several shops makes goods taken for own use always leave from the warehouse chosen in its settings.

# Customer need: the company has a central warehouse and shops; goods for own use always leave from the warehouse set on the company.
# depends: ['stock', 'l10n_gr_nt_selfsupply']
from odoo import fields, models


class ResCompany(models.Model):
    _inherit = 'res.company'

    x_self_supply_warehouse_id = fields.Many2one('stock.warehouse', string='Self-supply warehouse')


class AccountMove(models.Model):
    _inherit = 'account.move'

    def _l10n_gr_self_supply_source_location(self):
        # The suite uses this for the stock check and for the moves, so both follow.
        warehouse = self.company_id.x_self_supply_warehouse_id
        if warehouse and warehouse.company_id == self.company_id:
            return warehouse.lot_stock_id
        return super()._l10n_gr_self_supply_source_location()

The accountant is reminded of every posted self-supply document that has no settlement entry, so no open balance stays on the company's own account.

# Customer need: the accountant is reminded of posted self-supply documents left without a settlement entry, for example after it was deleted.
# depends: ['l10n_gr_nt_selfsupply']
# Run it from an ir.cron on model account.move, code: model._cron_acme_unsettled_self_supply()
from odoo import _, api, models


class AccountMove(models.Model):
    _inherit = 'account.move'

    @api.model
    def _cron_acme_unsettled_self_supply(self):
        # Read only: the suite posts the settlement itself, never set the field from here.
        unsettled = self.search([
            ('l10n_gr_self_supply_type', '!=', False),
            ('state', '=', 'posted'),
            ('l10n_gr_self_supply_entry_id', '=', False),
        ])
        for doc in unsettled.filtered(lambda d: not d.activity_ids):
            doc.activity_schedule(
                'mail.mail_activity_data_todo',
                summary=_('Self-supply without settlement entry'),
            )

The warehouse prints, for each self-supply document, a sheet of the products, locations and quantities it took out of stock, for signature.

<!-- Customer need: the warehouse keeps a signed sheet of what each self-supply document took out of stock. -->
<!-- depends: ['stock', 'l10n_gr_nt_selfsupply'] -->
<!-- Bind it with an ir.actions.report on account.move (report_name acme_custom.self_supply_stock_sheet). -->
<template id="self_supply_stock_sheet">
    <t t-call="web.html_container">
        <t t-foreach="docs" t-as="o">
            <t t-call="web.external_layout">
                <div class="page">
                    <h4><span t-out="o.name"/> · <span t-out="o.invoice_date"/></h4>
                    <table class="table table-sm">
                        <tr t-foreach="o.l10n_gr_self_supply_move_ids" t-as="m">
                            <td t-out="m.product_id.display_name"/>
                            <td t-out="m.location_id.display_name"/>
                            <td class="text-end"><span t-out="m.quantity"/> <span t-out="m.product_uom.name"/></td>
                        </tr>
                    </table>
                    <p t-if="not o.l10n_gr_self_supply_move_ids">No stock moves: services or non-storable products only.</p>
                    <p class="mt-5">Signature: ____________________</p>
                </div>
            </t>
        </t>
    </t>
</template>

The owner's monthly dashboard shows sales separately from self-supply of goods and own use of services, so turnover is not overstated.

# Customer need: the owner's monthly dashboard shows self-supplies apart from sales, so own use never inflates turnover.
# depends: ['l10n_gr_nt_selfsupply']
from odoo import api, models


class AccountMove(models.Model):
    _inherit = 'account.move'

    @api.model
    def _acme_turnover_and_self_supply(self, date_from, date_to):
        domain = [
            ('company_id', '=', self.env.company.id),
            ('move_type', '=', 'out_invoice'),
            ('state', '=', 'posted'),
            ('invoice_date', '>=', date_from),
            ('invoice_date', '<=', date_to),
        ]
        # Stored and indexed, so it groups in SQL; False means an ordinary sale.
        rows = self._read_group(
            domain,
            ['l10n_gr_self_supply_type', 'invoice_date:month'],
            ['amount_untaxed_signed:sum'],
        )
        return [{'kind': kind or 'sales', 'month': month, 'net': net} for kind, month, net in rows]

The warehouse manager's monthly report shows, per product, how much stock left for own use, how much was scrapped and how much was sold.

# Customer need: the warehouse manager's monthly outflow report separates goods taken for own use from sales and scrap.
# depends: ['sale_stock', 'l10n_gr_nt_selfsupply']
from odoo import api, models


class StockMove(models.Model):
    _inherit = 'stock.move'

    @api.model
    def _acme_outflow_by_reason(self, date_from, date_to):
        base = [
            ('state', '=', 'done'), ('date', '>=', date_from), ('date', '<=', date_to),
            ('location_id.usage', '=', 'internal'), ('location_dest_id.usage', '!=', 'internal'),
        ]
        reasons = {
            'self_supply': [('l10n_gr_self_supply_invoice_id', '!=', False)],
            'scrap': [('l10n_gr_self_supply_invoice_id', '=', False), ('scrap_id', '!=', False)],
            'sale': [('l10n_gr_self_supply_invoice_id', '=', False), ('sale_line_id', '!=', False)],
        }
        return {
            reason: dict(self._read_group(base + extra, ['product_id'], ['product_qty:sum']))
            for reason, extra in reasons.items()
        }

When an invoice is posted, the deliveries it declares are marked with its number, so the warehouse management system can close them.

# Customer need: the WMS must know which deliveries an invoice covers, so it can close them on its side.
# depends: ['l10n_gr_nt_stock']
from odoo import fields, models


class StockPicking(models.Model):
    _inherit = 'stock.picking'

    x_wms_invoice_ref = fields.Char(string='Invoiced by', copy=False, readonly=True)


class AccountMove(models.Model):
    _inherit = 'account.move'

    def _post(self, soft=True):
        posted = super()._post(soft=soft)
        # Read after super(): the suite fills the list while posting, then keeps it fixed.
        for move in posted.filtered(lambda m: m.move_type == 'out_invoice'):
            move.l10n_gr_connected_picking_ids.write({'x_wms_invoice_ref': move.name})
        return posted

The route planner assigns the truck and its departure time to the next day's deliveries, so each delivery note shows them without manual entry.

# Customer need: the route planner sets the truck and its departure time on tomorrow's deliveries, so the delivery note carries them.
# depends: ['l10n_gr_nt_stock']
from datetime import timedelta

from odoo import _, fields, models
from odoo.exceptions import UserError


class StockPicking(models.Model):
    _inherit = 'stock.picking'

    def action_acme_plan_route(self, plate, departure=None):
        """plate: the truck's registration plate; departure: datetime, default in one hour."""
        departure = departure or fields.Datetime.now() + timedelta(hours=1)
        if departure < fields.Datetime.now():
            # The suite itself refuses a dispatch day in the past when the note is issued.
            raise UserError(_('The departure time is in the past.'))
        # Only deliveries still to ship.
        todo = self.filtered(lambda p: p.state not in ('done', 'cancel'))
        todo.write({
            'vehicle_number': plate,
            'dispatch_date': departure,
        })
        return True

When sales representatives send product samples to prospects, a button sets the movement purpose to sampling, so the delivery note does not declare a sale.

# Customer need: sales reps send product samples to prospects; the delivery note must say sampling, not sale.
# depends: ['stock', 'l10n_gr_nt_stock']
from odoo import _, models
from odoo.exceptions import UserError


class StockPicking(models.Model):
    _inherit = 'stock.picking'

    def action_acme_mark_as_samples(self):
        # AADE table 8.14: code 3 is sampling.
        sampling = self.env['aade.move.purpose'].search([('code', '=', 3)], limit=1)
        for picking in self:
            if picking.state in ('done', 'cancel'):
                raise UserError(_('%s is already done or cancelled: set the purpose before shipping.', picking.name))
            if sampling not in picking.allowed_move_purpose_ids:
                raise UserError(_('%s cannot carry the sampling purpose for this direction.', picking.name))
            # Kept as set, since it is one of the purposes offered for this picking.
            picking.move_purpose_id = sampling
        return True

The dispatcher enters the truck's plate once on a batch of deliveries, and every delivery note of the batch carries it.

# Customer need: the dispatcher sets the truck once on a picking batch, and every delivery in the batch carries its plate.
# depends: ['stock_picking_batch', 'l10n_gr_nt_stock']
from odoo import fields, models


class StockPickingBatch(models.Model):
    _inherit = 'stock.picking.batch'

    x_license_plate = fields.Char(string='Truck plate')

    def write(self, vals):
        res = super().write(vals)
        if 'x_license_plate' in vals:
            # Only deliveries still to ship; done pickings keep what they declared.
            self.picking_ids.filtered(lambda p: p.state not in ('done', 'cancel')).write({
                'vehicle_number': vals['x_license_plate'],
            })
        return res

A food distributor scraps every expired lot in one run, and the loss is booked to the stock destruction account rather than cost of goods sold.

# Need: a food distributor destroys expired lots every month; the loss must land on 67.02.00.
# depends: ['l10n_gr_nt_stock_balance', 'product_expiry']
# The l10n.gr API is reached through the ORM, never by importing from odoo.addons.l10n_gr_*.
from odoo import api, fields, models, _
from odoo.exceptions import UserError


class StockQuant(models.Model):
    _inherit = 'stock.quant'

    @api.model
    def _acme_destroy_expired_lots(self):
        destruction = self.env['stock.location'].search([
            ('company_id', '=', self.env.company.id),
            ('l10n_gr_destruction', '=', True),  # search by the marker, never by name
        ], limit=1)
        if not destruction:
            raise UserError(_('No stock destruction location. Is the Greek chart of accounts installed?'))
        quants = self.search([
            ('company_id', '=', self.env.company.id),
            ('location_id.usage', '=', 'internal'),
            ('lot_id.expiration_date', '<', fields.Datetime.now()),
            ('quantity', '>', 0),
        ])
        scraps = self.env['stock.scrap'].create([{
            'product_id': q.product_id.id, 'lot_id': q.lot_id.id, 'scrap_qty': q.quantity,
            'location_id': q.location_id.id, 'scrap_location_id': destruction.id,
            'origin': _('Expired lots'),
        } for q in quants])
        for scrap in scraps:  # action_validate works on one scrap at a time
            scrap.action_validate()

A retail chain records stolen goods with the police report number, so the loss lands on the theft and loss account instead of cost of goods sold.

# Need: a retail chain records goods found stolen at a store count, with the police report number.
# depends: ['l10n_gr_nt_stock_balance']
# The l10n.gr API is reached through the ORM, never by importing from odoo.addons.l10n_gr_*.
from odoo import fields, models, _
from odoo.exceptions import UserError


class AcmeTheftReport(models.TransientModel):
    _name = 'acme.theft.report'
    _description = 'Record stolen goods'

    product_id = fields.Many2one('product.product', required=True)
    location_id = fields.Many2one('stock.location', required=True, domain=[('usage', '=', 'internal')])
    quantity = fields.Float(required=True)
    police_report = fields.Char(required=True)

    def action_confirm(self):
        self.ensure_one()
        theft = self.env['stock.location'].search([
            ('company_id', '=', self.location_id.company_id.id),
            ('l10n_gr_theft', '=', True),  # search by the marker, never by name
        ], limit=1)
        if not theft:
            raise UserError(_('No stock theft and loss location for this company.'))
        self.env['stock.scrap'].create({
            'product_id': self.product_id.id, 'scrap_qty': self.quantity,
            'location_id': self.location_id.id, 'scrap_location_id': theft.id,
            'origin': _('Police report %s', self.police_report),
        }).action_validate()

A wholesaler links every wrong-shipment correction to the supplier's purchase order and tracks whether the claim was sent.

# Need: a wholesaler corrects wrong-product shipments and must link each correction
# to the supplier's purchase order, so the claim to the supplier can be followed up.
# depends: ['l10n_gr_nt_stock_transfer', 'purchase']
# The l10n.gr API is reached through the ORM (_inherit), never by importing from odoo.addons.l10n_gr_*.
from odoo import api, fields, models, _
from odoo.exceptions import ValidationError


class StockProductTransfer(models.Model):
    _inherit = 'l10n_gr.stock.product.transfer'

    acme_purchase_id = fields.Many2one('purchase.order', string='Supplier order', check_company=True)
    acme_claim_sent = fields.Boolean('Claim sent to supplier', tracking=True)

    @api.constrains('mode', 'acme_purchase_id')
    def _check_acme_purchase(self):
        for transfer in self:
            if transfer.mode == 'wrong_shipment' and not transfer.acme_purchase_id:
                raise ValidationError(_('A wrong-shipment correction needs the supplier order.'))

A distributor blocks posting a wrong-shipment correction without a photo of the goods and creates a follow-up for purchasing once it is posted.

# Need: the warehouse manager requires a photo of the goods before a wrong-shipment
# correction is posted, and the purchasing team must be told after posting.
# depends: ['l10n_gr_nt_stock_transfer']
# The l10n.gr API is reached through the ORM (_inherit), never by importing from odoo.addons.l10n_gr_*.
from odoo import models, _
from odoo.exceptions import UserError


class StockProductTransfer(models.Model):
    # the transfer has mail.thread only; add activities to schedule follow-ups
    _inherit = ['l10n_gr.stock.product.transfer', 'mail.activity.mixin']

    def action_post(self):
        Attachment = self.env['ir.attachment']
        wrong = self.filtered(lambda t: t.mode == 'wrong_shipment')
        for transfer in wrong:
            if not Attachment.search_count([('res_model', '=', self._name), ('res_id', '=', transfer.id)]):
                raise UserError(_('Attach a photo of the goods to %s before posting.', transfer.display_name))
        res = super().action_post()  # suite checks, numbering and stock moves happen here
        for transfer in wrong:
            transfer.activity_schedule(
                'mail.mail_activity_data_todo',
                summary=_('Claim the wrong shipment from the supplier'),
                user_id=transfer.create_uid.id,
            )
        return res

When a posted transfer is reversed, the reversal keeps the link to the supplier order and the accountant gets a task to check its value.

# Need: reversals must keep the supplier order link and alert the accountant,
# because the reversal is valued at today's cost and the figures will differ.
# depends: ['l10n_gr_nt_stock_transfer', 'purchase']
# The l10n.gr API is reached through the ORM (_inherit), never by importing from odoo.addons.l10n_gr_*.
from odoo import fields, models, _


class StockProductTransfer(models.Model):
    # the transfer has mail.thread only; add activities to schedule follow-ups
    _inherit = ['l10n_gr.stock.product.transfer', 'mail.activity.mixin']

    acme_purchase_id = fields.Many2one('purchase.order', string='Supplier order')

    def action_reverse(self):
        res = super().action_reverse()  # works on one transfer and posts the reversal
        reversal = self.reversed_by_id
        reversal.acme_purchase_id = self.acme_purchase_id
        accountant = self.env.ref('account.group_account_manager').user_ids[:1]
        reversal.activity_schedule(
            'mail.mail_activity_data_todo',
            summary=_('Check the value of the reversal of %s', self.name),
            user_id=(accountant or self.env.user).id,
        )
        return res

A wholesaler turns the warehouse's weekly box-split file into one numbered conversion document, with box quantities going out and piece quantities coming in.

# Need: a cosmetics wholesaler splits boxes into pieces every week from a CSV the
# warehouse exports (box_sku;piece_sku;boxes;pieces_per_box). Run in odoo-bin shell (env given).
# depends (of the module the data belongs to): ['l10n_gr_nt_stock_transfer']
# The l10n.gr API is reached through the ORM (env[...]), never by importing from odoo.addons.l10n_gr_*.
import csv

from odoo import Command

Product = env['product.product']
stock = env['stock.warehouse'].search([('company_id', '=', env.company.id)], limit=1).lot_stock_id
with open('/tmp/box_split.csv', newline='', encoding='utf-8') as f:
    rows = list(csv.DictReader(f, delimiter=';'))
lines = []
for row in rows:
    box = Product.search([('default_code', '=', row['box_sku'])], limit=1)
    piece = Product.search([('default_code', '=', row['piece_sku'])], limit=1)
    if not (box and piece):
        print('skipped, unknown item:', row['box_sku'], row['piece_sku'])
        continue
    boxes = float(row['boxes'])
    lines.append(Command.create({
        'product_id': box.id, 'quantity': boxes,
        # different units (box -> pieces): set dest_quantity yourself
        'dest_product_id': piece.id, 'dest_quantity': boxes * float(row['pieces_per_box']),
    }))
transfer = env['l10n_gr.stock.product.transfer'].create({
    'mode': 'conversion', 'location_id': stock.id,
    'reason': 'Weekly box split', 'line_ids': lines,
})
transfer.action_post()
env.cr.commit()

A stock-loss report shows each item's adjustments and scrap over 90 days without counting the stock moved out by product-to-product transfers.

# Need: a stock-loss report per item over 90 days (inventory adjustments and scrap).
# Product transfers also leave stock through an inventory-type location, but they are not losses.
# depends: ['l10n_gr_nt_stock_transfer']
# The l10n.gr API is reached through the ORM, never by importing from odoo.addons.l10n_gr_*.
from datetime import timedelta

from odoo import fields, models


class ProductProduct(models.Model):
    _inherit = 'product.product'

    acme_loss_qty_90d = fields.Float('Lost in 90 days', compute='_compute_acme_loss_qty_90d')

    def _compute_acme_loss_qty_90d(self):
        since = fields.Datetime.now() - timedelta(days=90)
        groups = self.env['stock.move']._read_group([
            ('product_id', 'in', self.ids),
            ('state', '=', 'done'),
            ('date', '>=', since),
            ('location_id.usage', '=', 'internal'),
            ('location_dest_id.usage', '=', 'inventory'),
            ('l10n_gr_transfer_id', '=', False),  # leave product transfers out
        ], ['product_id'], ['product_qty:sum'])
        qty = {product.id: total for product, total in groups}
        for product in self:
            product.acme_loss_qty_90d = qty.get(product.id, 0.0)

A scheduled action fills the missing TARIC codes of purchased items from the valid codes suppliers put on their received invoices.

# Need: before 1/1/2028, fill the missing TARIC codes of purchased items from what the
# suppliers already send on their invoices, matched through the supplier's product code.
# depends: ['l10n_gr_nt_taric']
# The l10n.gr API is reached through the ORM, never by importing from odoo.addons.l10n_gr_*.
from odoo import api, models, _


class ProductTemplate(models.Model):
    _inherit = 'product.template'

    @api.model
    def _cron_acme_taric_from_suppliers(self):
        Taric = self.env['l10n_gr.taric.code']
        lines = self.env['l10n_gr.mydata.received.line'].search([
            ('l10n_gr_taric_no', '!=', False), ('item_code', '!=', False),
            ('doc_id.partner_id', '!=', False),
        ])
        for line in lines:
            info = self.env['product.supplierinfo'].search([
                ('partner_id', '=', line.doc_id.partner_id.id),
                ('product_code', '=', line.item_code),
            ], limit=1)
            tmpl = info.product_tmpl_id
            if tmpl and not tmpl.l10n_gr_taric_no and Taric._l10n_gr_find(line.l10n_gr_taric_no, on_date=line.doc_id.issue_date):
                tmpl.l10n_gr_taric_no = line.l10n_gr_taric_no  # we write our item, never the supplier's line
                tmpl.message_post(body=_('TARIC code taken from %s.', line.doc_id.partner_id.display_name))

A partner migrating from a legacy ERP converts the old 8-digit customs codes into TARIC codes and gets a list of items that need a human decision.

# Need: migration from a legacy ERP that kept 8-digit customs (CN) codes on items.
# Map each to the single declarable 10-digit TARIC code valid today under it; list the rest for review.
# Run in odoo-bin shell (env given). depends: ['l10n_gr_nt_taric']
# The l10n.gr API is reached through the ORM (env[...]), never by importing from odoo.addons.l10n_gr_*.
import csv

Taric = env['l10n_gr.taric.code']
review = []
with open('/tmp/legacy_items.csv', newline='', encoding='utf-8') as f:
    for row in csv.DictReader(f, delimiter=';'):  # columns: sku;cn8
        tmpl = env['product.template'].search([('default_code', '=', row['sku'])], limit=1)
        candidates = Taric.search([
            ('code', '=like', row['cn8'] + '%'),
            ('declarable', '=', True),
        ]).filtered(lambda c: Taric._l10n_gr_find(c.code))  # keep codes valid today
        if tmpl and len(candidates) == 1:
            tmpl.l10n_gr_taric_no = candidates.code
        else:
            review.append((row['sku'], row['cn8'], ', '.join(candidates.mapped('code'))))
env.cr.commit()
for sku, cn8, options in review:
    print(sku, cn8, options or 'no declarable code')

An item import refuses any TARIC code that is not a declarable code valid on the obligation date, so bad codes never reach the item catalogue.

# Need: items come in daily from a supplier price-list import; a code that is not valid
# on 1/1/2028 must be rejected at save time, not discovered when a delivery note is blocked.
# depends: ['l10n_gr_nt_taric']
# The l10n.gr API is reached through the ORM, never by importing from odoo.addons.l10n_gr_*.
from odoo import api, fields, models, _
from odoo.exceptions import ValidationError


class ProductTemplate(models.Model):
    _inherit = 'product.template'

    @api.constrains('l10n_gr_taric_no')
    def _check_acme_taric_valid(self):
        Taric = self.env['l10n_gr.taric.code']
        deadline = fields.Date.to_date('2028-01-01')
        for tmpl in self.filtered('l10n_gr_taric_no'):
            if not Taric._l10n_gr_find(tmpl.l10n_gr_taric_no, on_date=deadline):
                raise ValidationError(_(
                    '%(item)s: TARIC code %(code)s is not a declarable code valid on 1/1/2028.',
                    item=tmpl.display_name, code=tmpl.l10n_gr_taric_no))

An exporter prints each item's TARIC code and official description under the product on the delivery note.

<!-- Need: an exporter's customers ask for the TARIC code and its official description
     under each item on the validated delivery note. -->
<!-- depends: ['l10n_gr_nt_taric', 'stock'] -->
<odoo>
    <!-- lines grouped by product (lots not printed) -->
    <template id="acme_delivery_aggregated_taric" inherit_id="stock.stock_report_delivery_aggregated_move_lines">
        <xpath expr="//tr/td[1]" position="inside">
            <t t-set="taric" t-value="aggregated_lines[line]['product'].product_tmpl_id.with_company(o.company_id).l10n_gr_taric_code_id"/>
            <div t-if="taric" class="text-muted small">
                TARIC <span t-out="taric.code"/>: <span t-out="taric.complete_name"/>
            </div>
        </xpath>
    </template>
    <!-- one line per lot or serial number -->
    <template id="acme_delivery_serial_taric" inherit_id="stock.stock_report_delivery_has_serial_move_line">
        <xpath expr="//td[1]" position="inside">
            <t t-set="taric" t-value="move_line.product_id.product_tmpl_id.with_company(o.company_id).l10n_gr_taric_code_id"/>
            <div t-if="taric" class="text-muted small">
                TARIC <span t-out="taric.code"/>: <span t-out="taric.complete_name"/>
            </div>
        </xpath>
    </template>
</odoo>

A weekly scheduled action gives the product manager a task for every item whose TARIC code is missing, unknown or ending before the obligation date.

# Need: every Monday until the obligation date, the product manager gets one task per
# item that still has a missing, unknown or ending TARIC code.
# depends: ['l10n_gr_nt_taric']
# The l10n.gr API is reached through the ORM, never by importing from odoo.addons.l10n_gr_*.
from odoo import api, models, _


class ProductTemplate(models.Model):
    _inherit = 'product.template'

    @api.model
    def _cron_acme_taric_todo(self):
        manager = self.env.ref('stock.group_stock_manager').user_ids[:1] or self.env.user
        summary = _('Fix the TARIC code')
        items = self.search([('type', '=', 'consu'), ('sale_ok', '=', True)])
        # the status is computed, not stored: filter in Python, not in the domain
        todo = items.filtered(lambda t: t.l10n_gr_taric_status in ('missing', 'unknown', 'ending'))
        open_ids = self.env['mail.activity'].search([
            ('res_model', '=', self._name), ('res_id', 'in', todo.ids), ('summary', '=', summary),
        ]).mapped('res_id')
        for tmpl in todo - self.browse(open_ids):
            tmpl.activity_schedule('mail.mail_activity_data_todo', summary=summary, user_id=manager.id)

A gym chain defines membership plans that are offered only in the branches chosen on each plan.

# Need: a gym chain sells membership plans that exist only in some of its branches.
# depends: ['nt_multi_branch']
# The l10n.gr API is reached through the ORM (_inherit), never by importing from odoo.addons.*.
from odoo import fields, models


class AcmeMembershipPlan(models.Model):
    _name = 'acme.membership.plan'
    _description = 'Membership plan'
    _inherit = ['nt.multi.branch.mixin']

    name = fields.Char(required=True, translate=True)
    monthly_fee = fields.Monetary(currency_field='currency_id')
    currency_id = fields.Many2one('res.currency', default=lambda self: self.env.company.currency_id)
    # own relation name, as the suite does for each model
    nt_branch_ids = fields.Many2many(relation='acme_membership_plan_branch_rel')

# The mixin adds no record rule on your model. To hide plans from other branches, add one:
# domain_force: ['|', ('nt_branch_ids', '=', False), ('nt_branch_ids', 'in', company_ids)]

An EDI order import for a branch keeps only the lines that branch sells and returns the other item codes to the customer as rejected.

# Need: B2B orders arrive by EDI for a given branch; lines for products that branch does
# not sell are returned to the customer as rejected instead of failing the whole order.
# depends: ['nt_multi_branch', 'sale']
# The l10n.gr API is reached through the ORM, never by importing from odoo.addons.*.
from odoo import Command, api, models


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    @api.model
    def _acme_create_from_edi(self, branch, partner, edi_lines):
        """edi_lines: [{'sku': ..., 'qty': ...}]. Returns (order, rejected skus)."""
        accepted, rejected = [], []
        for row in edi_lines:
            product = self.env['product.product'].search([('default_code', '=', row['sku'])], limit=1)
            if product and product.product_tmpl_id._nt_available_in(branch):
                accepted.append(Command.create({'product_id': product.id, 'product_uom_qty': row['qty']}))
            else:
                rejected.append(row['sku'])
        order = self.with_company(branch).create({
            'company_id': branch.id, 'partner_id': partner.id, 'order_line': accepted,
        }) if accepted else self.browse()
        return order, rejected

On a quotation, the pricelist field offers only the pricelists available in the branch of that order.

# Need: a salesperson who works for several branches must see on a quotation only the
# pricelists available in the branch of that order, not in the branches selected in the switcher.
# depends: ['nt_multi_branch', 'sale']
# The l10n.gr API is reached through the ORM (_inherit), never by importing from odoo.addons.*.
from odoo import fields, models


class SaleOrder(models.Model):
    _inherit = 'sale.order'

    # «empty or contains the branch»: empty means available in every branch
    pricelist_id = fields.Many2one(
        domain="['|', ('company_id', '=', False), ('company_id', 'parent_of', company_id),"
               " '|', ('nt_branch_ids', '=', False), ('nt_branch_ids', 'in', [company_id])]",
    )

A partner migrating from a legacy ERP sets, item by item, the branches that sell each product, leaving it open to every branch when the old system had no restriction.

# Need: migration from a legacy ERP that kept, per item, the stores that sell it
# (sku;stores, stores as 'ATH|PAT'). Empty in the file means every branch.
# Run in odoo-bin shell (env given). depends: ['nt_multi_branch']
# The l10n.gr API is reached through the ORM (env[...]), never by importing from odoo.addons.*.
import csv

from odoo import Command

# legacy store code -> branch company; adjust the names to the customer's branches
branches = {
    'ATH': env['res.company'].search([('name', '=', 'Acme Αθήνα')], limit=1),
    'PAT': env['res.company'].search([('name', '=', 'Acme Πάτρα')], limit=1),
}
with open('/tmp/item_stores.csv', newline='', encoding='utf-8') as f:
    for row in csv.DictReader(f, delimiter=';'):
        tmpl = env['product.template'].search([('default_code', '=', row['sku'])], limit=1)
        if not tmpl:
            continue
        codes = [c for c in row['stores'].split('|') if c]
        ids = [branches[c].id for c in codes if branches.get(c)]
        tmpl.nt_branch_ids = [Command.set(ids)] if ids else [Command.clear()]
env.cr.commit()

A bakery chain's new branch gets a POS whose receipts carry the branch's own name and address instead of the head store's.

# Need: a bakery chain opens new branches often; each new branch's POS must print its
# own name and address on the receipt, not those of the head store it was copied from.
# depends: ['nt_multi_branch', 'point_of_sale']
# The l10n.gr API is reached through the ORM (_inherit), never by importing from odoo.addons.*.
from odoo import models, _


class ResCompany(models.Model):
    _inherit = 'res.company'

    def _nt_branch_pos_vals(self, source, vals):
        vals = super()._nt_branch_pos_vals(source, vals)  # always first: other modules use this hook
        address = ', '.join(filter(None, [self.street, self.zip, self.city]))
        vals.update({
            'name': _('%s POS', self.name),
            'is_header_or_footer': True,
            'receipt_header': '%s\n%s' % (self.name, address),
        })
        return vals

A scheduled action flags every inter-branch receipt still open three days after the sending delivery was validated.

# Need: goods sent between branches must be received within 3 days; the receiving
# branch's warehouse manager gets a task for every receipt still open after that.
# depends: ['nt_multi_branch', 'stock']
# The l10n.gr API is reached through the ORM, never by importing from odoo.addons.*.
from datetime import timedelta

from odoo import api, fields, models, _


class StockPicking(models.Model):
    _inherit = 'stock.picking'

    @api.model
    def _cron_acme_late_branch_receipts(self):
        late = self.search([
            ('nt_transit_source_id', '!=', False),
            ('nt_transit_source_id.date_done', '<', fields.Datetime.now() - timedelta(days=3)),
            ('state', 'not in', ('done', 'cancel')),
            ('activity_ids', '=', False),
        ])
        managers = self.env.ref('stock.group_stock_manager').user_ids
        for receipt in late:
            manager = receipt.user_id or managers.filtered(lambda u: receipt.company_id in u.company_ids)[:1]
            receipt.activity_schedule(
                'mail.mail_activity_data_todo',
                summary=_('Goods sent with %s not received yet', receipt.nt_transit_source_id.name),
                user_id=(manager or self.env.user).id,
            )