API της σουίτας l10n.gr για συνεργάτες

Ο λογιστής θέλει κάθε κατηγορία ειδών να έχει σταθερή κατηγορία εξόδου myDATA, ώστε οι αγορές της να χαρακτηρίζονται πάντα με τον ίδιο τρόπο.

# 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))

Ένας πελάτης που μεταφέρεται από παλαιό ERP χρειάζεται να αντιστοιχίσει τους δικούς του κωδικούς εξόδων στους επίσημους κωδικούς Ε3 πριν καταχωριστεί η πρώτη αγορά στο 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()

Μια επιχείρηση που πουλά χονδρικά και μέσω e-shop θέλει κάθε ομάδα πωλήσεων να συνδέεται με την κατηγορία εσόδου myDATA που της αντιστοιχεί, ώστε τα έσοδα να ελέγχονται ανά κατηγορία.

# 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')

Κατά τη μετάπτωση από παλαιό ERP, ο συνεργάτης τηρεί έναν πίνακα αντιστοίχισης, ελεγμένο από τον λογιστή, που μετατρέπει κάθε παλαιό κωδικό εσόδου σε κατηγορία εσόδου myDATA και κωδικό Ε3.

# 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)

Στο κλείσιμο του μήνα ο λογιστής θέλει έναν πίνακα με το πλήθος των παραστατικών κάθε τύπου ΑΑΔΕ που εκδόθηκαν, για να τον συγκρίνει με τη σύνοψη του myDATA.

# 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))]

Το προσωπικό της αποθήκης που μεταφέρει εμπορεύματα μεταξύ των εγκαταστάσεων της εταιρείας πρέπει να βλέπει μόνο τους σκοπούς διακίνησης που ισχύουν για εσωτερικές μεταφορές.

# 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'}

Ο λογιστής χρειάζεται τις καθαρές πωλήσεις του μήνα ανά κατηγορία ΦΠΑ του myDATA, για να τις συμφωνήσει με την περιοδική δήλωση ΦΠΑ.

# 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

Ένας πελάτης που αγοράζει με απαλλαγή ΦΠΑ βάσει συγκεκριμένης διάταξης δεν πρέπει ποτέ να λάβει επιβεβαιωμένη παραγγελία με φόρο που αναφέρει διαφορετικό λόγο απαλλαγής.

# 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()

Η ειδική εκτύπωση τιμολογίου που σχεδιάζει ο συνεργάτης για τον πελάτη πρέπει να τυπώνει, σε κάθε τιμολόγιο με απαλλαγή ΦΠΑ, τη διατύπωση της διάταξης που ισχύει σήμερα.

<!-- 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>

Το τμήμα αγορών θέλει να βλέπει σε κάθε παραστατικό ελεύθερου επαγγελματία το ποσό που θα παρακρατηθεί, με τον επίσημο κωδικό και συντελεστή παρακράτησης της ΑΑΔΕ.

# 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)

Μετά από μετάπτωση, ο συνεργάτης θέλει έναν εβδομαδιαίο έλεγχο που επισημαίνει κάθε φόρο ΦΠΑ χωρίς κατηγορία ΦΠΑ myDATA, πριν φτάσουν στην προθεσμία υποβολής τα τιμολόγια που τον χρησιμοποιούν.

# 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.

Ο λογιστής μιας εξαγωγικής επιχείρησης χρειάζεται κάθε τρίμηνο τα σύνολα των πωλήσεων με απαλλαγή ΦΠΑ ανά λόγο απαλλαγής, για να τα συμφωνήσει με τη δήλωση ΦΠΑ.

# 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)]

Το τμήμα εισπράξεων χρειάζεται λίστα με τα καταχωρημένα τιμολόγια που φέρουν φόρο παρακράτησης, ώστε να ζητά από κάθε πελάτη τη βεβαίωση παρακράτησης.

# 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')]"/>

Ένας προμηθευτής νοσοκομείων και υπουργείων θέλει κάθε τιμολόγιο προς το Δημόσιο να δημιουργεί υπενθύμιση είσπραξης για το αρμόδιο τμήμα, επειδή οι φορείς πληρώνουν με καθυστέρηση.

# 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

Ένας προμηθευτής νοσοκομείων πρέπει να καταγράφει σε κάθε παραγγελία την αναφορά αγοραστή που δίνει το νοσοκομείο, ώστε η καταχώρηση του τιμολογίου να μη σταματά σε αυτόν τον έλεγχο.

# 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

Μια επιχείρηση που κερδίζει δημόσιους διαγωνισμούς θέλει ο ΑΔΑΜ της σύμβασης να καταχωρίζεται μία φορά στην παραγγελία και να μεταφέρεται σε κάθε τιμολόγιο που εκδίδεται βάσει αυτής.

# 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

Ένας προμηθευτής υπουργείου με πολλές αναθέτουσες αρχές κάτω από τον ίδιο ΑΦΜ θέλει κάθε τιμολόγιο να φέρει τον κωδικό της αρχής που αντιστοιχεί στη διεύθυνση παράδοσης.

# 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

Ο συνεργάτης που εισάγει λίστα πελατών του Δημοσίου πρέπει πρώτα να καθαρίσει τους κωδικούς αναθέτουσας αρχής, γιατί συχνά περιέχουν ελληνικά γράμματα που μοιάζουν με λατινικά και το πεδίο δεν τους δέχεται.

# 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()

Μια επιχείρηση που πουλά και αγαθά και υπηρεσίες θέλει οι παραγγελίες που περιέχουν μόνο υπηρεσίες να τιμολογούνται αυτόματα από τη σειρά του Τιμολογίου Παροχής Υπηρεσιών.

# 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

Ένας διανομέας ποτών χρειάζεται τα τέλη ανακύκλωσης που εισέπραξε κάθε μήνα, μετά την αφαίρεση των πιστωτικών, για να υποβάλει τη μηνιαία δήλωση τελών.

# 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

Μια εταιρεία με στόλο επιβατικών αυτοκινήτων θέλει να αποτρέπεται η καταχώριση τιμολογίων καυσίμων ή μισθώσεων με εκπιπτόμενο ΦΠΑ.

# 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()

Κατά τη μετάπτωση των ειδών ο συνεργάτης πρέπει να αντιστοιχίσει κάθε παλαιό κωδικό ΦΠΑ στον σωστό φόρο πωλήσεων και αγορών, ακόμη κι αν οι χρήστες έχουν μετονομάσει τους φόρους.

# 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()

Πριν από την έναρξη λειτουργίας, ο συνεργάτης θέλει μια λίστα με τα τέλη ανά τεμάχιο που δεν έχει ελέγξει ακόμη ο λογιστής, μαζί με το πλήθος των ειδών που χρησιμοποιούν το καθένα.

# 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.

Ένας διανομέας ποτών που εισάγει τον κατάλογο του προμηθευτή του θέλει κάθε είδος σε πλαστική φιάλη να παίρνει αυτόματα το τέλος ανακύκλωσης.

# 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()

Ένα κατάστημα που πουλά και υπηρεσίες εγκατάστασης θέλει οι υπηρεσίες αυτές να χαρακτηρίζονται ως έσοδο από παροχή υπηρεσιών στο myDATA, παρότι χρησιμοποιούν τον ίδιο λογαριασμό εσόδων με τα αγαθά.

# 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()

Ένας χονδρέμπορος σε νησί, όταν μεταφέρει τους πελάτες του στο Odoo, θέλει να ορίσει το καθεστώς μειωμένου ΦΠΑ νησιών μόνο στους πελάτες που το δικαιούνται.

# 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()

Ένας πωλητής αγαθών του άρθρου 45 θέλει οι προσφορές προς τους αγοραστές που εμπίπτουν στη διάταξη να αναφέρουν εξαρχής ότι για τα αγαθά αυτά ισχύει αντίστροφη επιβάρυνση ΦΠΑ.

<!-- 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>

Μια εταιρεία που περνά στο νέο λογιστικό σχέδιο πρέπει να καταχωρίσει στους αντίστοιχους νέους λογαριασμούς τα υπόλοιπα έναρξης, που εξάγονται από το παλαιό ERP με τους παλαιούς κωδικούς λογαριασμών.

# 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()

Ο προμηθευτής ενός εμπόρου στην ΕΕ στέλνει τα αγαθά απευθείας στον πελάτη του, επίσης στην ΕΕ. Ο έμπορος θέλει οι πωλήσεις αυτές να σημειώνονται ως τριγωνικές, ώστε να καταχωρίζονται στη σωστή στήλη του ανακεφαλαιωτικού πίνακα.

# 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

Μια μικρή επιχείρηση που υπάγεται στο καθεστώς απαλλαγής ΦΠΑ δεν πρέπει να επιβεβαιώνει παραγγελία στην οποία κάποια γραμμή εξακολουθεί να χρεώνει ΦΠΑ.

# 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()

Το τιμολόγιο που επέχει θέση δελτίου αποστολής τυπώνει τον αριθμό του δελτίου, το όχημα και την τρέχουσα κατάσταση της διακίνησης.

<!-- 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>

Το σύστημα αποθήκης κρατά τη δική του αναφορά αποστολής σε κάθε δελτίο και αντλεί τα δελτία που δεν έχουν ολοκληρωθεί.

# 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')

Τα εισερχόμενα δελτία αποστολής με κωδικούς του παλαιού ERP του προμηθευτή αντιστοιχίζονται αυτόματα στα σωστά είδη.

# 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)

Το εξωτερικό WMS ή ο κόμβος EDI ενημερώνεται μόλις μια παράδοση ολοκληρωθεί, αποτύχει ή ξεκινήσει η επιστροφή της.

# 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)

Η οθόνη διανομής μετρά τις παραδόσεις που βρίσκονται ακόμη καθ' οδόν ανά φορτηγό του στόλου της εταιρείας.

# 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]

Η διοίκηση παρακολουθεί τη συνέπεια των παραδόσεων συγκρίνοντας τον χρόνο παράδοσης με την προγραμματισμένη ημερομηνία της διακίνησης.

# 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)
            )

Ο υπεύθυνος logistics λαμβάνει μηνιαία αναφορά με τις πλήρεις, μερικές και αποτυχημένες παραδόσεις ανά οδηγό.

# 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

Το email αποστολής του e-shop δίνει στον αγοραστή σύνδεσμο παρακολούθησης της παράδοσης, μόνο όταν ο σύνδεσμος υπάρχει.

<!-- 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>

Οι πωλητές βλέπουν σε κάθε παραγγελία την κατάσταση ΑΑΔΕ των παραδόσεών της χωρίς να ανοίξουν τις διακινήσεις.

# 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

Τα οχήματα του Στόλου δημιουργούνται ή αρχειοθετούνται αυτόματα ως οχήματα διακίνησης.

# 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

Το γραφείο λαμβάνει στο τέλος της ημέρας σύνοψη με τις ποσότητες που φορτώθηκαν, πωλήθηκαν, επιστράφηκαν και απομένουν σε κάθε δρομολόγιο πώλησης επί αυτοκινήτου.

# 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)

Ένα module προγραμματισμού δημιουργεί δρομολόγια διανομής από τις έτοιμες παραδόσεις της ημέρας, ώστε η σουίτα να εκδίδει ένα δελτίο αποστολής ανά στάση.

# 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)],
        })

Το μήνυμα EDI αποστολής προς αλυσίδα λιανικής περιλαμβάνει τον αριθμό και την κατάσταση του δελτίου αποστολής της διακίνησης.

# 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
            ],
        }

Κάθε δρομολόγιο πώλησης επί αυτοκινήτου εμφανίζει πόσες πωλήσεις ολοκληρώθηκαν στις στάσεις του, για σύγκριση μεταξύ δρομολογίων.

# 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)

Ένας ημερήσιος έλεγχος επισημαίνει παραδόσεις με αποδεικτικό που υπογράφηκε μακριά από τη διεύθυνση του πελάτη ή χωρίς θέση συσκευής.

# 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,
            )

Το module διανομής αναθέτει κάθε δρομολόγιο σε συγκεκριμένο οδηγό, ώστε μόνο αυτός να το βλέπει στη συσκευή του.

# 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

Οι λογαριασμοί εξόδων που προσθέτει ο συνεργάτης για τον πελάτη συνδέονται κατά την εγκατάσταση με τη σωστή γραμμή της Κατάστασης Φορολογικής Αναμόρφωσης.

# 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})

Ένας προγραμματισμένος έλεγχος ανανεώνει τη σύγκριση Ε3 με το myDATA και δημιουργεί εργασία για τον λογιστή όταν η δήλωση θα απορριπτόταν.

# 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,
            )

Κατά τη μετάπτωση, η αντιστοίχιση λογαριασμών εξόδων με γραμμές αναμόρφωσης, όπως υπήρχε στο παλαιό ERP, φορτώνεται με βάση τον κωδικό γραμμής.

# 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()

Το πακέτο κλεισίματος χρήσης για τη διοίκηση περιλαμβάνει το σύνολο της αναμόρφωσης, το ποσό του Ε3 και τα παραστατικά που δεν έχουν ακόμη εγγραφή αναμόρφωσης.

# 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,
        }

Τα είδη ομαδοποιούνται σε λογιστικές κατηγορίες που ταιριάζουν στον κατάλογο του πελάτη, ώστε οι γραμμές των τιμολογίων να προτείνουν τους σωστούς χαρακτηρισμούς.

# 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

Η μετάπτωση από παλαιό ERP μεταφράζει τους κωδικούς πληρωμής του στους τρόπους πληρωμής της ΑΑΔΕ.

# 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}

Ένας νέος τρόπος πληρωμής του e-shop αντιστοιχίζεται στον τρόπο πληρωμής της ΑΑΔΕ με τον οποίο πρέπει να δηλώνεται.

<!-- 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>

Τα είδη που εισάγονται από το παλαιό ERP λαμβάνουν λογιστική κατηγορία βάσει της παλαιάς ομάδας ειδών.

# 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()

Ένας εισαγωγέας ενδοκοινοτικών αγαθών φορτώνει τους κωδικούς TARIC από τους τιμοκαταλόγους των προμηθευτών στη δεκαψήφια μορφή που απαιτούν τα παραστατικά.

# 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

Ένας προμηθευτής του Δημοσίου δεν μπορεί να επιβεβαιώσει παραγγελία φορέα του Δημοσίου πριν αποκτήσουν όλα τα είδη κωδικό CPV.

# 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()

Οι πωλητές ενημερώνονται ήδη στην προσφορά ότι παραγγελία ιδιώτη ίση ή μεγαλύτερη από το όριο μετρητών πρέπει να εξοφληθεί ηλεκτρονικά.

# 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)),
            }}

Μια προσαρμοσμένη διάταξη παραστατικών τυπώνει τον αριθμό άδειας του πιστοποιημένου παρόχου ηλεκτρονικής τιμολόγησης μέσω του οποίου εκδίδει η εταιρεία.

<!-- 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>

Οι ανώνυμες ημερήσιες πωλήσεις από εξωτερικό ταμείο καταχωρίζονται ως πρόχειρα στην επαφή λιανικής της εταιρείας.

# 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

Μια εταιρεία που εκδίδει η ίδια τα παραστατικά των προμηθευτών της επισυνάπτει κάθε υπογεγραμμένη συμφωνία από τη ροή εγγράφων και εντοπίζει τους προμηθευτές χωρίς συμφωνία.

# 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),
        ])

Μια νέα μονάδα μέτρησης που χρησιμοποιείται στα τιμολόγια αντιστοιχίζεται στον τύπο ποσότητας της ΑΑΔΕ με τον οποίο δηλώνεται.

<!-- 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>

Οι συναλλαγές εταιρικής κάρτας που εισάγονται ως δαπάνες φτάνουν με ήδη συμπληρωμένη την κατηγορία εξόδου myDATA.

# 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),
        })

Μια προσαρμοσμένη διάταξη τιμολογίου τυπώνει τα τέλη, το χαρτόσημο ή τις παρακρατήσεις που εφαρμόζονται σε ολόκληρο το παραστατικό.

<!-- 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>

Μια επιχείρηση λιανικής αναλύει τις πωλήσεις της ανά ώρα έκδοσης, σε τοπική ώρα.

# 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()))

Μια προγραμματισμένη ενέργεια επισημαίνει παραστατικά με γραμμές χωρίς χαρακτηρισμό, ώστε ο λογιστής να τα διορθώσει πριν από την προθεσμία του myDATA.

# 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)

Τα τιμολόγια που επέχουν θέση δελτίου αποστολής για παραγγελίες δειγμάτων φέρουν σκοπό διακίνησης «Δειγματισμός» αντί για «Πώληση».

# 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

Τα τιμολόγια των παραγγελιών του e-shop συμπληρώνονται με τον τρόπο πληρωμής της ΑΑΔΕ που χρησιμοποίησε πράγματι ο πελάτης.

# 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

Τα τιμολόγια αγορών που παραλαμβάνονται μέσω myDATA χωρίς αντίστοιχη παραγγελία αγοράς προωθούνται στον υπεύθυνο αγορών για έλεγχο.

# 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,
            )

Στο τέλος του έτους, κάθε ελεύθερος επαγγελματίας λαμβάνει βεβαίωση αμοιβών και παρακρατηθέντος φόρου ανά κανόνα παρακράτησης.

# 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

Ο λογιστής βλέπει ανά μήνα πόσο φόρο παρακράτησε η εταιρεία από προμηθευτές και πόσο της παρακράτησαν οι πελάτες της.

# 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]

Ο ιδιοκτήτης του καταστήματος θέλει το σημείωμα κλεισίματος κάθε session του Point of Sale να δείχνει πόσες αποδείξεις και πόσα τιμολόγια εκδόθηκαν, με τα σύνολά τους.

# 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

Πέντε ημέρες πριν από την προθεσμία, ο λογιστής λαμβάνει υπενθύμιση για κάθε τιμολόγιο αγοράς από το myDATA που δεν έχει ακόμη χαρακτηρισμό εξόδων.

# 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,
            )

Ο οικονομικός διευθυντής θέλει κάθε παραστατικό προμηθευτή που χαρακτηρίζεται ως «αγνοείται» να έχει γραπτή αιτιολογία, ώστε να μην παραλείπεται σιωπηρά τίποτα από όσα δήλωσε ο προμηθευτής.

# 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.

Πριν από το κλείσιμο του μήνα, ο λογιστής βλέπει τα καθαρά ποσά και τον ΦΠΑ που δήλωσαν οι προμηθευτές σε παραστατικά που δεν έχουν καταχωριστεί ακόμη ως τιμολόγια αγοράς, ανά κατηγορία χαρακτηρισμού του εκδότη και κατηγορία ΦΠΑ.

# 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
        ]

Μετά από συγχώνευση ΔΟΥ, το back office λαμβάνει εκκρεμότητα για κάθε πελάτη που είναι ακόμη καταχωρισμένος σε καταργημένη ΔΟΥ, ώστε να επιβεβαιώσει τη νέα ΔΟΥ με τον πελάτη.

# 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

Κατά τη μετάπτωση από το παλαιό ERP, η ΔΟΥ κάθε πελάτη αντιστοιχίζεται από το ελεύθερο κείμενο του παλαιού συστήματος και οι ονομασίες που δεν αντιστοιχούν σε καμία ΔΟΥ συγκεντρώνονται για χειροκίνητο έλεγχο.

# 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)

Μια διασύνδεση EDI με αλυσίδα λιανικής λαμβάνει στοιχεία πελατών με τον κωδικό TAXIS της ΔΟΥ και, όταν ο κωδικός λείπει, αναζητά τη ΔΟΥ από την ονομασία της.

# 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

Ο λογιστής βλέπει στην επαφή τόσο τη ΔΟΥ που τυπώνεται στα παραστατικά όσο και τη ΔΟΥ που την εξυπηρετεί σήμερα, ώστε η αλληλογραφία να απευθύνεται στη σωστή υπηρεσία.

# 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

Μια προσαρμοσμένη μορφή προσφοράς τυπώνει τη νομική μορφή, τον αριθμό ΓΕΜΗ και τον ιστότοπο της εταιρείας μόνο όταν τα απαιτεί η νομική της μορφή.

<!-- 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>

Η επιβεβαίωση παραγγελίας που αποστέλλεται μέσω EDI σε αλυσίδα σούπερ μάρκετ περιλαμβάνει τον ΑΦΜ του πωλητή και του αγοραστή χωρίς πρόθεμα χώρας, όπως τον αναμένει η αλυσίδα.

# 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)
            ],
        }

Μια προσαρμοσμένη αναφορά καρτέλας πελάτη εμφανίζει τον ΑΦΜ και τη ΔΟΥ της εταιρείας ακριβώς όπως εμφανίζονται στα τιμολόγιά της.

<!-- 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>

Πριν από την έκδοση του πρώτου τιμολογίου, ο σύμβουλος ελέγχει με ένα κουμπί ποιες ενδείξεις που απαιτεί ο νόμος λείπουν ακόμη από τα παραστατικά της εταιρείας.

# 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'},
        }

Ένα προσαρμοσμένο υποσέλιδο παραστατικών τυπώνει το κεφάλαιο της εταιρείας μόνο όταν και όπως το απαιτεί η νομική της μορφή, για παράδειγμα και το καλυφθέν και το καταβεβλημένο κεφάλαιο για μια ΑΕ.

<!-- 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>

Κάθε βράδυ ελέγχονται ξανά στο VIES οι επιχειρήσεις-πελάτες της ΕΕ των οποίων ο ΑΦΜ δεν επιβεβαιώθηκε κατά τη δημιουργία τους, ώστε να μην καθυστερούν τα ενδοκοινοτικά τιμολόγια.

# 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)

Το αρχείο μαζικών πληρωμών προμηθευτών για την τράπεζα περιλαμβάνει τον ΑΦΜ κάθε προμηθευτή χωρίς πρόθεμα χώρας, όπως τον απαιτεί η τράπεζα.

# 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()

Η ετικέτα courier που τυπώνεται από κάθε παράδοση εμφανίζει την επωνυμία του πελάτη, την ίδια που φέρουν τα τιμολόγιά του.

<!-- 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>

Μια παραγγελία πώλησης προς ελληνική επιχείρηση δεν επιβεβαιώνεται πριν συμπληρωθεί η ΔΟΥ του πελάτη, ώστε το τιμολόγιο να μην εκδίδεται ποτέ χωρίς αυτήν.

# 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()

Το υποσέλιδο του ηλεκτρονικού καταστήματος του πελάτη εμφανίζει την επωνυμία, την έδρα σε μία γραμμή, τον ΑΦΜ, τη ΔΟΥ και τον αριθμό ΓΕΜΗ της εταιρείας.

<!-- 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>

Η διασύνδεση με εταιρεία courier αποστέλλει για κάθε παράδοση την οδό μαζί με τον αριθμό ως ενιαία τιμή, χωρίς να επαναλαμβάνει αριθμό που ήδη περιέχεται στην οδό.

# 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,
        }

Ο συγχρονισμός με το CRM αποθηκεύει τον αριθμό ΓΕΜΗ κάθε πελάτη αφού τον καθαρίσει, και καταγράφει σημείωση στην επαφή όταν ο αριθμός ανήκει ήδη σε άλλη επιχείρηση.

# 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

Κατά τη μετάπτωση από παλαιό ERP, η νομική μορφή κάθε πελάτη, που εκεί τηρείται ως κείμενο, ορίζεται στην επαφή ώστε τα παραστατικά να τυπώνουν τις σωστές ενδείξεις.

# 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]

Κατά τη μετάπτωση, κάθε πελάτης διατηρεί τον διακριτικό τίτλο ως όνομα επαφής και την επωνυμία του για τα παραστατικά, όπως τα τηρούσε το παλαιό ERP.

# 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,
            })

Ένα τιμολόγιο χωρίς ΦΠΑ προς επιχείρηση της ΕΕ καταχωρίζεται μόνο αφού το VIES επικυρώσει τον ΑΦΜ του πελάτη, με έναν νέο έλεγχο αν δεν είχε επιβεβαιωθεί προηγουμένως.

# 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()

Μια εξαγωγική εταιρεία τυπώνει τον νόμιμο ελληνικό τίτλο κάθε τιμολογίου μαζί με την αγγλική ονομασία του, όταν ο πελάτης δεν διαβάζει ελληνικά.

# 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

Οι χρήστες δεν μπορούν να καταχωρίσουν απόδειξη λιανικής για επιχείρηση-πελάτη με ΑΦΜ, ώστε οι πελάτες αυτοί να λαμβάνουν πάντα τιμολόγιο.

# 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()

Μια εταιρεία με κεντρική αποθήκη και πολλά καταστήματα θέλει τα αγαθά της αυτοπαράδοσης να εξέρχονται πάντα από την αποθήκη που έχει επιλέξει στις ρυθμίσεις της.

# 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()

Ο λογιστής λαμβάνει υπενθύμιση για κάθε καταχωρισμένο παραστατικό αυτοπαράδοσης που δεν έχει εγγραφή συμψηφισμού, ώστε να μη μένει ανοιχτό υπόλοιπο στον λογαριασμό της ίδιας της εταιρείας.

# 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'),
            )

Η αποθήκη τυπώνει για κάθε παραστατικό αυτοπαράδοσης ένα φύλλο με τα είδη, τις θέσεις και τις ποσότητες που εξήλθαν από το απόθεμα, προς υπογραφή.

<!-- 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>

Ο μηνιαίος πίνακας του ιδιοκτήτη εμφανίζει τις πωλήσεις χωριστά από την αυτοπαράδοση αγαθών και την ιδιοχρησιμοποίηση υπηρεσιών, ώστε ο κύκλος εργασιών να μην εμφανίζεται διογκωμένος.

# 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]

Η μηνιαία αναφορά του υπευθύνου αποθήκης δείχνει ανά είδος πόσο απόθεμα εξήλθε για αυτοπαράδοση, πόσο καταστράφηκε και πόσο πωλήθηκε.

# 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()
        }

Όταν καταχωρίζεται ένα τιμολόγιο, οι παραδόσεις που δηλώνει σημειώνονται με τον αριθμό του, ώστε το σύστημα διαχείρισης αποθήκης να τις κλείσει.

# 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

Ο υπεύθυνος δρομολογίων ορίζει το φορτηγό και την ώρα αναχώρησης στις παραδόσεις της επόμενης ημέρας, ώστε κάθε δελτίο αποστολής να τα αναγράφει χωρίς χειροκίνητη καταχώριση.

# 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

Όταν οι πωλητές στέλνουν δείγματα προϊόντων σε υποψήφιους πελάτες, ένα κουμπί ορίζει ως σκοπό διακίνησης τον δειγματισμό, ώστε το δελτίο αποστολής να μη δηλώνει πώληση.

# 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

Ο υπεύθυνος αποστολών καταχωρίζει μία φορά τον αριθμό κυκλοφορίας του φορτηγού σε μια ομάδα παραδόσεων, και τον αναγράφει κάθε δελτίο αποστολής της ομάδας.

# 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

Ένας διανομέας τροφίμων καταστρέφει με μία ενέργεια όλες τις ληγμένες παρτίδες και η ζημιά καταχωρείται στον λογαριασμό καταστροφής αποθεμάτων αντί για το κόστος πωληθέντων.

# 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()

Μια αλυσίδα λιανικής καταχωρεί τα κλεμμένα είδη με τον αριθμό της αστυνομικής δήλωσης, ώστε η ζημιά να πηγαίνει στον λογαριασμό κλοπής και απώλειας και όχι στο κόστος πωληθέντων.

# 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()

Ένας χονδρέμπορος συνδέει κάθε διόρθωση λανθασμένης αποστολής με την παραγγελία αγοράς του προμηθευτή και παρακολουθεί αν έχει σταλεί η απαίτηση.

# 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.'))

Ένας διανομέας δεν επιτρέπει την καταχώριση διόρθωσης λανθασμένης αποστολής χωρίς φωτογραφία των ειδών και, μετά την καταχώριση, δημιουργεί εργασία για το τμήμα αγορών.

# 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

Όταν αντιλογίζεται μια καταχωρισμένη μεταφορά, ο αντιλογισμός διατηρεί τη σύνδεση με την παραγγελία του προμηθευτή και ο λογιστής λαμβάνει εργασία να ελέγξει την αξία του.

# 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

Ένας χονδρέμπορος μετατρέπει το εβδομαδιαίο αρχείο ανοίγματος κιβωτίων της αποθήκης σε ένα αριθμημένο παραστατικό μετατροπής, με έξοδο των κιβωτίων και είσοδο των τεμαχίων.

# 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()

Μια αναφορά απωλειών αποθέματος δείχνει τις διορθώσεις απογραφής και τις καταστροφές κάθε είδους για 90 ημέρες, χωρίς να μετρά τις εξαγωγές από μεταφορές είδους σε είδος.

# 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)

Μια προγραμματισμένη ενέργεια συμπληρώνει τους κωδικούς TARIC που λείπουν από τα είδη αγοράς με τους έγκυρους κωδικούς που αναγράφουν οι προμηθευτές στα ληφθέντα παραστατικά τους.

# 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))

Ένας συνεργάτης που κάνει μετάπτωση από παλιό ERP μετατρέπει τους παλιούς οκταψήφιους δασμολογικούς κωδικούς σε κωδικούς TARIC και παίρνει λίστα με τα είδη που χρειάζονται απόφαση από άνθρωπο.

# 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')

Η εισαγωγή ειδών απορρίπτει κάθε κωδικό TARIC που δεν είναι δηλώσιμος και έγκυρος την ημερομηνία υποχρέωσης, ώστε λανθασμένοι κωδικοί να μη φτάνουν ποτέ στον κατάλογο ειδών.

# 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))

Ένας εξαγωγέας τυπώνει κάτω από κάθε είδος του δελτίου αποστολής τον κωδικό TARIC και την επίσημη περιγραφή του.

<!-- 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>

Μια εβδομαδιαία προγραμματισμένη ενέργεια αναθέτει στον υπεύθυνο ειδών μία εργασία για κάθε είδος με κωδικό TARIC που λείπει, είναι άγνωστος ή λήγει πριν από την ημερομηνία υποχρέωσης.

# 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)

Μια αλυσίδα γυμναστηρίων ορίζει προγράμματα συνδρομής που διατίθενται μόνο στα καταστήματα που επιλέγονται σε κάθε πρόγραμμα.

# 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)]

Η εισαγωγή παραγγελίας EDI για ένα κατάστημα κρατά μόνο τις γραμμές με είδη που πουλά το κατάστημα και επιστρέφει στον πελάτη τους υπόλοιπους κωδικούς ως απορριφθέντες.

# 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

Στην προσφορά, το πεδίο τιμοκαταλόγου προτείνει μόνο τους τιμοκαταλόγους που διατίθενται στο κατάστημα της συγκεκριμένης παραγγελίας.

# 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])]",
    )

Ένας συνεργάτης που κάνει μετάπτωση από παλιό ERP ορίζει ανά είδος τα καταστήματα που το πουλούν και το αφήνει διαθέσιμο σε όλα όταν το παλιό σύστημα δεν είχε περιορισμό.

# 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()

Το νέο κατάστημα μιας αλυσίδας αρτοποιείων αποκτά POS που τυπώνει στις αποδείξεις την επωνυμία και τη διεύθυνση του καταστήματος και όχι του κεντρικού.

# 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

Μια προγραμματισμένη ενέργεια επισημαίνει κάθε παραλαβή μεταξύ καταστημάτων που παραμένει ανοιχτή τρεις ημέρες μετά την επικύρωση της αποστολής.

# 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,
            )