ERP DEVELOPMNT Presented by abiy alemayehu

PRESENTATION
INTRODUCTION
ERP (Enterprise Resource Planning) systems are essential for managing and integrating core
business processes, and they play a critical role in both short-term and long-term operations.
Benefits of ERP
Improved Efficiency: ERP integrates various business processes, eliminating manual tasks and
reducing redundancy. This helps businesses run more smoothly and quickly address day-to-day
operational challenges.
Real-Time Decision Making: With centralized data, managers can make informed decisions faster,
responding to market changes, customer needs, and operational issues promptly.
Cost Control: ERP helps reduce operating costs by optimizing resource use, tracking expenditures,
and identifying inefficiencies quickly.
Better Compliance: ERP systems ensure businesses meet regulatory and financial compliance by
providing accurate, up-to-date reports.
Streamlined Communication: ERP systems integrate different departments, improving collaboration
and information sharing in the short term
ERP ODOO VERSIONS
1,Odoo Community
Open Source: Free to use with a flexible, open-source license.
Basic Features: It includes essential ERP modules like Sales, Accounting,
Inventory, and CRM, but with limited features compared to the Enterprise version.
Customization: Highly customizable by developers to fit specific business needs.
No Official Support: Support is community-driven, relying on forums and the
Odoo community for troubleshooting and improvements.
Limited Usability: Features like advanced accounting, reporting, studio
(customization tool), and mobile support are limited or absent.
Ideal For: Small businesses or startups with lower budgets, or those who have in-
house development teams.
…...
2,Odoo Enterprise
Subscription-Based: Paid version with additional features and regular updates.
Advanced Features: Includes advanced modules like marketing automation, eSign, Odoo Studio (for
customization), advanced accounting, full mobile compatibility, and improved performance.
Support: Comes with official Odoo support, including bug fixes and guaranteed uptime.
Cloud or On-Premise: Offers cloud hosting (Odoo.sh) and on-premise deployment options.
Third-Party Integrations: Easier integration with third-party apps and more out-of-the-box features.
User Interface (UI) Enhancements: Sleeker interface with more tools for automation and user
experience improvements.
Ideal For: Medium to large enterprises needing advanced functionality, scalability, and official
support.
KEY DIFFERENCES OF VERSIONS
Pricing: Odoo Community is free, while Odoo Enterprise requires a subscription
fee.
Support: Enterprise includes official support, while Community relies on
community forums.
Features: Enterprise has more advanced modules and functionalities (e.g., studio
customization, advanced reporting).
Hosting: Odoo Enterprise offers cloud hosting (Odoo.sh) and more secure hosting
options
ODOO ERP ARCHITECTURE
Odoo ERP follows a multi-layer architecture ,separate the concerns of data management,
business logic, and presentation
1, Presentation Layer (User Interface Layer)
Role: This layer is responsible for how users interact with the system. It includes the user
interface (UI) components such as forms, dashboards, and reports that users see and use to
perform tasks.
Technologies:
 Web Interface: Odoo uses web technologies like HTML, CSS, JavaScript, and XML to render the user interface.
 QWeb: Odoo’s templating engine (QWeb) is used to define views and customize the interface, generating HTML
dynamically based on the data.

Clients:
 Web Client: Most users interact with Odoo through a browser-based web interface.
 Mobile Client: Mobile applications interact with Odoo via RESTful APIs.
 Backend Interface: Admins or developers can access the backend for managing the system, modules, and
configurations.
…..
2,Business Logic Layer (Application Layer)
Role: This layer handles the business rules and application logic that govern how data is
processed. It interprets user commands, validates inputs, manages workflows, and communicates
between the UI and the database.
Technologies:
Python: Odoo’s business logic is primarily written in Python. This includes the creation of
modules, automation, validation, and custom workflows.
ORM (Object-Relational Mapping): Odoo's ORM abstracts the underlying database operations. It
allows developers to work with high-level Python objects, which represent database records,
rather than writing raw SQL queries.
Modules: The business logic is organized into modular apps such as Sales, Inventory, Accounting,
CRM, HR, and others. These modules can be installed, updated, or customized according to business
needs.
…..
3, Data Layer (Database Layer)
Role: This layer is responsible for storing, retrieving, and managing the application's data. It ensures
data integrity, consistency, and availability.
Technologies:
PostgreSQL: Odoo uses PostgreSQL as its default database management system (DBMS) to store
data. It supports complex transactions, relational queries, and scalability.
ORM Mapping: The ORM (Object-Relational Mapping) in the business logic layer converts Python
objects (models) to relational database tables, making it easier for developers to interact with the
database without writing SQL queries.
Models: In Odoo, each module defines its models (data structures) that map to tables in the
database. For example, a SaleOrder model would map to the sale_order table in the database
ODOO MODULES
An Odoo module adds new features or extends existing ones by modifying data models, business
logic, views, or workflows. It enables Odoo to be flexible and customizable to suit various business
requirements
An Odoo module typically consists of the following components:
__manifest__.py: The module’s configuration file containing metadata (name, version,
dependencies, etc.).
__init__.py: An initialization file that imports Python files to load models and logic.
Python Files (Models): Define the business logic and data models using Odoo's ORM.
XML Files (Views): Define the user interface, forms, lists, and dashboards using XML.
Security Files: Manage user access using access control lists (ACLs) and record rules.
Static Files: Include assets like images, JavaScript, and CSS for the frontend.
Data Files: Optional configuration or initial data loaded during module installation.
STRUCTURE OF AN ODOO MODULE
custom_module/

├── __init__.py # Initialization

├── __manifest__.py # Metadata

├── models/ # Python business models

│ └── custom_model.py

├── views/ # XML view definitions

│ └── custom_view.xml

├── security/ # Access control and record rules

│ └── ir.model.access.csv

└── static/ # Static assets (images, JS, CSS)

└── description/

└── icon.png
…..
Models: Contains Python files defining business models and logic.

Views: XML files for UI customization (forms, lists, dashboards).

Security: Defines user permissions.

Static: Optional, for static assets like icons, CSS, and JavaScript.

python

Copy code

{ 'name': 'Custom Sales Module',

'version': '1.0',

'depends': ['sale'],

'data':

[ 'views/custom_view.xml', 'security/ir.model.access.csv',

],

'installable': True, }
OBJECT-RELATIONAL MAPPING

Object-Relational Mapping (ORM) is a technique used in Odoo (and other ERP

systems) to map Python objects (models) to database tables in a relational
database (like PostgreSQL). The ORM allows developers to interact with the
database using high-level Python code, without writing raw SQL queries.
In Odoo's ORM, each model (Python class) represents a table in the database, and
each field in the model represents a column in the table. Relationships between
models are managed through various field types, ensuring data integrity and
relational consistency.
KEY COMPONENTS OF ORM IN ODOO
Models (Python Classes):
Define the business objects (e.g., sale.order, res.partner) that map to database tables.
Fields (Attributes):
Define columns in the database table. Examples include Char, Integer, Many2one,
One2many, etc.
Relationships (Field Types):
Many2one: Defines a "many-to-one" relationship (foreign key). For example, multiple sales
orders may reference a single customer.
One2many: Defines a "one-to-many" relationship, where one record is linked to multiple
related records.
Many2many: Defines a "many-to-many" relationship where multiple records in one table are
related to multiple records in another table.
EXAMPLE OF ORM IN ODOO
class SaleOrder(models.Model):
_name = 'sale.order' # Defines the table name
_description = 'Sales Order'
name = fields.Char(string='Order Reference')
partner_id = fields.Many2one('res.partner', string='Customer')
order_line_ids = fields.One2many('sale.order.line', 'order_id', string='Order Lines')
BENEFITS OF ORM IN ERP (ODOO)
Abstraction: Developers can work with Python objects instead of SQL queries,
making code easier to write and maintain.
Data Integrity: ORM manages relational integrity (e.g., foreign keys) automatically.
Modular Design: Models are extendable, enabling seamless customization without
affecting core tables.
MODELS IN ODOO
Models in Odoo represent business objects and map Python classes to database tables. Each model defines
the structure and behavior of business data, with fields corresponding to database columns.
A model is a Python class that extends models.Model, representing a database table. It contains fields
(attributes) and methods (business logic) to interact with the data
Key Components
_name: The name of the model (table).
Fields: Define the data structure and relationships.
 Char: For strings (e.g., name = fields.Char(string="Name")).
 Integer: For integers (e.g., age = fields.Integer(string="Age")).
 Many2one: For many-to-one relationships (e.g., customer = fields.Many2one('res.partner',
string='Customer')).
 One2many: For one-to-many relationships.
 Many2many: For many-to-many relationships.

_description: A short description of the model.

ACCESS RIGHTS IN ODOO
Access rights in Odoo control which users can perform certain actions (read, create, write, delete) on specific
models (database tables). This ensures data security and proper role-based permissions in the system.
Types of Access Control
User Groups:
 Odoo organizes users into groups. Each group has specific permissions, and users inherit the permissions of their groups.
 Examples of groups: Sales Manager, HR Officer, Accountant.

Access Control Lists (ACLs):

 ACLs define what actions (read, write, create, delete) a user group can perform on a model (table).
 Example: A sales user can read and create sales orders but may not have the right to delete them.
 Defined in ir.model.access.csv.

Record Rules:
 Record rules control which specific records a user can access based on conditions.
 Example: Sales users can only see their own sales orders, not those of other users.
 Defined in the ir.rule model, usually via XML.
2. ACL STRUCTURE (CSV FORMAT)

An Access Control List is defined in a CSV file (ir.model.access.csv), specifying the group’s
access to a model. Fields include:
id: Unique identifier.
name: Name of the access rule.
model_id: The model (object) to which the rule applies.
group_id: The user group to which this rule applies.
perm_read: Can read records (1 for yes, 0 for no).
perm_write: Can write (edit) records.
perm_create: Can create new records.
perm_unlink: Can delete records.
…...
3,RECORD RULES (XML FORMAT)
Record rules apply more granular conditions to limit access to specific records. They
are typically defined in XML files
4. Menu Access Control
In addition to model and record access, Odoo controls which menu items users can
access based on their group. This is configured in the menu’s XML definition using
groups.
<menuitem id="menu_sales"
name="Sales"groups="sales_team.group_sale_manager"/>
ACTIONS IN ODOO
Actions in Odoo are used to define how the system responds to user interactions, such as clicking a menu item or a button.
Actions link user interface elements (like menus or buttons) to specific views, reports, or other functionalities.
1. Types of Actions
Window Actions:
 Used to open views (e.g., forms, lists, kanban) for a specific model.
 Example: Clicking on "Sales Orders" opens the list of all sales orders.

Server Actions:
 These trigger Python code on the server side. Server actions can be used to automate processes, like sending emails, updating fields, or
executing workflows.

Report Actions:
 These trigger the generation of reports (e.g., PDFs, Excel files) for a specific model or record.

URL Actions:
 Used to redirect users to a specific URL when an action is triggered.

Client Actions:
 These perform actions on the client side, such as opening a specific web page or displaying a notification.