odoo-app-automator

Odoo App Automator

AI-powered automation for creating, deploying, and managing Odoo modules and custom applications. This skill enables AI agents to generate production-ready Odoo modules, configure Studio customizations, set up containerized deployments, and integrate third-party services.

Purpose

Automate the entire lifecycle of Odoo custom module development:

• Module Scaffolding: Generate complete Odoo module structures with models, views, security, and data
• Studio Integration: Programmatically configure Odoo Studio customizations
• Container Deployment: Set up Odoo.sh containers with dependencies and configurations
• Third-Party Integration: Connect external APIs, payment providers, and business services
• Upgrade Management: Handle version upgrades and module migrations

When to Use This Skill

Use this skill when the user requests:

• "Create a custom Odoo module for [purpose]"
• "Build an Odoo app for [business process]"
• "Automate [workflow] in Odoo"
• "Deploy a custom Odoo module"
• "Integrate [third-party service] with Odoo"
• "Set up Odoo Studio customizations"
• "Migrate custom module from Odoo [version] to [version]"

Core Capabilities

1. Module Scaffolding

Generate complete Odoo module structures following best practices:

Module Structure:

custom_module/
├── __init__.py
├── __manifest__.py
├── models/
│   ├── __init__.py
│   └── custom_model.py
├── views/
│   ├── custom_views.xml
│   └── menu_views.xml
├── security/
│   ├── ir.model.access.csv
│   └── security_groups.xml
├── data/
│   └── default_data.xml
├── static/
│   ├── description/
│   │   ├── index.html
│   │   └── icon.png
│   └── src/
│       ├── js/
│       ├── css/
│       └── xml/
├── wizards/
├── reports/
├── controllers/
└── README.md

Key Files to Generate:

1. __manifest__.py: Module metadata
2. models/*.py: Business logic and database models
3. views/*.xml: UI definitions (form, tree, kanban, search)
4. security/ir.model.access.csv: Access control rules
5. data/*.xml: Default data and demo data
6. README.md: Documentation

2. Odoo Studio Automation

Configure Studio customizations programmatically:

Studio Capabilities:

• Add/modify fields to existing models
• Create custom views (form, list, kanban, pivot, graph)
• Define automated actions and workflows
• Set up filters and default values
• Configure access rights and security rules
• Create reports and dashboards

Workflow:

1. Export Studio customizations as modules
2. Version control Studio-created modules
3. Deploy to production via git
4. Update Studio configs via XML data files

3. Container Setup (Odoo.sh)

Configure Odoo.sh containers with custom requirements:

Directory Structure:

/home/odoo/
├── src/
│   ├── odoo/          # Odoo Community
│   ├── enterprise/    # Odoo Enterprise
│   ├── themes/        # Themes
│   └── user/          # Custom modules
├── data/
│   ├── filestore/     # Attachments
│   └── sessions/      # User sessions
└── logs/
    ├── odoo.log
    ├── install.log
    └── pip.log

Dependencies Management:

Create requirements.txt in repository root:

# Python dependencies
pandas>=1.5.0
requests>=2.28.0
pillow>=9.0.0
paddleocr>=2.6.0
supabase>=1.0.0

Custom Commands:

# Install module
odoo-bin -i custom_module --stop-after-init

# Update module
odoo-bin -u custom_module --stop-after-init

# Run tests
odoo-bin -i custom_module --test-enable --log-level=test --stop-after-init

# Odoo shell
odoo-bin shell

4. Third-Party Integration

Integrate external services into Odoo:

Common Integrations:

• Payment Providers: Stripe, PayPal, Paymongo (PH)
• Shipping: FedEx, DHL, LBC (PH)
• Accounting: QuickBooks, Xero
• CRM: Salesforce, HubSpot
• Communication: Slack, Microsoft Teams
• Storage: Google Drive, Dropbox, Supabase
• AI/ML: OpenAI, Anthropic Claude, PaddleOCR

Integration Pattern:

1. Create API Wrapper Model:

class ExternalService(models.Model):
    _name = 'external.service'
    
    api_key = fields.Char(string='API Key')
    base_url = fields.Char(string='Base URL')
    
    def call_api(self, endpoint, method='GET', data=None):
        url = f"{self.base_url}/{endpoint}"
        headers = {'Authorization': f'Bearer {self.api_key}'}
        response = requests.request(method, url, headers=headers, json=data)
        return response.json()

2. Add Configuration UI
3. Implement Webhook Handlers
4. Set Up Scheduled Actions

5. Upgrade Management

Handle version migrations for custom modules:

Upgrade Workflow:

1. Request test upgrade from Odoo.sh or upgrade.odoo.com
2. Update custom module code for new version
3. Test upgraded database thoroughly
4. Deploy to production

Module Version Compatibility:

# __manifest__.py
{
    'name': 'Custom Module',
    'version': '19.0.1.0.0',  # Format: {odoo_version}.{major}.{minor}.{patch}
    'depends': ['base', 'sale', 'account'],
}

Practical Examples for Finance SSC

Example 1: BIR Tax Filing Module

User Request: "Create an Odoo module for BIR tax form filing (1601-C, 2550Q, 1702-RT)"

Module Structure:

bir_tax_filing/
├── models/
│   ├── bir_form_1601c.py
│   ├── bir_form_2550q.py
│   └── bir_form_1702rt.py
├── views/
│   ├── bir_form_views.xml
│   └── bir_filing_schedule_views.xml
├── wizards/
│   └── bir_filing_wizard.py
├── reports/
│   ├── bir_pdf_reports.xml
│   └── bir_dat_export.py
└── data/
    └── bir_default_schedules.xml

Key Features:

• Automated form generation from accounting data
• Filing schedule tracking
• .DAT file export for eBIRForms
• Compliance dashboard
• Multi-agency support (RIM, CKVC, BOM, JPAL, JLI, JAP, LAS, RMQB)

Example 2: Travel & Expense Management (SAP Concur Alternative)

User Request: "Build a self-hosted travel and expense management app"

Module Features:

• Travel request workflow
• Expense report submission
• Receipt OCR with PaddleOCR
• Policy validation
• Multi-level approvals
• GL account posting
• Budget tracking

Cost Savings: $15,000/year in licensing fees

Example 3: Superset Dashboard Integration

User Request: "Connect Odoo data to Apache Superset dashboards"

Implementation:

1. Create database connector in Superset
2. Build Odoo API endpoints for dashboard data
3. Set up scheduled data synchronization
4. Create pre-built dashboard templates

Use Cases:

• BIR compliance metrics
• Month-end closing progress
• Multi-agency financial KPIs

Example 4: Notion Workflow Sync

User Request: "Sync finance tasks between Notion and Odoo"

Implementation:

1. Notion API integration module
2. Task synchronization with external ID upserts
3. Webhook handlers for real-time updates
4. Scheduled actions for batch sync

Module Generation Workflow

Step 1: Requirements Gathering

Ask the user:

1. Module Purpose: What business process does this automate?
2. Core Entities: What are the main data models?
3. User Workflows: What actions will users perform?
4. Integrations: Which external systems need to connect?
5. Security: Who should have access to what?
6. Reporting: What reports/dashboards are needed?

Step 2: Generate Module Structure

Create all necessary files:

1. manifest.py with dependencies and metadata
2. models/ with Python classes for each entity
3. views/ with XML definitions for UI
4. security/ with access control rules
5. data/ with default records
6. README.md with usage instructions

Step 3: Add Business Logic

Implement:

• Field validations and constraints
• Computed fields
• CRUD operations
• Workflow automation
• API integrations

Step 4: Configure Security

Define:

• User groups
• Access rights (read, write, create, unlink)
• Record rules (domain-based access)
• Field-level security

Step 5: Create UI Views

Build:

• Form views (detail page)
• Tree views (list page)
• Kanban views (card layout)
• Search views (filters, group by)
• Dashboard widgets

Step 6: Testing & Deployment

1. Local Testing:

odoo-bin -d test_db -i custom_module --test-enable

2. Deploy to Odoo.sh:

git add custom_module/
git commit -m "Add custom module"
git push origin staging

3. Install in Production:
   • Test in staging branch first
   • Merge to production branch
   • Auto-deployment triggered

Best Practices

Code Quality

1. Follow OCA Guidelines: Use Odoo Community Association standards
2. Use Python Type Hints: Improve code readability
3. Write Docstrings: Document all models and methods
4. Add Unit Tests: Ensure reliability
5. Validate XML: Check view definitions

Performance

1. Optimize Queries: Use _read_group() for aggregations
2. Lazy Loading: Use @api.depends wisely
3. Index Database Fields: Add index=True to frequently queried fields
4. Cache Computed Fields: Use store=True when appropriate

Security

1. Never Trust User Input: Validate and sanitize
2. Use Record Rules: Restrict data access by domain
3. Encrypt Sensitive Data: Use password=True for password fields
4. Audit Logging: Track important changes
5. Rate Limiting: Prevent API abuse

Maintenance

1. Version Control: Use git with semantic versioning
2. Migration Scripts: Provide upgrade paths
3. Backup Data: Regular database backups
4. Monitor Logs: Watch for errors and performance issues
5. Documentation: Keep README up-to-date

Common Pitfalls to Avoid

1. Missing Dependencies: Always declare in __manifest__.py
2. Hardcoded Values: Use configuration parameters instead
3. No Access Rules: Module won't be accessible without security/ir.model.access.csv
4. Circular Dependencies: Check module dependency graph
5. Unused Fields: Don't add fields you won't use
6. Poor Naming: Use clear, descriptive names
7. Skipping Tests: Test before deploying to production

Integration with User's Stack

InsightPulse AI Infrastructure

Components:

• Odoo 19 ERP: Primary application (self-hosted with OCA modules)
• Apache Superset: BI dashboards (replaces Tableau, saves $4,728/year)
• Supabase: PostgreSQL database (project: spdtwktxdalcfigzeqrz)
• MCP Servers: Notion, Google Drive integration
• PaddleOCR: Receipt and BIR form processing

Module Integration Points:

1. Connect to Supabase for centralized data
2. Sync with Notion for task management
3. Send analytics to Superset dashboards
4. Process documents with PaddleOCR
5. Store files in Google Drive

Multi-Agency Configuration

Support for 8 agencies:

• RIM, CKVC, BOM, JPAL, JLI, JAP, LAS, RMQB

Implementation:

class FinanceAgency(models.Model):
    _name = 'finance.agency'
    
    code = fields.Selection([
        ('RIM', 'RIM'),
        ('CKVC', 'CKVC'),
        ('BOM', 'BOM'),
        ('JPAL', 'JPAL'),
        ('JLI', 'JLI'),
        ('JAP', 'JAP'),
        ('LAS', 'LAS'),
        ('RMQB', 'RMQB'),
    ], required=True)
    
    name = fields.Char(required=True)
    tin = fields.Char(string='TIN')
    rdo_code = fields.Char(string='RDO Code')

Output Format

When generating a module, provide:

1. Complete Module ZIP: Ready to install in Odoo
2. Installation Instructions: Step-by-step deployment guide
3. Configuration Guide: How to set up after installation
4. User Documentation: How to use the module
5. Developer Notes: Architecture decisions and extension points

References

• Odoo 19 Developer Documentation
• Odoo.sh Containers Guide
• Odoo Studio Documentation
• Odoo Apps & Modules Management
• Odoo Upgrade Process
• OCA Guidelines

---

Built for Finance Shared Service Centers managing multi-agency operations with self-hosted infrastructure.