CargoWise Custom Development: Workflow Extensions & Automation (2025 Guide)

Jan 19, 2025•

cargowisecustom-developmentworkflowautomation

•

CargoWise custom development enables freight forwarders to extend and automate their operations beyond standard functionality. By leveraging CargoWise's powerful scripting engine, workflow extensions, and business rule framework, organizations can create tailored solutions that address specific business requirements and streamline complex processes.

This comprehensive guide covers everything you need to know about CargoWise custom development, from basic workflow extensions to advanced automation patterns. Whether you're a developer building your first CargoWise extension or an experienced architect designing enterprise-scale solutions, this guide will provide the technical foundation you need.

Understanding CargoWise Custom Development

What is CargoWise Custom Development?

CargoWise custom development involves creating extensions, scripts, and workflows that integrate with CargoWise's core functionality to address specific business requirements. These customizations can range from simple field validations to complex automated workflows that span multiple CargoWise modules.

Key Development Areas:

Workflow Extensions: Custom business processes and automation
Business Rules: Data validation and business logic enforcement
Script Development: Custom calculations and data processing
Integration Extensions: External system integrations
User Interface Customizations: Custom forms and dashboards
Reporting Extensions: Custom reports and data exports

CargoWise Development Architecture

Development Components:

Script Engine: CargoWise's built-in scripting environment
Workflow Engine: Process automation and workflow management
Business Rules Engine: Rule-based logic and validation
Integration Framework: External system connectivity
Custom Forms: User interface customizations
Report Builder: Custom reporting capabilities

CargoWise Scripting Fundamentals

Script Types and Use Cases

1. Field Scripts

Execute when specific fields are modified
Used for validation, calculation, and data transformation
Triggered on field change, focus, or blur events

2. Form Scripts

Execute when forms are loaded, saved, or closed
Used for form initialization, data loading, and cleanup
Triggered on form events

3. Workflow Scripts

Execute as part of workflow processes
Used for business logic, decision making, and automation
Triggered by workflow events

4. Integration Scripts

Execute during data exchange with external systems
Used for data transformation, validation, and mapping
Triggered by integration events

Basic Script Development

CargoWise Script Example (Field Validation):

// Field script for shipment weight validation
function validateShipmentWeight() {
    var weight = GetFieldValue("Weight");
    var mode = GetFieldValue("Mode");
    
    if (weight <= 0) {
        ShowMessage("Weight must be greater than zero");
        SetFieldFocus("Weight");
        return false;
    }
    
    // Air freight weight limits
    if (mode == "Air" && weight > 1000) {
        ShowMessage("Air freight weight cannot exceed 1000 kg");
        SetFieldFocus("Weight");
        return false;
    }
    
    // Ocean freight weight limits
    if (mode == "Ocean" && weight > 50000) {
        ShowMessage("Ocean freight weight cannot exceed 50000 kg");
        SetFieldFocus("Weight");
        return false;
    }
    
    return true;
}

CargoWise Script Example (Calculation):

// Calculate total freight charges
function calculateFreightCharges() {
    var weight = parseFloat(GetFieldValue("Weight"));
    var volume = parseFloat(GetFieldValue("Volume"));
    var rate = parseFloat(GetFieldValue("RatePerKg"));
    var mode = GetFieldValue("Mode");
    
    var totalCharges = 0;
    
    if (mode == "Air") {
        // Air freight: chargeable weight is greater of actual weight or volume weight
        var volumeWeight = volume * 167; // 167 kg per cubic meter
        var chargeableWeight = Math.max(weight, volumeWeight);
        totalCharges = chargeableWeight * rate;
    } else if (mode == "Ocean") {
        // Ocean freight: chargeable weight is greater of actual weight or volume weight
        var volumeWeight = volume * 1000; // 1000 kg per cubic meter
        var chargeableWeight = Math.max(weight, volumeWeight);
        totalCharges = chargeableWeight * rate;
    }
    
    SetFieldValue("TotalCharges", totalCharges.toFixed(2));
    SetFieldValue("ChargeableWeight", chargeableWeight.toFixed(2));
}

CargoWise Script Example (Data Integration):

// Integrate with external carrier system
function integrateWithCarrier() {
    var shipmentId = GetFieldValue("ShipmentId");
    var carrier = GetFieldValue("Carrier");
    var mode = GetFieldValue("Mode");
    
    try {
        // Prepare data for carrier integration
        var carrierData = {
            shipmentId: shipmentId,
            carrier: carrier,
            mode: mode,
            weight: GetFieldValue("Weight"),
            volume: GetFieldValue("Volume"),
            origin: GetFieldValue("Origin"),
            destination: GetFieldValue("Destination")
        };
        
        // Call external API
        var response = CallExternalAPI("https://api.carrier.com/shipments", "POST", carrierData);
        
        if (response.success) {
            SetFieldValue("CarrierReference", response.reference);
            SetFieldValue("CarrierStatus", "Booked");
            ShowMessage("Shipment successfully booked with carrier");
        } else {
            ShowMessage("Carrier booking failed: " + response.error);
        }
    } catch (error) {
        ShowMessage("Integration error: " + error.message);
    }
}

Workflow Extensions

Workflow Design Patterns

1. Sequential Workflow

Linear process flow with defined steps
Each step must complete before next begins
Suitable for standard business processes

2. Parallel Workflow

Multiple processes run simultaneously
Steps can execute in parallel
Suitable for independent operations

3. Conditional Workflow

Process flow depends on conditions
Different paths based on data or user input
Suitable for complex business logic

4. Event-Driven Workflow

Process triggered by specific events
Reactive to system or user events
Suitable for automation and notifications

Workflow Implementation

CargoWise Workflow Example (Shipment Processing):

// Workflow: Automated shipment processing
function processShipmentWorkflow() {
    var workflow = new Workflow("ShipmentProcessing");
    
    // Step 1: Validate shipment data
    workflow.addStep("ValidateData", function() {
        var isValid = validateShipmentData();
        if (!isValid) {
            workflow.setStatus("Failed", "Validation failed");
            return false;
        }
        return true;
    });
    
    // Step 2: Calculate charges
    workflow.addStep("CalculateCharges", function() {
        calculateFreightCharges();
        calculateAdditionalCharges();
        return true;
    });
    
    // Step 3: Generate documents
    workflow.addStep("GenerateDocuments", function() {
        generateAirWaybill();
        generateCommercialInvoice();
        generatePackingList();
        return true;
    });
    
    // Step 4: Notify stakeholders
    workflow.addStep("NotifyStakeholders", function() {
        notifyCustomer();
        notifyCarrier();
        notifyCustoms();
        return true;
    });
    
    // Execute workflow
    workflow.execute();
}

CargoWise Workflow Example (Customs Clearance):

// Workflow: Automated customs clearance
function customsClearanceWorkflow() {
    var workflow = new Workflow("CustomsClearance");
    
    // Step 1: Prepare customs documents
    workflow.addStep("PrepareDocuments", function() {
        var country = GetFieldValue("DestinationCountry");
        var mode = GetFieldValue("Mode");
        
        if (country == "US" && mode == "Air") {
            generateACEForm();
            generateCommercialInvoice();
            generatePackingList();
        } else if (country == "EU" && mode == "Ocean") {
            generateENSForm();
            generateCommercialInvoice();
            generatePackingList();
        }
        
        return true;
    });
    
    // Step 2: Submit to customs
    workflow.addStep("SubmitToCustoms", function() {
        var country = GetFieldValue("DestinationCountry");
        
        if (country == "US") {
            submitToACE();
        } else if (country == "EU") {
            submitToENS();
        }
        
        return true;
    });
    
    // Step 3: Monitor clearance status
    workflow.addStep("MonitorClearance", function() {
        var status = checkCustomsStatus();
        SetFieldValue("CustomsStatus", status);
        
        if (status == "Cleared") {
            workflow.setStatus("Completed", "Customs clearance completed");
            return true;
        } else if (status == "Rejected") {
            workflow.setStatus("Failed", "Customs clearance rejected");
            return false;
        } else {
            // Continue monitoring
            workflow.scheduleRetry(300000); // Retry in 5 minutes
            return false;
        }
    });
    
    // Execute workflow
    workflow.execute();
}

Business Rules Development

Business Rule Types

1. Validation Rules

Ensure data integrity and business logic compliance
Prevent invalid data entry
Enforce business constraints

2. Calculation Rules

Automatically calculate derived values
Apply business formulas and algorithms
Maintain data consistency

3. Workflow Rules

Control process flow and decision making
Automate business processes
Enforce business policies

4. Integration Rules

Manage data exchange with external systems
Transform data between systems
Handle integration errors and exceptions

Business Rule Implementation

CargoWise Business Rule Example (Validation):

// Business rule: Validate shipment data
function validateShipmentData() {
    var errors = [];
    
    // Validate required fields
    if (!GetFieldValue("ShipmentId")) {
        errors.push("Shipment ID is required");
    }
    
    if (!GetFieldValue("Origin")) {
        errors.push("Origin is required");
    }
    
    if (!GetFieldValue("Destination")) {
        errors.push("Destination is required");
    }
    
    // Validate weight and volume
    var weight = parseFloat(GetFieldValue("Weight"));
    var volume = parseFloat(GetFieldValue("Volume"));
    
    if (weight <= 0) {
        errors.push("Weight must be greater than zero");
    }
    
    if (volume <= 0) {
        errors.push("Volume must be greater than zero");
    }
    
    // Validate mode-specific rules
    var mode = GetFieldValue("Mode");
    if (mode == "Air") {
        if (weight > 1000) {
            errors.push("Air freight weight cannot exceed 1000 kg");
        }
        if (volume > 10) {
            errors.push("Air freight volume cannot exceed 10 cubic meters");
        }
    } else if (mode == "Ocean") {
        if (weight > 50000) {
            errors.push("Ocean freight weight cannot exceed 50000 kg");
        }
        if (volume > 1000) {
            errors.push("Ocean freight volume cannot exceed 1000 cubic meters");
        }
    }
    
    // Display errors if any
    if (errors.length > 0) {
        ShowMessage("Validation errors:\n" + errors.join("\n"));
        return false;
    }
    
    return true;
}

CargoWise Business Rule Example (Calculation):

// Business rule: Calculate freight charges
function calculateFreightCharges() {
    var weight = parseFloat(GetFieldValue("Weight"));
    var volume = parseFloat(GetFieldValue("Volume"));
    var mode = GetFieldValue("Mode");
    var rate = parseFloat(GetFieldValue("RatePerKg"));
    
    var totalCharges = 0;
    var chargeableWeight = 0;
    
    if (mode == "Air") {
        // Air freight: chargeable weight is greater of actual weight or volume weight
        var volumeWeight = volume * 167; // 167 kg per cubic meter
        chargeableWeight = Math.max(weight, volumeWeight);
        totalCharges = chargeableWeight * rate;
    } else if (mode == "Ocean") {
        // Ocean freight: chargeable weight is greater of actual weight or volume weight
        var volumeWeight = volume * 1000; // 1000 kg per cubic meter
        chargeableWeight = Math.max(weight, volumeWeight);
        totalCharges = chargeableWeight * rate;
    } else if (mode == "Road") {
        // Road freight: chargeable weight is actual weight
        chargeableWeight = weight;
        totalCharges = chargeableWeight * rate;
    }
    
    // Apply discounts based on volume
    if (chargeableWeight > 1000) {
        totalCharges *= 0.95; // 5% discount for large shipments
    } else if (chargeableWeight > 500) {
        totalCharges *= 0.98; // 2% discount for medium shipments
    }
    
    // Apply surcharges based on destination
    var destination = GetFieldValue("Destination");
    if (destination == "Remote Area") {
        totalCharges *= 1.1; // 10% surcharge for remote areas
    }
    
    SetFieldValue("ChargeableWeight", chargeableWeight.toFixed(2));
    SetFieldValue("TotalCharges", totalCharges.toFixed(2));
}

Automation Patterns

Automation Design Principles

1. Event-Driven Automation

Trigger actions based on system events
Reactive to data changes and user actions
Suitable for real-time automation

2. Scheduled Automation

Execute tasks at specific times or intervals
Batch processing and maintenance tasks
Suitable for routine operations

3. Conditional Automation

Execute actions based on specific conditions
Business logic and decision making
Suitable for complex workflows

4. Integration Automation

Automate data exchange with external systems
Real-time synchronization and updates
Suitable for system integration

Automation Implementation

CargoWise Automation Example (Event-Driven):

// Automation: Auto-generate documents when shipment is confirmed
function autoGenerateDocuments() {
    var status = GetFieldValue("Status");
    
    if (status == "Confirmed") {
        // Generate air waybill
        generateAirWaybill();
        
        // Generate commercial invoice
        generateCommercialInvoice();
        
        // Generate packing list
        generatePackingList();
        
        // Generate customs documents
        var destination = GetFieldValue("DestinationCountry");
        if (destination == "US") {
            generateACEForm();
        } else if (destination == "EU") {
            generateENSForm();
        }
        
        // Update status
        SetFieldValue("DocumentStatus", "Generated");
        
        // Log activity
        logActivity("Documents auto-generated for shipment " + GetFieldValue("ShipmentId"));
    }
}

CargoWise Automation Example (Scheduled):

// Automation: Daily shipment status update
function dailyShipmentStatusUpdate() {
    var today = new Date();
    var yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000);
    
    // Get shipments from yesterday
    var shipments = getShipmentsByDate(yesterday);
    
    for (var i = 0; i < shipments.length; i++) {
        var shipment = shipments[i];
        
        // Check carrier status
        var carrierStatus = checkCarrierStatus(shipment.CarrierReference);
        
        if (carrierStatus != shipment.CarrierStatus) {
            // Update status
            updateShipmentStatus(shipment.ShipmentId, carrierStatus);
            
            // Notify customer
            notifyCustomer(shipment.CustomerId, shipment.ShipmentId, carrierStatus);
            
            // Log activity
            logActivity("Status updated for shipment " + shipment.ShipmentId + " to " + carrierStatus);
        }
    }
}

CargoWise Automation Example (Conditional):

// Automation: Auto-approve low-value shipments
function autoApproveLowValueShipments() {
    var value = parseFloat(GetFieldValue("Value"));
    var currency = GetFieldValue("Currency");
    var destination = GetFieldValue("DestinationCountry");
    
    // Convert to USD for comparison
    var valueUSD = convertToUSD(value, currency);
    
    // Auto-approve if value is below threshold
    if (valueUSD < 1000) {
        SetFieldValue("ApprovalStatus", "Auto-Approved");
        SetFieldValue("ApprovedBy", "System");
        SetFieldValue("ApprovedDate", new Date());
        
        // Log activity
        logActivity("Shipment " + GetFieldValue("ShipmentId") + " auto-approved due to low value");
        
        // Notify approver
        notifyApprover("Shipment auto-approved: " + GetFieldValue("ShipmentId"));
    } else {
        // Send for manual approval
        SetFieldValue("ApprovalStatus", "Pending");
        SetFieldValue("ApprovalRequired", true);
        
        // Notify approver
        notifyApprover("Shipment requires approval: " + GetFieldValue("ShipmentId"));
    }
}

Integration Extensions

External System Integration

CargoWise Integration Example (Carrier API):

// Integration: Carrier booking system
function integrateWithCarrier() {
    var carrier = GetFieldValue("Carrier");
    var mode = GetFieldValue("Mode");
    
    try {
        // Prepare booking data
        var bookingData = {
            shipmentId: GetFieldValue("ShipmentId"),
            carrier: carrier,
            mode: mode,
            weight: GetFieldValue("Weight"),
            volume: GetFieldValue("Volume"),
            origin: GetFieldValue("Origin"),
            destination: GetFieldValue("Destination"),
            pickupDate: GetFieldValue("PickupDate"),
            deliveryDate: GetFieldValue("DeliveryDate")
        };
        
        // Call carrier API
        var response = callCarrierAPI(carrier, "book", bookingData);
        
        if (response.success) {
            // Update shipment with carrier reference
            SetFieldValue("CarrierReference", response.reference);
            SetFieldValue("CarrierStatus", "Booked");
            SetFieldValue("CarrierRate", response.rate);
            
            // Generate carrier documents
            generateCarrierDocuments(response.documents);
            
            // Log activity
            logActivity("Shipment booked with carrier " + carrier + " - Reference: " + response.reference);
        } else {
            // Handle booking failure
            SetFieldValue("CarrierStatus", "Booking Failed");
            SetFieldValue("CarrierError", response.error);
            
            // Notify user
            ShowMessage("Carrier booking failed: " + response.error);
        }
    } catch (error) {
        // Handle integration error
        SetFieldValue("CarrierStatus", "Integration Error");
        SetFieldValue("CarrierError", error.message);
        
        // Log error
        logError("Carrier integration error: " + error.message);
    }
}

CargoWise Integration Example (Customs System):

// Integration: Customs clearance system
function integrateWithCustoms() {
    var destination = GetFieldValue("DestinationCountry");
    var mode = GetFieldValue("Mode");
    
    try {
        // Prepare customs data
        var customsData = {
            shipmentId: GetFieldValue("ShipmentId"),
            destination: destination,
            mode: mode,
            shipper: GetFieldValue("Shipper"),
            consignee: GetFieldValue("Consignee"),
            goods: GetFieldValue("GoodsDescription"),
            value: GetFieldValue("Value"),
            currency: GetFieldValue("Currency"),
            weight: GetFieldValue("Weight"),
            volume: GetFieldValue("Volume")
        };
        
        // Call customs API
        var response = callCustomsAPI(destination, "submit", customsData);
        
        if (response.success) {
            // Update shipment with customs reference
            SetFieldValue("CustomsReference", response.reference);
            SetFieldValue("CustomsStatus", "Submitted");
            SetFieldValue("CustomsSubmissionDate", new Date());
            
            // Log activity
            logActivity("Customs submission successful - Reference: " + response.reference);
        } else {
            // Handle submission failure
            SetFieldValue("CustomsStatus", "Submission Failed");
            SetFieldValue("CustomsError", response.error);
            
            // Notify user
            ShowMessage("Customs submission failed: " + response.error);
        }
    } catch (error) {
        // Handle integration error
        SetFieldValue("CustomsStatus", "Integration Error");
        SetFieldValue("CustomsError", error.message);
        
        // Log error
        logError("Customs integration error: " + error.message);
    }
}

Testing and Deployment

Testing Strategies

1. Unit Testing

Test individual scripts and functions
Validate business logic and calculations
Ensure error handling works correctly

2. Integration Testing

Test workflows and automation
Validate external system integrations
Ensure data flow works correctly

3. User Acceptance Testing

Test with real users and data
Validate user experience and functionality
Ensure business requirements are met

4. Performance Testing

Test with large data volumes
Validate system performance and scalability
Ensure response times are acceptable

Deployment Best Practices

1. Development Environment

Use separate development environment
Test all changes before production
Maintain version control and change tracking

2. Staging Environment

Use staging environment for final testing
Test with production-like data
Validate all integrations and workflows

3. Production Deployment

Deploy during maintenance windows
Monitor system performance and errors
Have rollback plan ready

4. Post-Deployment

Monitor system performance and errors
Validate all functionality works correctly
Provide user training and support

Conclusion

CargoWise custom development provides powerful tools for extending and automating freight forwarding operations. By following the patterns and best practices outlined in this guide, you can create robust, scalable solutions that address specific business requirements and improve operational efficiency.

Key Takeaways:

Start Simple: Begin with basic scripts and gradually add complexity
Test Thoroughly: Implement comprehensive testing at all levels
Document Everything: Maintain clear documentation for all customizations
Monitor Performance: Implement proper logging and monitoring
Plan for Maintenance: Design solutions that are easy to maintain and update

Next Steps:

Identify Requirements and prioritize development needs
Start with Basic Scripts for field validation and calculations
Implement Workflows for process automation
Add Integrations for external system connectivity
Test and Deploy with proper monitoring and support

For more CargoWise custom development guidance and implementation support, explore our CargoWise Integration Services or contact our team for personalized consulting.

FAQ

Q: What programming languages can I use for CargoWise custom development? A: CargoWise primarily uses JavaScript for scripting, but also supports C# for more complex integrations and custom forms. The choice depends on your specific requirements and complexity.

Q: How do I test CargoWise customizations before deploying to production? A: Use CargoWise's development and staging environments, implement comprehensive unit and integration tests, and test with real data to ensure your customizations work correctly.

Q: Can I integrate CargoWise with external systems using custom development? A: Yes, CargoWise provides robust integration capabilities through custom scripts, APIs, and workflow extensions that can connect with external systems and services.

Q: What are the performance considerations for CargoWise custom development? A: Consider script execution time, database queries, external API calls, and system resources. Implement proper error handling, logging, and monitoring to ensure optimal performance.

Q: How do I maintain and update CargoWise customizations? A: Use version control, maintain clear documentation, implement proper testing, and plan for regular updates and maintenance. Consider the impact of CargoWise updates on your customizations.