jgtolentino InsightPulse Connection Manager
When to Use This Skill
Use this skill when you need to:
- Manage multiple database and API connections for Finance SSC operations
- Generate connection strings, .env files, or Docker Compose configs
- Test and monitor connection health across infrastructure
- Integrate Supabase, Odoo, Superset, MCP servers, and PostgreSQL
- Build self-hosted connection management without vendor lock-in
- Create unified connection dashboard for multi-agency operations
Core Capabilities
Connection Management
- Unified interface for all connections (Supabase, Odoo, Superset, MCP, PostgreSQL, APIs)
- Pre-configured connections for InsightPulse AI stack
- Support for 8 agencies: RIM, CKVC, BOM, JPAL, JLI, JAP, LAS, RMQB
- Color-coded connection types with visual status indicators
Auto-Generated Configuration
- Connection string generation (PostgreSQL, MySQL, MongoDB formats)
- Environment variables in .env format with copy-to-clipboard
- Docker Compose service definitions
- Kubernetes ConfigMap snippets
Connection Testing & Monitoring
- One-click connection testing
- Real-time connection health monitoring
- Active connection count tracking
- Connection latency measurement
Beautiful UI
- Supabase-inspired Kanban interface
- Color-coded by connection type
- Visual status indicators (green/yellow/red)
- Quick-access copy buttons
Prerequisites
Required Software
- Odoo 19 Community Edition
- PostgreSQL 16+ (for connection testing)
- Python 3.11+ with psycopg2
Optional Integrations
- Supabase project (ref: spdtwktxdalcfigzeqrz)
- Apache Superset instance
- MCP servers (Notion, Google Drive)
- DigitalOcean PostgreSQL cluster
Access Requirements
- Odoo administrator access
- Database credentials for systems being managed
- API keys for external services
Implementation Patterns
Module Structure
insightpulse_connection_manager/
├── __init__.py
├── __manifest__.py
├── models/
│ ├── __init__.py
│ └── connection_endpoint.py # Main model
├── views/
│ ├── connection_endpoint_views.xml
│ └── connection_endpoint_kanban.xml
├── security/
│ ├── ir.model.access.csv
│ └── connection_security.xml
├── data/
│ └── default_endpoints.xml # Pre-configured connections
└── static/
├── description/
│ └── index.html
└── src/
└── scss/
└── connection_manager.scss
Model Definition
# models/connection_endpoint.py
from odoo import models, fields, api
import psycopg2
class ConnectionEndpoint(models.Model):
_name = 'insightpulse.connection.endpoint'
_description = 'Connection Endpoint'
_order = 'sequence, name'
name = fields.Char(required=True)
connection_type = fields.Selection([
('supabase', 'Supabase'),
('postgresql', 'PostgreSQL'),
('odoo', 'Odoo Database'),
('superset', 'Apache Superset'),
('mcp', 'MCP Server'),
('api', 'REST API'),
], required=True)
base_url = fields.Char(string='Server/Host')
port = fields.Integer(default=5432)
database_name = fields.Char()
username = fields.Char()
password = fields.Char()
api_key = fields.Char()
connection_string = fields.Text(compute='_compute_connection_string')
env_vars = fields.Text(compute='_compute_env_vars')
docker_compose = fields.Text(compute='_compute_docker_compose')
status = fields.Selection([
('draft', 'Not Tested'),
('success', 'Connected'),
('failed', 'Failed'),
], default='draft')
@api.depends('connection_type', 'base_url', 'port', 'database_name', 'username', 'password')
def _compute_connection_string(self):
for rec in self:
if rec.connection_type in ['supabase', 'postgresql', 'odoo']:
rec.connection_string = (
f"postgresql://{rec.username}:{rec.password}@"
f"{rec.base_url}:{rec.port}/{rec.database_name}"
)
elif rec.connection_type == 'superset':
rec.connection_string = f"http://{rec.base_url}:{rec.port}"
else:
rec.connection_string = f"{rec.base_url}"
@api.depends('name', 'connection_string')
def _compute_env_vars(self):
for rec in self:
safe_name = rec.name.upper().replace(' ', '_').replace('-', '_')
rec.env_vars = (
f"{safe_name}_URL={rec.connection_string}\n"
f"{safe_name}_USER={rec.username}\n"
f"{safe_name}_PASSWORD={rec.password}"
)
def action_test_connection(self):
"""Test database connection"""
for rec in self:
try:
if rec.connection_type in ['supabase', 'postgresql', 'odoo']:
conn = psycopg2.connect(rec.connection_string)
conn.close()
rec.status = 'success'
return {
'type': 'ir.actions.client',
'tag': 'display_notification',
'params': {
'message': f'✅ Connected to {rec.name}',
'type': 'success',
'sticky': False,
}
}
except Exception as e:
rec.status = 'failed'
return {
'type': 'ir.actions.client',
'tag': 'display_notification',
'params': {
'message': f'❌ Connection failed: {str(e)}',
'type': 'danger',
'sticky': True,
}
}
View Definition (Kanban)
<!-- views/connection_endpoint_kanban.xml -->
<record id="view_connection_endpoint_kanban" model="ir.ui.view">
<field name="name">insightpulse.connection.endpoint.kanban</field>
<field name="model">insightpulse.connection.endpoint</field>
<field name="arch" type="xml">
<kanban class="o_kanban_mobile" sample="1">
<field name="id"/>
<field name="name"/>
<field name="connection_type"/>
<field name="status"/>
<field name="connection_string"/>
<templates>
<t t-name="kanban-box">
<div class="oe_kanban_global_click o_kanban_record_has_image_fill">
<div class="o_kanban_record_top">
<div class="o_kanban_record_headings">
<strong class="o_kanban_record_title">
<field name="name"/>
</strong>
<span class="badge badge-pill"
t-attf-class="badge-{{status == 'success' and 'success' or status == 'failed' and 'danger' or 'secondary'}}">
<field name="status"/>
</span>
</div>
</div>
<div class="o_kanban_record_body">
<field name="connection_type" widget="badge"/>
<div class="text-muted">
<i class="fa fa-server"/> <field name="base_url"/>:<field name="port"/>
</div>
</div>
<div class="o_kanban_record_bottom">
<div class="oe_kanban_bottom_left">
<button type="object" name="action_test_connection"
class="btn btn-sm btn-secondary">
<i class="fa fa-plug"/> Test
</button>
</div>
<div class="oe_kanban_bottom_right">
<button type="object" name="action_copy_connection_string"
class="btn btn-sm btn-link">
<i class="fa fa-clipboard"/> Copy
</button>
</div>
</div>
</div>
</t>
</templates>
</kanban>
</field>
</record>
Default Data
<!-- data/default_endpoints.xml -->
<odoo>
<data noupdate="1">
<!-- Supabase Production -->
<record id="endpoint_supabase_prod" model="insightpulse.connection.endpoint">
<field name="name">Supabase Production</field>
<field name="connection_type">supabase</field>
<field name="base_url">db.spdtwktxdalcfigzeqrz.supabase.co</field>
<field name="port">5432</field>
<field name="database_name">postgres</field>
<field name="username">postgres</field>
<field name="sequence">10</field>
</record>
<!-- Odoo Database -->
<record id="endpoint_odoo_db" model="insightpulse.connection.endpoint">
<field name="name">Odoo 19 Database</field>
<field name="connection_type">odoo</field>
<field name="base_url">localhost</field>
<field name="port">5432</field>
<field name="database_name">odoo19</field>
<field name="username">odoo</field>
<field name="sequence">20</field>
</record>
<!-- Apache Superset -->
<record id="endpoint_superset" model="insightpulse.connection.endpoint">
<field name="name">Apache Superset Dashboard</field>
<field name="connection_type">superset</field>
<field name="base_url">localhost</field>
<field name="port">8088</field>
<field name="username">admin</field>
<field name="sequence">30</field>
</record>
<!-- MCP Server - Notion -->
<record id="endpoint_mcp_notion" model="insightpulse.connection.endpoint">
<field name="name">MCP Server - Notion</field>
<field name="connection_type">mcp</field>
<field name="base_url">http://localhost:3000</field>
<field name="sequence">40</field>
</record>
</data>
</odoo>
Integration Points
With Odoo Finance Modules
# Access connections from other modules
connection = self.env['insightpulse.connection.endpoint'].search([
('name', '=', 'Supabase Production')
], limit=1)
if connection:
# Use connection string for external API calls
import requests
response = requests.get(
f"{connection.connection_string}/rest/v1/bir_forms",
headers={'apikey': connection.api_key}
)
With Superset Dashboards
# Auto-configure Superset database connections
superset_conn = self.env['insightpulse.connection.endpoint'].search([
('connection_type', '=', 'superset')
], limit=1)
# Generate Superset database URI
db_uri = f"postgresql+psycopg2://{username}:{password}@{host}:{port}/{database}"
With MCP Servers
# Manage MCP server endpoints
mcp_servers = self.env['insightpulse.connection.endpoint'].search([
('connection_type', '=', 'mcp')
])
for server in mcp_servers:
# Register MCP server URL for bridge connections
mcp_config[server.name] = {
'url': server.base_url,
'api_key': server.api_key,
}
Output Formats
Connection String
postgresql://postgres:password@db.spdtwktxdalcfigzeqrz.supabase.co:5432/postgres
Environment Variables
SUPABASE_PRODUCTION_URL=postgresql://postgres:password@db.spdtwktxdalcfigzeqrz.supabase.co:5432/postgres
SUPABASE_PRODUCTION_USER=postgres
SUPABASE_PRODUCTION_PASSWORD=password
Docker Compose
services:
app:
environment:
- DATABASE_URL=postgresql://postgres:password@db.spdtwktxdalcfigzeqrz.supabase.co:5432/postgres
BIR Compliance Integration
Connection for BIR Systems
<record id="endpoint_bir_portal" model="insightpulse.connection.endpoint">
<field name="name">BIR eFPS Portal API</field>
<field name="connection_type">api</field>
<field name="base_url">https://efps.bir.gov.ph</field>
<field name="api_key">YOUR_BIR_API_KEY</field>
</record>
Usage in BIR Module
# Fetch BIR connection for form submission
bir_conn = self.env['insightpulse.connection.endpoint'].search([
('name', 'ilike', 'BIR')
], limit=1)
# Submit Form 1601-C via API
import requests
response = requests.post(
f"{bir_conn.base_url}/api/submit/1601-c",
headers={'Authorization': f'Bearer {bir_conn.api_key}'},
json=form_data
)
Security Best Practices
Access Control
<!-- security/connection_security.xml -->
<record id="group_connection_manager" model="res.groups">
<field name="name">Connection Manager</field>
<field name="category_id" ref="base.module_category_administration"/>
</record>
<record id="group_connection_admin" model="res.groups">
<field name="name">Connection Administrator</field>
<field name="category_id" ref="base.module_category_administration"/>
<field name="implied_ids" eval="[(4, ref('group_connection_manager'))]"/>
</record>
Password Encryption
from cryptography.fernet import Fernet
def _encrypt_password(self, password):
"""Encrypt sensitive credentials"""
key = self.env['ir.config_parameter'].sudo().get_param('connection.encryption.key')
f = Fernet(key.encode())
return f.encrypt(password.encode()).decode()
def _decrypt_password(self, encrypted_password):
"""Decrypt credentials for use"""
key = self.env['ir.config_parameter'].sudo().get_param('connection.encryption.key')
f = Fernet(key.encode())
return f.decrypt(encrypted_password.encode()).decode()
Examples
Example 1: Multi-Agency Database Connections
# Create connections for 8 agencies
agencies = ['RIM', 'CKVC', 'BOM', 'JPAL', 'JLI', 'JAP', 'LAS', 'RMQB']
for agency in agencies:
self.env['insightpulse.connection.endpoint'].create({
'name': f'{agency} Database',
'connection_type': 'postgresql',
'base_url': 'db.spdtwktxdalcfigzeqrz.supabase.co',
'port': 5432,
'database_name': f'{agency.lower()}_db',
'username': 'postgres',
'password': os.getenv(f'{agency}_DB_PASSWORD'),
})
Example 2: Connection Health Dashboard
def get_connection_health_dashboard(self):
"""Generate health metrics for all connections"""
connections = self.env['insightpulse.connection.endpoint'].search([])
health_data = {
'total': len(connections),
'active': len(connections.filtered(lambda c: c.status == 'success')),
'failed': len(connections.filtered(lambda c: c.status == 'failed')),
'not_tested': len(connections.filtered(lambda c: c.status == 'draft')),
'by_type': {}
}
for conn_type in ['supabase', 'postgresql', 'odoo', 'superset', 'mcp', 'api']:
type_conns = connections.filtered(lambda c: c.connection_type == conn_type)
health_data['by_type'][conn_type] = len(type_conns)
return health_data
Example 3: Auto-Generate .env File
def generate_env_file(self):
"""Generate complete .env file for deployment"""
connections = self.env['insightpulse.connection.endpoint'].search([])
env_content = "# InsightPulse AI - Connection Configuration\n"
env_content += "# Auto-generated from Connection Manager\n\n"
for conn in connections:
safe_name = conn.name.upper().replace(' ', '_').replace('-', '_')
env_content += f"# {conn.name}\n"
env_content += f"{safe_name}_URL={conn.connection_string}\n"
env_content += f"{safe_name}_USER={conn.username}\n"
env_content += f"{safe_name}_PASSWORD={conn.password}\n"
if conn.api_key:
env_content += f"{safe_name}_API_KEY={conn.api_key}\n"
env_content += "\n"
return env_content
Cost Savings
By using this self-hosted connection manager:
- No vendor lock-in: Own your infrastructure
- Zero licensing costs: Open-source solution
- Integrated workflow: All connections in one place
- Replaces: Paid connection management tools ($50-200/month)
Annual Savings: $600-2,400
Production Deployment
Installation
# Copy module to Odoo addons
cp -r insightpulse_connection_manager /odoo/addons/
# Update module list in Odoo
# Apps → Update Apps List
# Install module
# Apps → Search "InsightPulse Connection Manager" → Install
Docker Deployment
# docker-compose.yml
services:
odoo:
image: odoo:19
volumes:
- ./insightpulse_connection_manager:/mnt/extra-addons/insightpulse_connection_manager
Kubernetes Deployment
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: odoo
spec:
template:
spec:
containers:
- name: odoo
volumeMounts:
- name: addons
mountPath: /mnt/extra-addons/insightpulse_connection_manager
Troubleshooting
Connection Test Fails
# Check psycopg2 is installed
pip install psycopg2-binary
# Verify firewall rules
# Ensure port 5432 is open for PostgreSQL connections
# Check credentials
# Verify username/password in Supabase/Odoo settings
Permission Denied
# Add user to connection manager group
# Settings → Users → Select User → Groups → Add "Connection Manager"
License
LGPL-3.0 (required for Odoo modules)
References
Built for Finance Shared Service Centers managing multi-agency operations with self-hosted infrastructure.