Skip to main content

Extensibility and Customization

Introduction​

The ESG Management System is designed with extensibility and customization at its core, enabling organizations to tailor the platform to their specific ESG requirements, industry standards, and business processes. Built on the flexible Frappe framework, the system provides multiple layers of customization from simple configuration changes to complex custom development.

1. Configuration-Based Customization​

ESG Constants and Standards​

The system provides extensive configuration options through constants and settings that can be customized without code changes:

Energy Source Configuration​

# Customizable energy source types and emission factors
RENEWABLE_SOURCES = ["Wind", "Solar", "Hydro", "Biomass", "Ocean", "Waste-to-Energy", "Other Renewable"]
FOSSIL_SOURCES = ["Coal", "Oil", "Shale Oil", "Shale Gas", "Peat", "Other Fossil"]
NEUTRAL_SOURCES = ["Electricity", "Gas"]  # Can be either renewable or fossil

# Customizable emission factors (kg CO2e per kWh)
EMISSION_FACTORS = {
    "Electricity": 0.5,  # Grid average, can be refined based on country/region
    "Gas": 0.2,
    "Coal": 0.9,
    "Oil": 0.7,
    "Wind": 0.01,
    "Solar": 0.02,
    "Hydro": 0.03,
    "Biomass": 0.05
}

# Customizable cost factors (USD per kWh)
COST_FACTORS = {
    "Electricity": 0.15,
    "Gas": 0.08,
    "Coal": 0.05,
    "Solar": 0.10,
    "Wind": 0.10,
    "Default": 0.12
}

ESG Measurement Units Customization​

# Extensible measurement units system
ESG_MEASUREMENT_UNITS = [
    {"value": "GJ", "label": "Gigajoules (GJ)", "group": "Energy"},
    {"value": "MWh", "label": "Megawatt Hours (MWh)", "group": "Energy"},
    {"value": "kWh", "label": "Kilowatt Hours (kWh)", "group": "Energy"},
    {"value": "t", "label": "Metric Tonnes (t)", "group": "Mass"},
    {"value": "tCO2e", "label": "Tonnes of CO2 Equivalent (tCO2e)", "group": "Emissions"},
    {"value": "m³", "label": "Cubic Meters (m³)", "group": "Volume"},
    {"value": "L", "label": "Liters (L)", "group": "Volume"},
    {"value": "%", "label": "Percentage (%)", "group": "Percentage"},
    {"value": "% of revenue", "label": "Percentage of Revenue", "group": "Percentage"},
    {"value": "hrs/emp", "label": "Hours per Employee", "group": "Ratio"},
    {"value": "incidents/mil hrs", "label": "Incidents per Million Hours", "group": "Ratio"},
    {"value": "USD", "label": "US Dollars (USD)", "group": "Currency"},
    {"value": "count", "label": "Count", "group": "Count"},
    {"value": "text", "label": "Text Response", "group": "Other"}
]

# Helper functions for unit management
def get_unit_options():
    """Generate grouped unit options for select fields"""
    unit_groups = {}
    for unit in ESG_MEASUREMENT_UNITS:
        if unit["group"] not in unit_groups:
            unit_groups[unit["group"]] = []
        unit_groups[unit["group"]].append(f"{unit['value']}: {unit['label']}")
    
    options = []
    for group, values in unit_groups.items():
        options.append(f"\n{group}")
        options.extend(values)
    
    return "\n".join(options)

def is_percentage_unit(value):
    """Check if a unit is percentage-based"""
    unit = get_unit_by_value(value)
    return unit and (unit["group"] == "Percentage" or "%" in unit["value"])

Application Hooks and Configuration​

Custom Hooks Registration​

# Application configuration and customization hooks
app_name = "esg_enviroment"
app_title = "ESG Enviroment Management"
app_publisher = "Duongtk"
app_description = "ESG ENV"

# Custom module inclusion
app_include_modules = ["ESG Enviroment Management"]

# Custom asset inclusion
app_include_css = ["/assets/esg_enviroment/css/esg_dashboard.bundle.css"]
app_include_js = ["/assets/esg_enviroment/js/custom_block_widget.js"]

# Custom commands for bench CLI
commands = ["esg_enviroment.esg_enviroment_management.utils.commands"]

# Workspace and role fixtures
fixtures = [
    {"dt": "Workspace", "filters": [["name", "in", ["ESG Enviroment", "Environmental Metrics"]]]},
    {"dt": "Module Def", "filters": [["name", "=", "ESG Enviroment Management"]]},
    {"dt": "Custom Role", "filters": [["name", "in", ["ESG Manager", "ESG User"]]]},
    {"dt": "Page", "filters": [["name", "in", ["esg-dashboard"]]]}
]

# Custom API endpoints
api_endpoints = [
    {'method': 'esg_enviroment.api.receive_mqtt_data', 'endpoint': 'esg/iot/mqtt'},
    {'method': 'esg_enviroment.api.receive_bulk_data', 'endpoint': 'esg/iot/bulk'},
    {'method': 'esg_enviroment.api.get_realtime_data', 'endpoint': 'esg/iot/data'}
]

2. Custom DocType Development​

Creating Custom ESG Metrics​

Custom Metric Definition​

# Example: Custom Carbon Footprint Calculator DocType
class CarbonFootprintCalculator(Document):
    def validate(self):
        """Custom validation for carbon footprint calculations"""
        self.validate_scope_emissions()
        self.calculate_total_footprint()
        self.set_reduction_targets()
    
    def validate_scope_emissions(self):
        """Validate scope 1, 2, and 3 emissions data"""
        if self.scope1_emissions < 0 or self.scope2_emissions < 0 or self.scope3_emissions < 0:
            frappe.throw("Emissions values cannot be negative")
        
        # Custom validation rules based on industry standards
        if self.industry_type == "Manufacturing":
            if self.scope1_emissions > self.scope2_emissions * 3:
                frappe.msgprint("Warning: Scope 1 emissions seem unusually high for manufacturing", 
                              indicator="orange")
    
    def calculate_total_footprint(self):
        """Calculate total carbon footprint with custom weighting"""
        # Custom calculation based on organization's methodology
        self.total_footprint = (
            self.scope1_emissions * 1.0 +  # Direct emissions
            self.scope2_emissions * 0.9 +  # Indirect energy emissions
            self.scope3_emissions * 0.7     # Other indirect emissions (weighted lower)
        )
        
        # Calculate intensity metrics
        if self.revenue:
            self.footprint_per_revenue = self.total_footprint / self.revenue
        if self.employee_count:
            self.footprint_per_employee = self.total_footprint / self.employee_count
    
    def set_reduction_targets(self):
        """Set science-based reduction targets"""
        # Custom target setting based on industry benchmarks
        industry_targets = {
            "Manufacturing": 0.045,  # 4.5% annual reduction
            "Technology": 0.07,      # 7% annual reduction
            "Energy": 0.03,          # 3% annual reduction
            "Default": 0.05          # 5% annual reduction
        }
        
        target_rate = industry_targets.get(self.industry_type, industry_targets["Default"])
        self.annual_reduction_target = self.total_footprint * target_rate

Custom Field Extensions​

Dynamic Field Configuration​

# Custom field additions through hooks
def add_custom_fields():
    """Add custom fields to existing DocTypes"""
    
    # Add custom fields to ESG Metric Value
    custom_fields = {
        "ESG Metric Value": [
            {
                "fieldname": "custom_verification_level",
                "label": "Verification Level",
                "fieldtype": "Select",
                "options": "Internal\nThird-party\nCertified Auditor",
                "insert_after": "verification_status"
            },
            {
                "fieldname": "custom_data_source_reliability",
                "label": "Data Source Reliability",
                "fieldtype": "Rating",
                "insert_after": "source_id"
            },
            {
                "fieldname": "custom_industry_benchmark",
                "label": "Industry Benchmark",
                "fieldtype": "Float",
                "precision": 3,
                "insert_after": "value"
            }
        ],
        
        # Add custom fields to ESG Report
        "ESG Report": [
            {
                "fieldname": "custom_materiality_assessment",
                "label": "Materiality Assessment",
                "fieldtype": "Text Editor",
                "insert_after": "report_summary"
            },
            {
                "fieldname": "custom_stakeholder_feedback",
                "label": "Stakeholder Feedback",
                "fieldtype": "Table",
                "options": "Custom Stakeholder Feedback",
                "insert_after": "custom_materiality_assessment"
            }
        ]
    }
    
    for doctype, fields in custom_fields.items():
        for field in fields:
            create_custom_field(doctype, field)

def create_custom_field(doctype, field_dict):
    """Create custom field if it doesn't exist"""
    if not frappe.db.exists("Custom Field", {"dt": doctype, "fieldname": field_dict["fieldname"]}):
        custom_field = frappe.get_doc({
            "doctype": "Custom Field",
            "dt": doctype,
            **field_dict
        })
        custom_field.insert()

3. Custom Calculation Engines​

Advanced Metric Calculations​

Custom Formula Engine​

class CustomESGCalculations:
    """Custom calculation engine for organization-specific ESG metrics"""
    
    @staticmethod
    def calculate_water_intensity(data):
        """Custom water intensity calculation"""
        total_water = data.get("water_withdrawal", 0) + data.get("water_recycled", 0)
        production_volume = data.get("production_volume", 1)
        
        # Custom calculation with efficiency factors
        efficiency_factor = data.get("water_efficiency_rating", 1.0)
        water_intensity = (total_water / production_volume) * efficiency_factor
        
        return round(water_intensity, 3)
    
    @staticmethod
    def calculate_circular_economy_index(data):
        """Custom circular economy index calculation"""
        waste_recycled = data.get("waste_recycled", 0)
        waste_reused = data.get("waste_reused", 0)
        total_waste = data.get("total_waste", 1)
        material_recovery = data.get("material_recovery_rate", 0)
        
        # Custom circular economy formula
        circularity_rate = (waste_recycled + waste_reused) / total_waste
        circular_index = (circularity_rate * 0.6) + (material_recovery * 0.4)
        
        return min(round(circular_index * 100, 2), 100)  # Cap at 100%
    
    @staticmethod
    def calculate_biodiversity_impact_score(data):
        """Custom biodiversity impact assessment"""
        protected_area_ratio = data.get("protected_area_ratio", 0)
        species_diversity_index = data.get("species_diversity_index", 0)
        habitat_restoration = data.get("habitat_restoration_area", 0)
        total_land_use = data.get("total_land_use", 1)
        
        # Weighted biodiversity score
        biodiversity_score = (
            protected_area_ratio * 0.4 +
            species_diversity_index * 0.3 +
            (habitat_restoration / total_land_use) * 0.3
        )
        
        return round(biodiversity_score * 100, 2)

# Integration with ESG Metric Value calculation engine
def execute_custom_calculation_formula(self):
    """Extended calculation formula execution with custom functions"""
    if not self.metric_definition:
        return
    
    try:
        metric_def = frappe.get_doc("ESG Metric Definition", self.metric_definition)
        
        if not metric_def.calculation_formula:
            return
        
        # Collect data for calculation
        data = self.collect_calculation_data()
        
        # Create enhanced namespace with custom functions
        namespace = {
            "frappe": frappe,
            "CustomESGCalculations": CustomESGCalculations,
            "math": __import__("math"),
            "datetime": __import__("datetime"),
            "statistics": __import__("statistics")
        }
        
        # Execute the formula
        exec(metric_def.calculation_formula, namespace)
        
        if "calculate" in namespace and callable(namespace["calculate"]):
            result = namespace["calculate"](data)
            
            if result is not None:
                self.value = round(float(result), 3)
                self.calculation_method = "Custom Formula"
                frappe.msgprint(f"Custom calculation completed: {self.value}", indicator="green")
        
    except Exception as e:
        frappe.log_error(f"Custom calculation error: {str(e)}", "Custom ESG Calculation")
        frappe.msgprint(f"Calculation error: {str(e)}", indicator="red")

4. Custom Reporting and Analytics​

Custom Report Templates​

Industry-Specific Report Generator​

class CustomESGReportGenerator:
    """Generate industry-specific ESG reports"""
    
    def __init__(self, organization, industry_type, reporting_period):
        self.organization = organization
        self.industry_type = industry_type
        self.reporting_period = reporting_period
        self.report_template = self.get_industry_template()
    
    def get_industry_template(self):
        """Get industry-specific report template"""
        templates = {
            "Manufacturing": {
                "key_metrics": ["energy_intensity", "water_intensity", "waste_generation", "ghg_emissions"],
                "benchmarks": "manufacturing_benchmarks",
                "regulations": ["ISO_14001", "EPA_regulations"],
                "stakeholders": ["employees", "communities", "regulators", "customers"]
            },
            "Technology": {
                "key_metrics": ["energy_consumption", "e_waste", "data_center_efficiency", "supply_chain_emissions"],
                "benchmarks": "tech_industry_benchmarks",
                "regulations": ["WEEE_directive", "conflict_minerals"],
                "stakeholders": ["employees", "customers", "investors", "NGOs"]
            },
            "Financial_Services": {
                "key_metrics": ["financed_emissions", "green_investments", "esg_integration", "climate_risk"],
                "benchmarks": "financial_benchmarks",
                "regulations": ["TCFD", "EU_taxonomy", "SFDR"],
                "stakeholders": ["investors", "regulators", "clients", "employees"]
            }
        }
        
        return templates.get(self.industry_type, templates["Manufacturing"])
    
    def generate_custom_report(self):
        """Generate customized ESG report"""
        report_data = {
            "organization": self.organization,
            "industry_type": self.industry_type,
            "reporting_period": self.reporting_period,
            "executive_summary": self.generate_executive_summary(),
            "key_metrics": self.collect_key_metrics(),
            "benchmark_analysis": self.perform_benchmark_analysis(),
            "regulatory_compliance": self.assess_regulatory_compliance(),
            "stakeholder_impact": self.analyze_stakeholder_impact(),
            "improvement_recommendations": self.generate_recommendations()
        }
        
        return self.format_report(report_data)
    
    def generate_executive_summary(self):
        """Generate industry-specific executive summary"""
        # Custom logic for executive summary based on industry
        pass
    
    def collect_key_metrics(self):
        """Collect industry-relevant metrics"""
        metrics = {}
        for metric_code in self.report_template["key_metrics"]:
            metric_value = frappe.db.get_value(
                "ESG Metric Value",
                {
                    "organization": self.organization,
                    "metric_definition": metric_code,
                    "esg_period": self.reporting_period
                },
                "value"
            )
            metrics[metric_code] = metric_value
        
        return metrics

Custom Dashboard Widgets​

Real-time ESG Dashboard Components​

// Custom dashboard widget for real-time ESG metrics
frappe.provide("esg_custom_widgets");

esg_custom_widgets.RealTimeMetricsWidget = class {
    constructor(parent, options) {
        this.parent = parent;
        this.options = options;
        this.setup();
    }
    
    setup() {
        this.wrapper = $(`
            <div class="custom-esg-widget">
                <div class="widget-header">
                    <h4>${this.options.title}</h4>
                    <div class="widget-controls">
                        <button class="btn btn-xs btn-default refresh-btn">
                            <i class="fa fa-refresh"></i>
                        </button>
                    </div>
                </div>
                <div class="widget-content">
                    <div class="metrics-grid"></div>
                </div>
            </div>
        `).appendTo(this.parent);
        
        this.setup_realtime_updates();
        this.load_metrics();
    }
    
    setup_realtime_updates() {
        // WebSocket connection for real-time updates
        frappe.realtime.on('esg_metric_update', (data) => {
            if (data.organization === this.options.organization) {
                this.update_metric_display(data);
            }
        });
        
        // Refresh button handler
        this.wrapper.find('.refresh-btn').on('click', () => {
            this.load_metrics();
        });
    }
    
    load_metrics() {
        frappe.call({
            method: 'esg_enviroment.api.get_realtime_metrics',
            args: {
                organization: this.options.organization,
                metric_types: this.options.metric_types
            },
            callback: (r) => {
                if (r.message) {
                    this.render_metrics(r.message);
                }
            }
        });
    }
    
    render_metrics(metrics) {
        const grid = this.wrapper.find('.metrics-grid');
        grid.empty();
        
        metrics.forEach(metric => {
            const metric_card = $(`
                <div class="metric-card" data-metric="${metric.code}">
                    <div class="metric-label">${metric.label}</div>
                    <div class="metric-value ${this.get_status_class(metric.status)}">
                        ${metric.value} ${metric.unit}
                    </div>
                    <div class="metric-trend">
                        <i class="fa fa-${metric.trend === 'up' ? 'arrow-up' : 'arrow-down'}"></i>
                        ${metric.change}%
                    </div>
                </div>
            `);
            
            grid.append(metric_card);
        });
    }
    
    update_metric_display(data) {
        const metric_card = this.wrapper.find(`[data-metric="${data.metric_code}"]`);
        if (metric_card.length) {
            metric_card.find('.metric-value')
                .removeClass('status-good status-warning status-danger')
                .addClass(this.get_status_class(data.status))
                .text(`${data.value} ${data.unit}`);
            
            // Animate the update
            metric_card.addClass('updated');
            setTimeout(() => metric_card.removeClass('updated'), 1000);
        }
    }
    
    get_status_class(status) {
        const status_map = {
            'good': 'status-good',
            'warning': 'status-warning',
            'danger': 'status-danger'
        };
        return status_map[status] || '';
    }
};

// Register custom widget
frappe.ui.form.on('ESG Dashboard', {
    refresh: function(frm) {
        // Add custom real-time metrics widget
        new esg_custom_widgets.RealTimeMetricsWidget(
            frm.dashboard.wrapper,
            {
                title: 'Real-time ESG Metrics',
                organization: frm.doc.organization,
                metric_types: ['energy', 'emissions', 'water', 'waste']
            }
        );
    }
});

5. Integration Extensions​

Custom API Endpoints​

Industry-Specific API Extensions​

# Custom API endpoints for specific industry requirements
@frappe.whitelist()
def get_manufacturing_esg_metrics(facility_id, from_date, to_date):
    """Custom API for manufacturing industry ESG metrics"""
    
    # Manufacturing-specific metrics
    metrics = {
        "energy_intensity": get_energy_intensity_per_unit(facility_id, from_date, to_date),
        "water_intensity": get_water_intensity_per_unit(facility_id, from_date, to_date),
        "waste_generation_rate": get_waste_generation_rate(facility_id, from_date, to_date),
        "material_efficiency": get_material_efficiency(facility_id, from_date, to_date),
        "safety_incidents": get_safety_incident_rate(facility_id, from_date, to_date)
    }
    
    # Add industry benchmarks
    metrics["benchmarks"] = get_manufacturing_benchmarks(facility_id)
    
    # Calculate compliance scores
    metrics["compliance_scores"] = calculate_manufacturing_compliance(metrics)
    
    return metrics

@frappe.whitelist()
def submit_supply_chain_esg_data(supplier_data):
    """Custom API for supply chain ESG data submission"""
    
    try:
        # Validate supplier data format
        validated_data = validate_supplier_esg_data(supplier_data)
        
        # Process each supplier's ESG data
        results = []
        for supplier in validated_data:
            # Create or update supplier ESG record
            supplier_doc = create_or_update_supplier_esg(supplier)
            
            # Calculate supplier ESG score
            esg_score = calculate_supplier_esg_score(supplier)
            
            # Update supplier risk assessment
            risk_assessment = update_supplier_risk_assessment(supplier, esg_score)
            
            results.append({
                "supplier_id": supplier["supplier_id"],
                "esg_score": esg_score,
                "risk_level": risk_assessment["risk_level"],
                "recommendations": risk_assessment["recommendations"]
            })
        
        return {
            "success": True,
            "processed_suppliers": len(results),
            "results": results
        }
        
    except Exception as e:
        frappe.log_error(f"Supply chain ESG data error: {str(e)}")
        return {"success": False, "error": str(e)}

def validate_supplier_esg_data(data):
    """Validate supplier ESG data format"""
    required_fields = ["supplier_id", "environmental_score", "social_score", "governance_score"]
    
    for supplier in data:
        missing_fields = [field for field in required_fields if field not in supplier]
        if missing_fields:
            frappe.throw(f"Missing fields for supplier {supplier.get('supplier_id', 'unknown')}: {missing_fields}")
    
    return data

Custom Workflow Extensions​

ESG Data Approval Workflows​

class CustomESGWorkflow:
    """Custom workflow for ESG data approval and verification"""
    
    @staticmethod
    def setup_esg_approval_workflow():
        """Setup custom approval workflow for ESG data"""
        
        workflow_states = [
            {"state": "Draft", "allow_edit": "ESG User"},
            {"state": "Pending Review", "allow_edit": "ESG Manager"},
            {"state": "Under Verification", "allow_edit": "ESG Auditor"},
            {"state": "Approved", "allow_edit": "System Manager"},
            {"state": "Rejected", "allow_edit": "ESG Manager"}
        ]
        
        workflow_transitions = [
            {"from": "Draft", "to": "Pending Review", "action": "Submit for Review"},
            {"from": "Pending Review", "to": "Under Verification", "action": "Send for Verification"},
            {"from": "Pending Review", "to": "Rejected", "action": "Reject"},
            {"from": "Under Verification", "to": "Approved", "action": "Approve"},
            {"from": "Under Verification", "to": "Rejected", "action": "Reject"},
            {"from": "Rejected", "to": "Draft", "action": "Revise"}
        ]
        
        return {
            "states": workflow_states,
            "transitions": workflow_transitions
        }
    
    @staticmethod
    def validate_esg_data_quality(doc):
        """Custom validation for ESG data quality"""
        quality_checks = {
            "completeness": check_data_completeness(doc),
            "accuracy": check_data_accuracy(doc),
            "consistency": check_data_consistency(doc),
            "timeliness": check_data_timeliness(doc)
        }
        
        overall_quality = sum(quality_checks.values()) / len(quality_checks)
        
        if overall_quality < 0.8:  # 80% quality threshold
            frappe.throw(f"Data quality score ({overall_quality:.2%}) below required threshold (80%)")
        
        return quality_checks

def check_data_completeness(doc):
    """Check if all required fields are populated"""
    required_fields = get_required_fields_for_doctype(doc.doctype)
    populated_fields = sum(1 for field in required_fields if getattr(doc, field, None))
    return populated_fields / len(required_fields) if required_fields else 1.0

def check_data_accuracy(doc):
    """Check data accuracy against validation rules"""
    # Custom accuracy checks based on business rules
    accuracy_score = 1.0
    
    # Example: Check if values are within expected ranges
    if hasattr(doc, 'value') and doc.value:
        if doc.value < 0:
            accuracy_score -= 0.3  # Negative values reduce accuracy
        
        # Check against historical data for anomalies
        historical_avg = get_historical_average(doc.metric_definition, doc.organization)
        if historical_avg and abs(doc.value - historical_avg) > (historical_avg * 2):
            accuracy_score -= 0.2  # Large deviations reduce accuracy
    
    return max(0, accuracy_score)

6. Custom User Interface Extensions​

Custom Form Enhancements​

Dynamic Form Behavior​

// Custom form enhancements for ESG data entry
frappe.ui.form.on('ESG Metric Value', {
    refresh: function(frm) {
        // Add custom buttons based on user role and document status
        add_custom_action_buttons(frm);
        
        // Setup dynamic field behavior
        setup_dynamic_fields(frm);
        
        // Add custom validation indicators
        add_validation_indicators(frm);
    },
    
    metric_definition: function(frm) {
        // Auto-populate fields based on metric definition
        if (frm.doc.metric_definition) {
            frappe.call({
                method: 'esg_enviroment.api.get_metric_definition_details',
                args: {metric_definition: frm.doc.metric_definition},
                callback: function(r) {
                    if (r.message) {
                        populate_metric_details(frm, r.message);
                    }
                }
            });
        }
    },
    
    value: function(frm) {
        // Real-time validation and calculation
        if (frm.doc.value && frm.doc.metric_definition) {
            validate_metric_value(frm);
            calculate_derived_metrics(frm);
        }
    }
});

function add_custom_action_buttons(frm) {
    // Custom button for data verification
    if (frm.doc.docstatus === 1 && !frm.doc.is_verified) {
        frm.add_custom_button(__('Verify Data'), function() {
            show_verification_dialog(frm);
        }, __('Actions'));
    }
    
    // Custom button for benchmark comparison
    if (frm.doc.value && frm.doc.metric_definition) {
        frm.add_custom_button(__('Compare with Benchmarks'), function() {
            show_benchmark_comparison(frm);
        }, __('Analysis'));
    }
    
    // Custom button for trend analysis
    frm.add_custom_button(__('View Trends'), function() {
        show_trend_analysis(frm);
    }, __('Analysis'));
}

function setup_dynamic_fields(frm) {
    // Show/hide fields based on metric type
    if (frm.doc.metric_definition) {
        frappe.call({
            method: 'frappe.client.get_value',
            args: {
                doctype: 'ESG Metric Definition',
                filters: {name: frm.doc.metric_definition},
                fieldname: ['category', 'subcategory', 'calculation_method']
            },
            callback: function(r) {
                if (r.message) {
                    toggle_category_specific_fields(frm, r.message);
                }
            }
        });
    }
}

function toggle_category_specific_fields(frm, metric_info) {
    // Environmental metrics specific fields
    if (metric_info.category === 'Environmental') {
        frm.toggle_display('emission_factor', metric_info.subcategory === 'Emissions');
        frm.toggle_display('energy_source', metric_info.subcategory === 'Energy');
        frm.toggle_display('water_source', metric_info.subcategory === 'Water');
    }
    
    // Social metrics specific fields
    if (metric_info.category === 'Social') {
        frm.toggle_display('employee_category', true);
        frm.toggle_display('training_hours', metric_info.subcategory === 'Training');
    }
    
    // Governance metrics specific fields
    if (metric_info.category === 'Governance') {
        frm.toggle_display('policy_reference', true);
        frm.toggle_display('compliance_framework', true);
    }
}

7. Custom Integration Patterns​

Third-Party System Integration​

ERP System Integration Template​

class CustomERPIntegration:
    """Template for custom ERP system integration"""
    
    def __init__(self, erp_system_type, connection_config):
        self.erp_system = erp_system_type
        self.config = connection_config
        self.connector = self.get_connector()
    
    def get_connector(self):
        """Get appropriate connector based on ERP system"""
        connectors = {
            "SAP": SAPConnector(self.config),
            "Oracle": OracleConnector(self.config),
            "Microsoft_Dynamics": DynamicsConnector(self.config),
            "Custom": CustomERPConnector(self.config)
        }
        return connectors.get(self.erp_system, connectors["Custom"])
    
    def sync_environmental_data(self):
        """Sync environmental data from ERP system"""
        try:
            # Get energy consumption data
            energy_data = self.connector.get_energy_consumption_data()
            self.process_energy_data(energy_data)
            
            # Get water consumption data
            water_data = self.connector.get_water_consumption_data()
            self.process_water_data(water_data)
            
            # Get waste generation data
            waste_data = self.connector.get_waste_generation_data()
            self.process_waste_data(waste_data)
            
            return {"success": True, "message": "Environmental data synced successfully"}
            
        except Exception as e:
            frappe.log_error(f"ERP sync error: {str(e)}", "Custom ERP Integration")
            return {"success": False, "error": str(e)}
    
    def process_energy_data(self, energy_data):
        """Process and store energy consumption data"""
        for record in energy_data:
            # Create or update Energy Consumption record
            energy_doc = frappe.get_doc({
                "doctype": "Energy Consumption",
                "facility_id": record["facility_id"],
                "reporting_period": record["period"],
                "electricity_kwh": record["electricity_consumption"],
                "gas_kwh": record["gas_consumption"],
                "source_id": f"ERP_{self.erp_system}",
                "data_source": "ERP Integration",
                "verification_status": "Unverified"
            })
            
            # Check if record already exists
            existing = frappe.db.exists("Energy Consumption", {
                "facility_id": record["facility_id"],
                "reporting_period": record["period"]
            })
            
            if existing:
                energy_doc.name = existing
                energy_doc.save()
            else:
                energy_doc.insert()

class SAPConnector:
    """SAP-specific connector implementation"""
    
    def __init__(self, config):
        self.config = config
        self.connection = self.establish_connection()
    
    def establish_connection(self):
        """Establish connection to SAP system"""
        # SAP-specific connection logic
        pass
    
    def get_energy_consumption_data(self):
        """Get energy consumption data from SAP"""
        # SAP-specific data extraction logic
        pass

Key Customization Features​

Configuration Options​

  • ESG Constants: Customizable emission factors, energy sources, and measurement units
  • Application Hooks: Custom module inclusion, asset loading, and API endpoints
  • Workflow Configuration: Custom approval workflows and validation rules
  • Role-Based Customization: Industry-specific user roles and permissions

Development Extensions​

  • Custom DocTypes: Create new document types for specific ESG requirements
  • Custom Fields: Add fields to existing documents without code modification
  • Custom Calculations: Implement organization-specific calculation formulas
  • Custom Reports: Generate industry-specific ESG reports and analytics

Integration Capabilities​

  • API Extensions: Custom endpoints for industry-specific requirements
  • Third-Party Integration: Templates for ERP, SCADA, and other system integration
  • Real-time Widgets: Custom dashboard components for live data visualization
  • Workflow Extensions: Custom approval and verification workflows

Conclusion​

The ESG Management System provides extensive extensibility and customization capabilities, enabling organizations to tailor the platform to their specific requirements. From simple configuration changes to complex custom development, the system's flexible architecture supports a wide range of customization scenarios while maintaining system integrity and performance. Organizations can start with basic configurations and gradually implement more sophisticated customizations as their ESG management maturity evolves.