Ana içeriğe atla
Ürün ayrıntıları İngilizce olarak görüntülenir. Çeviriler yakında gelecek.
Workspace & Field-Level Permissions Manager — A build-to-order Frappe app that extends ERPNext permissions with field-level r — 1/1Örnek önizleme

A build-to-order Frappe app that extends ERPNext permissions with field-level read/write masking,

record-level rules and role-scoped workspace visibility.

ECOSIRE scopes, builds, installs and supports it on your ERPNext v15/v16 bench.

Workspace & Field-Level Permissions Manager nedir?

A build-to-order Frappe app that extends ERPNext permissions with field-level read/write masking, record-level rules and role-scoped workspace visibility. ECOSIRE scopes, builds, installs and supports it on your ERPNext v15/v16 bench. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Temel Özellikler

Role-profile-aware workspace visibility that shows or hides Frappe Workspaces, shortcuts and cards per user without cloning workspaces
Field-level read/write/mask rules driven by a `Field Permission Rule` DocType instead of scattered `permlevel` hacks
Server-side enforcement in `hooks.py` doc events (`validate`, `before_save`, `onload`) so masked values never reach the client
Masking applied at the field-fetch layer so hidden values are also stripped from the Frappe REST API (`/api/resource`, `frappe.client.get`) and report builder
Record-level rules via `get_permission_query_conditions` so filtering happens in the SQL `WHERE` clause, not just in the UI
`has_permission` hook for per-document allow/deny beyond ERPNext's User Permission link matching
User- and group-scoped rules that map to existing role profiles, teams and territory/company dimensions
Private comments and tagged visibility so record notes are seen only by named users or groups
Permission Audit Script/Query Report resolving the effective read/write/mask matrix per user and flagging conflicting rules
Immutable log DocType capturing every rule change and every access-denied event for compliance trails
Scheduled weekly permission-change and access-denial digest via a registered `scheduler_event`
Whitelisted server methods for programmatic rule checks so integrations honour the same access boundary
Client scripts used only for UX (greying masked fields, hiding tabs) with the real boundary always on the server
Delivered as a versioned Frappe app with fixtures and `hooks.py`, upgrade-safe across ERPNext v15 and v16

Siparişe özel, sizin için baştan sona

Kendiniz kurmanıza gerek yok — ECOSIRE tarafından geliştirilen, kurulan ve desteklenen çalışır bir uygulama.

  1. 1

    Sipariş verirsiniz

    Tek seferlik geliştirme fiyatıyla başlayın. Kapsamı başlangıçta sizinle birlikte belirleriz.

  2. 2

    Geliştirir ve kurarız

    ECOSIRE, ERPNext ortamınızda geliştirir, yapılandırır ve kurar.

  3. 3

    Yayına alma + destek

    Yaklaşık bir iş haftasında yayına alırsınız; canlıya geçiş sonrası iki hafta destek dahildir. Teslim ettiğimiz koddaki hatalar ücretsiz düzeltilir.

Teknik Özellikler

ERPNext Uyumluluğu
—
Lisans
Lisansın doğrulanması gerekiyor
Python Gereksinimi
Python 3.10+
Veritabanı
MariaDB 10.6+

Bu Ürün Hakkında

Standard ERPNext permissions are role-and-DocType shaped: you grant a role read/write/create/delete on a DocType, add User Permissions to fence off records by link field, and lean on Permission Level (permlevel) fields for coarse column control. That works until Finance can see a customer record but must never see its credit_limit, until a regional manager should only touch leads in their own territory group, or until a whole workspace of reports needs to disappear for contractors. At that point admins resort to duplicating DocTypes, hiding fields with brittle client scripts (which never actually secure the data server-side), or over-granting roles and hoping nobody notices. ERPNext core simply runs out of road for least-privilege, per-field, per-record governance.

We build a proper Frappe app (its own module, DocTypes, hooks.py and fixtures) that layers structured, auditable access control on top of ERPNext's native permission engine rather than fighting it. A Field Permission Rule DocType maps role profiles to per-field read/write/mask behavior; enforcement runs server-side in hooks.py doc events (before_save, validate, onload) and in an override of the controlled DocTypes' get_valid_columns/field-fetch path, so masked values never leave the server even via the Frappe REST API, frappe.client.get, list view, or report builder. Record-level rules are evaluated with a whitelisted get_permission_query_conditions hook and a has_permission hook, so filtering happens in the SQL WHERE clause — a user cannot enumerate hidden records by guessing names or paging the /api/resource endpoint. Workspace visibility is driven by role-profile-aware logic that hides or shows Frappe Workspaces and their shortcuts per user without cloning them.

On top of enforcement we build the operational surface admins actually need: a Permission Audit report (Query/Script Report) that resolves, for any user, the effective read/write/mask matrix across the governed DocTypes and flags conflicts; private comments and tagged-visibility controls so notes on a record are only visible to named users or groups; and a scheduled digest (registered as a scheduler_event) that emails owners a weekly summary of permission changes and access-denied events. Every rule change and every enforced denial is written to a log DocType so you have a defensible trail for audit and compliance reviews. Client scripts are used only for UX affordances (greying out masked fields, hiding tabs) — never as the security boundary, which always lives on the server.

Because this is built-to-order, nothing here is a generic download. We start from your real role profiles, the exact DocTypes and fields you need to govern, and your ERPNext version (v15 or v16), then deliver an app tailored to that scope. Typical delivery is one working week from confirmed scope. You get the installable source code for your build, installation and configuration on your bench, technical and end-user documentation, a training session, UAT on a staging site with a tested rollback plan, and a post-go-live support window. ECOSIRE builds it, installs it, and supports it — you are not left to reverse-engineer someone else's marketplace app.

Ne elde edeceksin

  • Installable source code for your build — a versioned Frappe app with module, DocTypes, `hooks.py` and fixtures
  • Installation and configuration on your ERPNext bench, wired to your real role profiles and governed DocTypes
  • Technical documentation covering DocType schema, hook flow, whitelisted methods and how enforcement is applied
  • End-user and admin guide plus a live training session for your permissions administrators
  • UAT on a staging site with a documented, tested rollback plan before production cut-over
  • Post-go-live support window for defect fixes and configuration questions
  • Git repository handover with full commit history and tagged release
  • Seeded example rules and the Permission Audit report configured for your initial governed DocTypes

Bu kimin için

Security & compliance administrator

Owns least-privilege access and needs field-level masking, record-level scoping and a defensible audit trail that ERPNext core cannot express through roles and User Permissions alone.

ERPNext system administrator

Manages role profiles across Finance, Sales and Operations and wants structured permission rules and an effective-access report instead of duplicated DocTypes and brittle client-script hiding.

Regional or divisional manager

Should only see and edit records within their own territory, company or team, enforced in the query layer so hidden records never surface via list views, reports or the REST API.

Data protection / internal audit lead

Needs proof that sensitive fields (salary, cost, credit limit, PII) are masked server-side and that every permission change and denial is logged for reviews.

Workspace & Field-Level Permissions Manager Nasıl Karşılaştırılır

KriterECOSIREÖzel YapıRakipERPNext Yerleşik
Field-level maskingServer-side read/write/mask per field via rule DocTypePossible but hand-coded per fieldOften UI-only hiding, not enforcedCoarse `permlevel` only, no true masking
Record-level rulesSQL `WHERE`-level filtering via query hookAchievable with deep Frappe knowledgeUsually limited to link-based filtersLink-based User Permissions only
REST API / report leakageMasked and filtered on API, list and reportsMust remember every access pathFrequently leaks via API or report builderRespects roles but not field masking
Workspace visibilityRole-profile-aware show/hide, no cloningManual per-user workspace jugglingRarely coveredBasic role-based, coarse
Audit & change logEffective-access report + immutable change logBuild it yourselfSeldom includedNo effective-access view
Fit to your orgBuilt to your roles, DocTypes and dimensionsFully bespoke, higher risk/costGeneric, configure to fitConfigure within core limits
Support & handoverPost-go-live window + git repo + docsDepends on the developerVendor forum/ticket, no source accessCommunity support only
Delivery modelBuild-to-order, one working week, UAT + rollbackOpen-ended timelineInstant download, integration on youAlready in your ERPNext

Workspace & Field-Level Permissions Manager hakkında Sıkça Sorulan Sorular

How long does delivery take?

This is a build-to-order app, not an instant download. After a scoping call to confirm the exact role profiles, DocTypes, fields and rules you need, typical delivery is one working week from confirmed scope, including UAT on staging before go-live.

How is this different from ERPNext's built-in Role Permissions and User Permissions?

ERPNext core is role-and-DocType shaped with coarse `permlevel` field control and link-based User Permissions. We add per-field read/write/masking, per-record allow/deny evaluated in the SQL query layer, and role-profile-aware workspace visibility — enforced server-side, with an effective-access audit report and change log on top.

Is the masking actually secure, or just hidden in the UI?

It is enforced server-side in `hooks.py` doc events and at the field-fetch layer, so masked values are stripped from the REST API, `frappe.client.get`, list views and report builder — not just greyed out. Client scripts only handle UX affordances; they are never the security boundary.

Which ERPNext and Frappe versions are supported?

We build and test against ERPNext/Frappe v15 and v16. We confirm your exact bench version during scoping and deliver an app aligned to it, with an upgrade-safe structure.

How do support and updates work after go-live?

Every build includes a post-go-live support window for defect fixes and configuration questions. Beyond that, we offer ongoing support and can add rules, DocTypes or version-upgrade compatibility as a follow-on engagement. You also receive the full git repository so your team can maintain it.

Will this survive an ERPNext version upgrade?

Because it is a standalone Frappe app using documented hooks (`get_permission_query_conditions`, `has_permission`, doc events, `scheduler_events`) rather than core patches, it upgrades cleanly. We validate against your target v15/v16 version and hand over docs so upgrades stay predictable.

Can rules follow our existing teams, territories or companies?

Yes. Record-level rules can key off existing dimensions such as territory, company, department or custom group fields, mapped to your current role profiles, so access mirrors your real org structure without duplicating records or roles.

Teklif isteyin

Workspace & Field-Level Permissions Manager

A build-to-order Frappe app that extends ERPNext permissions with field-level read/write masking, record-level rules and role-scoped workspace visibility. ECOSIRE scopes, builds, installs and supports it on your ERPNext v15/v16 bench.

  • Role-profile-aware workspace visibility that shows or hides Frappe Workspaces, shortcuts and cards per user without cloning workspaces
  • Field-level read/write/mask rules driven by a `Field Permission Rule` DocType instead of scattered `permlevel` hacks
  • Server-side enforcement in `hooks.py` doc events (`validate`, `before_save`, `onload`) so masked values never reach the client
  • Masking applied at the field-fetch layer so hidden values are also stripped from the Frappe REST API (`/api/resource`, `frappe.client.get`) and report builder

Teklif isteyin

Workspace & Field-Level Permissions Manager ihtiyaçlarınızı bize anlatın; fiyatları, lisans seçeneklerini ve size özel bir teklifi genellikle bir iş günü içinde gönderelim.

Şimdi ödeme yok. Bu, ekibimize bir teklif talebi gönderir — fiyat ve sonraki adımlarla e-posta ile dönüş yapacağız.