Skip to main content
Journal Restriction For Users — A build-to-order Odoo accounting-security module that limits which journals each user can pos — 1/1Illustrative preview

A build-to-order Odoo accounting-security module that limits which journals each user can post,

view, and reconcile — so sales, purchase, bank, and cash entries stay walled off by role.

ECOSIRE scopes, builds, installs, and supports it on your Odoo 17, 18, or 19.

What is Journal Restriction For Users?

A build-to-order Odoo accounting-security module that limits which journals each user can post, view, and reconcile — so sales, purchase, bank, and cash entries stay walled off by role. ECOSIRE scopes, builds, installs, and supports it on your Odoo 17, 18, or 19. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Many-to-many mapping between `res.users` (or a configurable `account.security.role`) and `account.journal`, managed from a dedicated Settings menu
Enforcement via `ir.rule` record rules on `account.move`, `account.move.line`, `account.payment`, and `account.bank.statement` — server-side, not a UI-only filter
`@api.depends` compute that resolves each user's effective journal set from one or more assigned roles, so access is managed by role rather than per-user clicks
`check_journal_access()` guard on `create`/`write` of `account.move` that raises a clear `AccessError` when a user posts to a forbidden journal
Read and write scopes controlled independently — a user can be allowed to view a journal for reconciliation while blocked from posting to it
Restriction applies through XML-RPC/JSON-RPC as well as the web client, closing the API back-door that view-only patches leave open
Company-aware rules that intersect journal access with the user's `company_ids` for correct multi-company behavior
Invoicing and Vendor Bills dashboards, the reconciliation widget, and journal-item lists all respect the same rules automatically
`mail.thread` chatter on the access-role model so every change to entitlements is audit-logged with author and timestamp
Optional automated action / activity that notifies an accounting administrator when an access attempt is denied
Default-journal handling on Sales and Purchase so restricted users are steered to a permitted journal instead of hitting an error
Configurable bypass group (e.g. `account.group_account_manager`) so controllers and auditors retain full visibility
QWeb accounting reports and pivots honor the same record rules, preventing data leakage through exports
Clean, versioned `__manifest__.py` with no monkey-patching of core — upgrade-safe across Odoo 17.0, 18.0, and 19.0

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

  1. 1

    You order

    Start with a one-time build price. We scope it with you at kickoff.

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your Odoo.

  3. 3

    Go live + support

    You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.

Technical Specifications

Odoo Compatibility
Odoo 17, Odoo 18, Odoo 19
Editions
Enterprise & Community
License
Licence confirmation required
Python Requirement
Python 3.10+
Database
PostgreSQL 12+

About this Product

In a growing finance team, everyone with accounting rights can see and post to every journal. A junior AR clerk can raise vendor bills against the bank journal; a purchasing user can open sensitive payroll or intercompany entries; a branch bookkeeper can reconcile a bank they should never touch. Odoo's out-of-the-box accounting security is coarse — the account.group_account_user and account.group_account_manager groups grant near-blanket access to account.move and account.journal, and there is no native "this person may only work in these journals" control per user. Once entry volume and headcount grow, that gap becomes an audit finding and a fraud surface, not just an inconvenience.

We build a dedicated journal-restriction layer on top of Odoo's own security model rather than bolting on a fragile UI filter. The core is a many-to-many link between res.users (or a configurable account.security.role you assign to users) and account.journal, enforced by ir.rule record rules on account.move, account.move.line, account.payment, and account.bank.statement. Because the restriction is evaluated by the ORM inside record rules, it holds everywhere — form and list views, the reconciliation widget, the invoicing dashboards, XML-RPC/JSON-RPC API calls, scheduled/automated actions, and QWeb reports alike — not just on the screens we happened to patch. A restricted user simply never sees a document in a journal they aren't entitled to, and cannot post one there either.

Technically, the module ships as a proper Odoo addon: a versioned __manifest__.py declaring dependencies on account, security defined in ir.model.access.csv plus data-file ir.rule records, a small model layer (models.Model with the journal-access fields and a compute/@api.depends helper that resolves a user's effective journal set from their roles), and OWL/XML views to manage the mappings from Settings. We add a check_journal_access() guard invoked on create/write of account.move so a blocked write fails loudly with a clear AccessError rather than silently, and an optional automated action that alerts an administrator when access is denied. We honor mail.thread audit logging on the access-role model so every change to who-can-touch-what is tracked. Multi-company deployments get company-aware rules that intersect journal access with the user's allowed companies; Community and Enterprise are both supported, with Enterprise-only touches (like the accounting dashboard) handled when present.

Delivery is build-to-order: you request a quotation, we run a short scoping call to confirm your journals, roles, company structure, and edge cases (default journals on sales/purchase, POS and bank feeds, existing custom security), then we build, test on a staging copy, and install on your Odoo. Typical delivery is one working week from confirmed scope. Pricing starts from $999 (indicative, single-company base scope); multi-company intersection rules, deeper localization, integration with existing custom accounting security, and data migration of historical assignments increase the quoted scope. You receive a fixed quote after the scoping call — never a surprise.

What you get

  • Installable, versioned Odoo module source for your target version (17.0, 18.0, or 19.0) built to your confirmed scope
  • Installation and configuration on your environment, including role setup and initial journal-access mapping
  • Technical documentation: data model, `ir.rule` logic, security groups, and configuration reference
  • End-user guide plus a live training session for your accounting administrators
  • UAT on a staging copy of your database with a documented rollback plan before any production change
  • Post-go-live support window for defect fixes and configuration questions
  • Git repository handover with full commit history and tagged release
  • Compatibility notes and an upgrade checklist for future Odoo point releases

Who this is for

Finance Controller / CFO

Needs enforceable segregation of duties so AR, AP, bank, and payroll journals are only touched by the right people — and needs it to survive an external audit, not just look tidy on screen.

Odoo / ERP Administrator

Wants restrictions enforced through record rules and security groups rather than brittle view hacks, so they hold across API calls and upgrades and don't break with every Odoo point release.

Multi-Company / Multi-Branch Accounting Manager

Runs several companies or branches in one database and needs each bookkeeper confined to their own journals and companies, with intercompany and shared journals handled correctly.

Internal Auditor / Compliance Lead

Requires a logged, reviewable trail of who can access which journals, plus denial alerts, to demonstrate controls over financial postings.

How Journal Restriction For Users Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Per-user journal access controlPurpose-built, enforced by record rules on all accounting modelsAchievable but you design and maintain the rules yourselfOften a view-level filter that varies in depthNo per-user journal restriction; access is group-wide
API / XML-RPC coverageEnforced server-side, so it holds through XML-RPC/JSON-RPC and cronDepends on whether you implement it at the ORM layerFrequently UI-only, leaving the API exposedGroup access applies but not per-journal scoping
Multi-company handlingCompany-aware rules intersecting journals with allowed companiesExtra effort to get intersection logic correctVaries; often single-company assumptionsCompany rules exist but no journal-level user control
Read vs write separationIndependent view and post scopes per journalPossible with additional rule designUsually all-or-nothing per journalNot available at journal granularity
Audit trail of entitlements`mail.thread` logging plus optional denial alertsYou add logging yourselfRarely includedNo dedicated entitlement audit
Upgrade safetyClean addon, no core monkey-patching; upgrade checklist providedQuality depends on your team's disciplineUnknown; may break on major versionsN/A — nothing to upgrade
Fit to your processScoped to your journals, roles, and edge cases before buildFully bespoke but you carry design risk and timeGeneric; you adapt your process to itStandard behavior only
Support & handoverSupport window, docs, training, and git repo handoverInternal only, ties up your developersVendor support quality variesCommunity/Enterprise support, no custom coverage

Frequently Asked Questions about Journal Restriction For Users

Is this an existing app I can download and install today?

No. This is a build-to-order module. ECOSIRE builds it to your confirmed journal, role, and company structure, then installs and supports it. There is no instant download — you request a quotation and we scope it with you first.

How long does delivery take?

Typical delivery is one working week from confirmed scope. After the scoping call we agree on the exact journals, roles, and edge cases; simpler single-company builds land toward the shorter end, while multi-company or heavily customized environments take longer.

How does pricing and scoping work?

Pricing starts from $999 as an indicative single-company base scope. We hold a short scoping call, then give you a fixed written quote. Multi-company rules, localization depth, integration with existing custom security, and migrating historical assignments increase the quoted scope.

What about support and future Odoo updates?

Every build includes a post-go-live support window for defect fixes and configuration help, plus a git repository handover so your team owns the code. We provide an upgrade checklist, and we can quote a separate engagement to move the module to a future Odoo major version when you upgrade.

Will the restriction hold through the API and reports, or only in the UI?

It holds everywhere. Enforcement is via `ir.rule` record rules evaluated by the ORM, so it applies to XML-RPC/JSON-RPC calls, scheduled actions, QWeb reports, and exports — not just the web screens. That closes the back-door that UI-only filters leave open.

Does it work on Odoo Community and Enterprise?

Yes. The core is built on standard Odoo accounting models present in both editions. Enterprise-only surfaces such as the accounting dashboard are handled when present, and we confirm your exact edition and version (17.0/18.0/19.0) during scoping.

Can a user be allowed to view a journal but not post to it?

Yes. Read and write scopes are controlled independently, so you can, for example, let a reconciler view bank journal entries without granting them the right to create or post entries there.

Request a quote

Journal Restriction For Users

A build-to-order Odoo accounting-security module that limits which journals each user can post, view, and reconcile — so sales, purchase, bank, and cash entries stay walled off by role. ECOSIRE scopes, builds, installs, and supports it on your Odoo 17, 18, or 19.

  • Many-to-many mapping between `res.users` (or a configurable `account.security.role`) and `account.journal`, managed from a dedicated Settings menu
  • Enforcement via `ir.rule` record rules on `account.move`, `account.move.line`, `account.payment`, and `account.bank.statement` — server-side, not a UI-only filter
  • `@api.depends` compute that resolves each user's effective journal set from one or more assigned roles, so access is managed by role rather than per-user clicks
  • `check_journal_access()` guard on `create`/`write` of `account.move` that raises a clear `AccessError` when a user posts to a forbidden journal

Request a Quotation

Tell us about your Journal Restriction For Users requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.