Back to Blog

Invalid Date•
0

kd--- title: "CargoWise for Air Freight Forwarders: Workflows & Automation (2025 Guide)" description: "Master CargoWise air freight workflows with our comprehensive guide. Learn AWB processing, MAWB/HAWB handling, carrier integrations, and automation for air freight operations." date: "2025-01-19" author: "Elysiate" tags: ["cargowise", "air-freight", "workflows", "automation", "awb", "mawb", "hawb", "carrier-integration"] schema: type: "Article" headline: "CargoWise for Air Freight Forwarders: Workflows & Automation (2025 Guide)" description: "Complete guide to CargoWise air freight workflows covering AWB processing, MAWB/HAWB handling, carrier integrations, and automation for air freight forwarding operations." author: name: "Elysiate" url: "https://www.elysiate.com" publisher: name: "Elysiate" url: "https://www.elysiate.com" datePublished: "2025-01-19" dateModified: "2025-01-19"

Air freight forwarding is one of the most complex and time-sensitive segments of the logistics industry, requiring precise coordination, real-time tracking, and seamless integration with multiple stakeholders. CargoWise provides powerful tools and workflows specifically designed for air freight operations, enabling forwarders to manage the entire air cargo lifecycle efficiently.

This comprehensive guide covers everything you need to know about CargoWise air freight workflows, from AWB processing and MAWB/HAWB handling to carrier integrations and automation. Whether you're managing a small air freight operation or a large-scale international forwarding business, this guide will help you optimize your air cargo processes.

Understanding Air Freight in CargoWise

Air Freight Workflow Overview

Core Air Freight Processes:

  • Booking Management: Carrier reservations and capacity allocation
  • AWB Processing: Air Waybill creation and management
  • Consolidation: MAWB/HAWB handling and groupage operations
  • Documentation: Customs and regulatory compliance
  • Tracking: Real-time shipment monitoring and updates
  • Delivery: Final mile coordination and proof of delivery

Key Air Freight Stakeholders:

  • Airlines: Capacity providers and transportation partners
  • Ground Handlers: Airport operations and cargo handling
  • Customs Brokers: Regulatory compliance and clearance
  • Consignees: End customers and delivery recipients
  • Shippers: Cargo owners and origin customers

Air Freight Data Model

CargoWise Air Freight Entities:

AirShipment (1) -----> (N) AirWaybill
    |                      |
    |                      |
    v                      v
Consolidation (1) -----> (N) HouseAWB
    |                      |
    |                      |
    v                      v
CarrierBooking (1) -----> (N) FlightSegment
    |                      |
    |                      |
    v                      v
CustomsDeclaration (1) --> (N) CustomsItem

AWB Processing and Management

Air Waybill Creation

C# AWB Processing Service:

public class CargoWiseAWBProcessor
{
    private readonly ILogger<CargoWiseAWBProcessor> _logger;
    private readonly IAWBRepository _awbRepository;
    private readonly ICarrierService _carrierService;
    private readonly IDocumentService _documentService;
    
    public CargoWiseAWBProcessor(
        ILogger<CargoWiseAWBProcessor> logger,
        IAWBRepository awbRepository,
        ICarrierService carrierService,
        IDocumentService documentService)
    {
        _logger = logger;
        _awbRepository = awbRepository;
        _carrierService = carrierService;
        _documentService = documentService;
    }
    
    public async Task<AWBResult> CreateAWB(CreateAWBRequest request)
    {
        var result = new AWBResult
        {
            StartTime = DateTime.UtcNow,
            Status = AWBStatus.InProgress
        };
        
        try
        {
            _logger.LogInformation("Creating AWB for shipment: {ShipmentId}", request.ShipmentId);
            
            // Validate AWB data
            var validationResult = await ValidateAWBData(request);
            if (!validationResult.IsValid)
            {
                result.Status = AWBStatus.ValidationFailed;
                result.ErrorMessage = validationResult.ErrorMessage;
                return result;
            }
            
            // Generate AWB number
            var awbNumber = await GenerateAWBNumber(request.Carrier);
            
            // Create AWB record
            var awb = new AirWaybill
            {
                Id = Guid.NewGuid().ToString(),
                AWBNumber = awbNumber,
                ShipmentId = request.ShipmentId,
                Carrier = request.Carrier,
                Origin = request.Origin,
                Destination = request.Destination,
                FlightNumber = request.FlightNumber,
                FlightDate = request.FlightDate,
                Shipper = request.Shipper,
                Consignee = request.Consignee,
                GoodsDescription = request.GoodsDescription,
                Weight = request.Weight,
                Volume = request.Volume,
                Pieces = request.Pieces,
                Value = request.Value,
                Currency = request.Currency,
                SpecialHandling = request.SpecialHandling,
                Status = AWBStatus.Created,
                CreatedAt = DateTime.UtcNow,
                UpdatedAt = DateTime.UtcNow
            };
            
            // Save AWB
            await _awbRepository.CreateAsync(awb);
            
            // Generate AWB document
            var documentResult = await _documentService.GenerateAWBDocument(awb);
            if (documentResult.IsSuccess)
            {
                awb.DocumentId = documentResult.DocumentId;
                await _awbRepository.UpdateAsync(awb);
            }
            
            result.Status = AWBStatus.Created;
            result.AWB = awb;
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            _logger.LogInformation("AWB created successfully: {AWBNumber} for shipment: {ShipmentId}", 
                awbNumber, request.ShipmentId);
            
            return result;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating AWB for shipment: {ShipmentId}", request.ShipmentId);
            
            result.Status = AWBStatus.Failed;
            result.ErrorMessage = ex.Message;
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            return result;
        }
    }
    
    private async Task<AWBValidationResult> ValidateAWBData(CreateAWBRequest request)
    {
        var result = new AWBValidationResult { IsValid = true };
        
        // Validate required fields
        if (string.IsNullOrEmpty(request.Carrier))
        {
            result.IsValid = false;
            result.ErrorMessage = "Carrier is required";
            return result;
        }
        
        if (string.IsNullOrEmpty(request.Origin))
        {
            result.IsValid = false;
            result.ErrorMessage = "Origin is required";
            return result;
        }
        
        if (string.IsNullOrEmpty(request.Destination))
        {
            result.IsValid = false;
            result.ErrorMessage = "Destination is required";
            return result;
        }
        
        if (request.Weight <= 0)
        {
            result.IsValid = false;
            result.ErrorMessage = "Weight must be greater than zero";
            return result;
        }
        
        if (request.Pieces <= 0)
        {
            result.IsValid = false;
            result.ErrorMessage = "Pieces must be greater than zero";
            return result;
        }
        
        // Validate carrier
        var carrierValidation = await _carrierService.ValidateCarrier(request.Carrier);
        if (!carrierValidation.IsValid)
        {
            result.IsValid = false;
            result.ErrorMessage = $"Invalid carrier: {carrierValidation.ErrorMessage}";
            return result;
        }
        
        // Validate route
        var routeValidation = await ValidateRoute(request.Origin, request.Destination);
        if (!routeValidation.IsValid)
        {
            result.IsValid = false;
            result.ErrorMessage = $"Invalid route: {routeValidation.ErrorMessage}";
            return result;
        }
        
        return result;
    }
    
    private async Task<string> GenerateAWBNumber(string carrier)
    {
        // Get carrier prefix
        var carrierPrefix = await _carrierService.GetCarrierPrefix(carrier);
        
        // Generate sequential number
        var sequenceNumber = await _awbRepository.GetNextSequenceNumber(carrier);
        
        // Format AWB number (e.g., 123-45678901)
        return $"{carrierPrefix}-{sequenceNumber:D8}";
    }
}

AWB Status Management

C# AWB Status Tracker:

public class CargoWiseAWBStatusTracker
{
    private readonly ILogger<CargoWiseAWBStatusTracker> _logger;
    private readonly IAWBRepository _awbRepository;
    private readonly ICarrierService _carrierService;
    private readonly INotificationService _notificationService;
    
    public CargoWiseAWBStatusTracker(
        ILogger<CargoWiseAWBStatusTracker> logger,
        IAWBRepository awbRepository,
        ICarrierService carrierService,
        INotificationService notificationService)
    {
        _logger = logger;
        _awbRepository = awbRepository;
        _carrierService = carrierService;
        _notificationService = notificationService;
    }
    
    public async Task<AWBStatusUpdateResult> UpdateAWBStatus(string awbNumber, AWBStatus newStatus, string statusReason = null)
    {
        var result = new AWBStatusUpdateResult
        {
            AWBNumber = awbNumber,
            StartTime = DateTime.UtcNow,
            Status = AWBStatusUpdateStatus.InProgress
        };
        
        try
        {
            _logger.LogInformation("Updating AWB status: {AWBNumber} to {NewStatus}", awbNumber, newStatus);
            
            // Get AWB record
            var awb = await _awbRepository.GetByAWBNumberAsync(awbNumber);
            if (awb == null)
            {
                result.Status = AWBStatusUpdateStatus.AWBNotFound;
                result.ErrorMessage = "AWB not found";
                return result;
            }
            
            // Validate status transition
            var transitionValidation = await ValidateStatusTransition(awb.Status, newStatus);
            if (!transitionValidation.IsValid)
            {
                result.Status = AWBStatusUpdateStatus.InvalidTransition;
                result.ErrorMessage = transitionValidation.ErrorMessage;
                return result;
            }
            
            // Update AWB status
            var previousStatus = awb.Status;
            awb.Status = newStatus;
            awb.StatusReason = statusReason;
            awb.StatusUpdatedAt = DateTime.UtcNow;
            awb.UpdatedAt = DateTime.UtcNow;
            
            await _awbRepository.UpdateAsync(awb);
            
            // Log status change
            await LogStatusChange(awb, previousStatus, newStatus, statusReason);
            
            // Send notifications
            await SendStatusNotifications(awb, previousStatus, newStatus);
            
            result.Status = AWBStatusUpdateStatus.Completed;
            result.PreviousStatus = previousStatus;
            result.NewStatus = newStatus;
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            _logger.LogInformation("AWB status updated successfully: {AWBNumber} from {PreviousStatus} to {NewStatus}", 
                awbNumber, previousStatus, newStatus);
            
            return result;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error updating AWB status: {AWBNumber}", awbNumber);
            
            result.Status = AWBStatusUpdateStatus.Failed;
            result.ErrorMessage = ex.Message;
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            return result;
        }
    }
    
    private async Task<StatusTransitionValidationResult> ValidateStatusTransition(AWBStatus currentStatus, AWBStatus newStatus)
    {
        var result = new StatusTransitionValidationResult { IsValid = true };
        
        // Define valid status transitions
        var validTransitions = new Dictionary<AWBStatus, List<AWBStatus>>
        {
            { AWBStatus.Created, new List<AWBStatus> { AWBStatus.Booked, AWBStatus.Cancelled } },
            { AWBStatus.Booked, new List<AWBStatus> { AWBStatus.Accepted, AWBStatus.Cancelled } },
            { AWBStatus.Accepted, new List<AWBStatus> { AWBStatus.InTransit, AWBStatus.Cancelled } },
            { AWBStatus.InTransit, new List<AWBStatus> { AWBStatus.Delivered, AWBStatus.Exception } },
            { AWBStatus.Delivered, new List<AWBStatus>() }, // Final status
            { AWBStatus.Cancelled, new List<AWBStatus>() }, // Final status
            { AWBStatus.Exception, new List<AWBStatus> { AWBStatus.InTransit, AWBStatus.Cancelled } }
        };
        
        if (validTransitions.ContainsKey(currentStatus))
        {
            if (!validTransitions[currentStatus].Contains(newStatus))
            {
                result.IsValid = false;
                result.ErrorMessage = $"Invalid status transition from {currentStatus} to {newStatus}";
            }
        }
        else
        {
            result.IsValid = false;
            result.ErrorMessage = $"Unknown current status: {currentStatus}";
        }
        
        return result;
    }
}

MAWB/HAWB Consolidation

Consolidation Management

C# Consolidation Service:

public class CargoWiseConsolidationService
{
    private readonly ILogger<CargoWiseConsolidationService> _logger;
    private readonly IConsolidationRepository _consolidationRepository;
    private readonly IAWBRepository _awbRepository;
    private readonly ICarrierService _carrierService;
    
    public CargoWiseConsolidationService(
        ILogger<CargoWiseConsolidationService> logger,
        IConsolidationRepository consolidationRepository,
        IAWBRepository awbRepository,
        ICarrierService carrierService)
    {
        _logger = logger;
        _consolidationRepository = consolidationRepository;
        _awbRepository = awbRepository;
        _carrierService = carrierService;
    }
    
    public async Task<ConsolidationResult> CreateConsolidation(CreateConsolidationRequest request)
    {
        var result = new ConsolidationResult
        {
            StartTime = DateTime.UtcNow,
            Status = ConsolidationStatus.InProgress
        };
        
        try
        {
            _logger.LogInformation("Creating consolidation: {ConsolidationId}", request.ConsolidationId);
            
            // Validate consolidation data
            var validationResult = await ValidateConsolidationData(request);
            if (!validationResult.IsValid)
            {
                result.Status = ConsolidationStatus.ValidationFailed;
                result.ErrorMessage = validationResult.ErrorMessage;
                return result;
            }
            
            // Create MAWB
            var mawb = await CreateMAWB(request);
            
            // Create consolidation record
            var consolidation = new Consolidation
            {
                Id = request.ConsolidationId,
                MAWBNumber = mawb.AWBNumber,
                Carrier = request.Carrier,
                Origin = request.Origin,
                Destination = request.Destination,
                FlightNumber = request.FlightNumber,
                FlightDate = request.FlightDate,
                Consolidator = request.Consolidator,
                Status = ConsolidationStatus.Created,
                CreatedAt = DateTime.UtcNow,
                UpdatedAt = DateTime.UtcNow
            };
            
            // Add HAWBs to consolidation
            foreach (var hawbRequest in request.HAWBs)
            {
                var hawb = await CreateHAWB(hawbRequest, consolidation);
                consolidation.HAWBs.Add(hawb);
            }
            
            // Save consolidation
            await _consolidationRepository.CreateAsync(consolidation);
            
            result.Status = ConsolidationStatus.Created;
            result.Consolidation = consolidation;
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            _logger.LogInformation("Consolidation created successfully: {ConsolidationId} with {HAWBCount} HAWBs", 
                request.ConsolidationId, consolidation.HAWBs.Count);
            
            return result;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating consolidation: {ConsolidationId}", request.ConsolidationId);
            
            result.Status = ConsolidationStatus.Failed;
            result.ErrorMessage = ex.Message;
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            return result;
        }
    }
    
    private async Task<AirWaybill> CreateMAWB(CreateConsolidationRequest request)
    {
        var mawbRequest = new CreateAWBRequest
        {
            ShipmentId = request.ConsolidationId,
            Carrier = request.Carrier,
            Origin = request.Origin,
            Destination = request.Destination,
            FlightNumber = request.FlightNumber,
            FlightDate = request.FlightDate,
            Shipper = request.Consolidator,
            Consignee = request.Consignee,
            GoodsDescription = "CONSOLIDATED CARGO",
            Weight = request.HAWBs.Sum(h => h.Weight),
            Volume = request.HAWBs.Sum(h => h.Volume),
            Pieces = request.HAWBs.Sum(h => h.Pieces),
            Value = request.HAWBs.Sum(h => h.Value),
            Currency = request.Currency,
            SpecialHandling = "CONSOLIDATION"
        };
        
        var mawbResult = await CreateAWB(mawbRequest);
        if (mawbResult.Status != AWBStatus.Created)
        {
            throw new Exception($"Failed to create MAWB: {mawbResult.ErrorMessage}");
        }
        
        return mawbResult.AWB;
    }
    
    private async Task<HouseAWB> CreateHAWB(CreateHAWBRequest request, Consolidation consolidation)
    {
        var hawb = new HouseAWB
        {
            Id = Guid.NewGuid().ToString(),
            HAWBNumber = await GenerateHAWBNumber(consolidation.Carrier),
            ConsolidationId = consolidation.Id,
            ShipmentId = request.ShipmentId,
            Shipper = request.Shipper,
            Consignee = request.Consignee,
            GoodsDescription = request.GoodsDescription,
            Weight = request.Weight,
            Volume = request.Volume,
            Pieces = request.Pieces,
            Value = request.Value,
            Currency = request.Currency,
            SpecialHandling = request.SpecialHandling,
            Status = HAWBStatus.Created,
            CreatedAt = DateTime.UtcNow,
            UpdatedAt = DateTime.UtcNow
        };
        
        return hawb;
    }
}

Consolidation Workflow Automation

C# Consolidation Workflow:

public class CargoWiseConsolidationWorkflow
{
    private readonly ILogger<CargoWiseConsolidationWorkflow> _logger;
    private readonly IConsolidationService _consolidationService;
    private readonly ICarrierService _carrierService;
    private readonly IDocumentService _documentService;
    private readonly INotificationService _notificationService;
    
    public CargoWiseConsolidationWorkflow(
        ILogger<CargoWiseConsolidationWorkflow> logger,
        IConsolidationService consolidationService,
        ICarrierService carrierService,
        IDocumentService documentService,
        INotificationService notificationService)
    {
        _logger = logger;
        _consolidationService = consolidationService;
        _carrierService = carrierService;
        _documentService = documentService;
        _notificationService = notificationService;
    }
    
    public async Task<WorkflowResult> ProcessConsolidationWorkflow(string consolidationId)
    {
        var result = new WorkflowResult
        {
            ConsolidationId = consolidationId,
            StartTime = DateTime.UtcNow,
            Status = WorkflowStatus.InProgress
        };
        
        try
        {
            _logger.LogInformation("Processing consolidation workflow: {ConsolidationId}", consolidationId);
            
            // Step 1: Validate consolidation
            var validationResult = await ValidateConsolidation(consolidationId);
            if (!validationResult.IsValid)
            {
                result.Status = WorkflowStatus.ValidationFailed;
                result.ErrorMessage = validationResult.ErrorMessage;
                return result;
            }
            
            // Step 2: Check carrier capacity
            var capacityResult = await CheckCarrierCapacity(consolidationId);
            if (!capacityResult.HasCapacity)
            {
                result.Status = WorkflowStatus.CapacityUnavailable;
                result.ErrorMessage = "Insufficient carrier capacity";
                return result;
            }
            
            // Step 3: Generate MAWB
            var mawbResult = await GenerateMAWB(consolidationId);
            if (!mawbResult.IsSuccess)
            {
                result.Status = WorkflowStatus.MAWBFailed;
                result.ErrorMessage = mawbResult.ErrorMessage;
                return result;
            }
            
            // Step 4: Generate HAWBs
            var hawbsResult = await GenerateHAWBs(consolidationId);
            if (!hawbsResult.IsSuccess)
            {
                result.Status = WorkflowStatus.HAWBsFailed;
                result.ErrorMessage = hawbsResult.ErrorMessage;
                return result;
            }
            
            // Step 5: Generate consolidation manifest
            var manifestResult = await GenerateConsolidationManifest(consolidationId);
            if (!manifestResult.IsSuccess)
            {
                result.Status = WorkflowStatus.ManifestFailed;
                result.ErrorMessage = manifestResult.ErrorMessage;
                return result;
            }
            
            // Step 6: Submit to carrier
            var carrierResult = await SubmitToCarrier(consolidationId);
            if (!carrierResult.IsSuccess)
            {
                result.Status = WorkflowStatus.CarrierSubmissionFailed;
                result.ErrorMessage = carrierResult.ErrorMessage;
                return result;
            }
            
            // Step 7: Send notifications
            await SendConsolidationNotifications(consolidationId);
            
            result.Status = WorkflowStatus.Completed;
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            _logger.LogInformation("Consolidation workflow completed successfully: {ConsolidationId} in {Duration}", 
                consolidationId, result.Duration);
            
            return result;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing consolidation workflow: {ConsolidationId}", consolidationId);
            
            result.Status = WorkflowStatus.Failed;
            result.ErrorMessage = ex.Message;
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            return result;
        }
    }
}

Carrier Integration

Airline API Integration

C# Airline Integration Service:

public class CargoWiseAirlineIntegrationService
{
    private readonly ILogger<CargoWiseAirlineIntegrationService> _logger;
    private readonly IAirlineApiClient _airlineApiClient;
    private readonly ICarrierRepository _carrierRepository;
    private readonly IEncryptionService _encryptionService;
    
    public CargoWiseAirlineIntegrationService(
        ILogger<CargoWiseAirlineIntegrationService> logger,
        IAirlineApiClient airlineApiClient,
        ICarrierRepository carrierRepository,
        IEncryptionService encryptionService)
    {
        _logger = logger;
        _airlineApiClient = airlineApiClient;
        _carrierRepository = carrierRepository;
        _encryptionService = encryptionService;
    }
    
    public async Task<CarrierIntegrationResult> BookCapacity(BookCapacityRequest request)
    {
        var result = new CarrierIntegrationResult
        {
            StartTime = DateTime.UtcNow,
            Status = CarrierIntegrationStatus.InProgress
        };
        
        try
        {
            _logger.LogInformation("Booking capacity with carrier: {Carrier}", request.Carrier);
            
            // Get carrier configuration
            var carrier = await _carrierRepository.GetByCodeAsync(request.Carrier);
            if (carrier == null)
            {
                result.Status = CarrierIntegrationStatus.CarrierNotFound;
                result.ErrorMessage = "Carrier not found";
                return result;
            }
            
            // Prepare booking request
            var bookingRequest = new AirlineBookingRequest
            {
                Carrier = request.Carrier,
                Origin = request.Origin,
                Destination = request.Destination,
                FlightDate = request.FlightDate,
                Weight = request.Weight,
                Volume = request.Volume,
                Pieces = request.Pieces,
                SpecialHandling = request.SpecialHandling,
                Shipper = request.Shipper,
                Consignee = request.Consignee
            };
            
            // Call airline API
            var bookingResponse = await _airlineApiClient.BookCapacityAsync(bookingRequest);
            
            if (bookingResponse.IsSuccess)
            {
                result.Status = CarrierIntegrationStatus.Completed;
                result.BookingReference = bookingResponse.BookingReference;
                result.FlightNumber = bookingResponse.FlightNumber;
                result.ConfirmedWeight = bookingResponse.ConfirmedWeight;
                result.ConfirmedVolume = bookingResponse.ConfirmedVolume;
            }
            else
            {
                result.Status = CarrierIntegrationStatus.Failed;
                result.ErrorMessage = bookingResponse.ErrorMessage;
            }
            
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            _logger.LogInformation("Capacity booking completed: {Carrier}, Status: {Status}", 
                request.Carrier, result.Status);
            
            return result;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error booking capacity with carrier: {Carrier}", request.Carrier);
            
            result.Status = CarrierIntegrationStatus.Failed;
            result.ErrorMessage = ex.Message;
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            return result;
        }
    }
    
    public async Task<CarrierIntegrationResult> GetFlightStatus(string carrier, string flightNumber, DateTime flightDate)
    {
        var result = new CarrierIntegrationResult
        {
            StartTime = DateTime.UtcNow,
            Status = CarrierIntegrationStatus.InProgress
        };
        
        try
        {
            _logger.LogInformation("Getting flight status: {Carrier} {FlightNumber} {FlightDate}", 
                carrier, flightNumber, flightDate);
            
            // Call airline API
            var statusResponse = await _airlineApiClient.GetFlightStatusAsync(carrier, flightNumber, flightDate);
            
            if (statusResponse.IsSuccess)
            {
                result.Status = CarrierIntegrationStatus.Completed;
                result.FlightStatus = statusResponse.FlightStatus;
                result.DepartureTime = statusResponse.DepartureTime;
                result.ArrivalTime = statusResponse.ArrivalTime;
                result.Gate = statusResponse.Gate;
                result.Terminal = statusResponse.Terminal;
            }
            else
            {
                result.Status = CarrierIntegrationStatus.Failed;
                result.ErrorMessage = statusResponse.ErrorMessage;
            }
            
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            _logger.LogInformation("Flight status retrieved: {Carrier} {FlightNumber}, Status: {FlightStatus}", 
                carrier, flightNumber, result.FlightStatus);
            
            return result;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting flight status: {Carrier} {FlightNumber}", carrier, flightNumber);
            
            result.Status = CarrierIntegrationStatus.Failed;
            result.ErrorMessage = ex.Message;
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
            
            return result;
        }
    }
}

Automation and Workflow Optimization

Automated AWB Processing

C# AWB Automation Service:

public class CargoWiseAWBAutomationService
{
    private readonly ILogger<CargoWiseAWBAutomationService> _logger;
    private readonly IAWBRepository _awbRepository;
    private readonly ICarrierService _carrierService;
    private readonly IDocumentService _documentService;
    private readonly INotificationService _notificationService;
    private readonly Timer _automationTimer;
    
    public CargoWiseAWBAutomationService(
        ILogger<CargoWiseAWBAutomationService> logger,
        IAWBRepository awbRepository,
        ICarrierService carrierService,
        IDocumentService documentService,
        INotificationService notificationService)
    {
        _logger = logger;
        _awbRepository = awbRepository;
        _carrierService = carrierService;
        _documentService = documentService;
        _notificationService = notificationService;
        
        // Set up automation timer (check every 5 minutes)
        _automationTimer = new Timer(ProcessAutomation, null, TimeSpan.Zero, TimeSpan.FromMinutes(5));
    }
    
    private async void ProcessAutomation(object state)
    {
        try
        {
            await ProcessPendingAWBs();
            await ProcessOverdueAWBs();
            await ProcessStatusUpdates();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error in AWB automation processing");
        }
    }
    
    private async Task ProcessPendingAWBs()
    {
        var pendingAWBs = await _awbRepository.GetPendingAWBsAsync();
        
        foreach (var awb in pendingAWBs)
        {
            try
            {
                await ProcessPendingAWB(awb);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing pending AWB: {AWBNumber}", awb.AWBNumber);
            }
        }
    }
    
    private async Task ProcessPendingAWB(AirWaybill awb)
    {
        _logger.LogInformation("Processing pending AWB: {AWBNumber}", awb.AWBNumber);
        
        // Check if AWB is ready for processing
        if (IsAWBReadyForProcessing(awb))
        {
            // Generate AWB document
            var documentResult = await _documentService.GenerateAWBDocument(awb);
            if (documentResult.IsSuccess)
            {
                awb.DocumentId = documentResult.DocumentId;
                awb.Status = AWBStatus.DocumentGenerated;
                await _awbRepository.UpdateAsync(awb);
                
                // Send notification
                await _notificationService.SendAWBReadyNotification(awb);
            }
        }
    }
    
    private async Task ProcessOverdueAWBs()
    {
        var overdueAWBs = await _awbRepository.GetOverdueAWBsAsync();
        
        foreach (var awb in overdueAWBs)
        {
            try
            {
                await ProcessOverdueAWB(awb);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing overdue AWB: {AWBNumber}", awb.AWBNumber);
            }
        }
    }
    
    private async Task ProcessOverdueAWB(AirWaybill awb)
    {
        _logger.LogWarning("Processing overdue AWB: {AWBNumber}", awb.AWBNumber);
        
        // Send overdue notification
        await _notificationService.SendAWBOverdueNotification(awb);
        
        // Update status
        awb.Status = AWBStatus.Overdue;
        awb.StatusReason = "AWB processing overdue";
        await _awbRepository.UpdateAsync(awb);
    }
}

Conclusion

CargoWise air freight workflows provide comprehensive tools for managing complex air cargo operations efficiently. By implementing the workflows and automation strategies outlined in this guide, you can streamline your air freight processes, improve operational efficiency, and enhance customer service.

Key Takeaways:

  1. Streamline AWB Processing: Implement automated AWB creation and management
  2. Optimize Consolidation: Use MAWB/HAWB workflows for efficient groupage operations
  3. Integrate with Carriers: Connect with airline APIs for real-time data exchange
  4. Automate Workflows: Implement automated processes for routine operations
  5. Monitor Performance: Track KPIs and optimize workflows continuously

Next Steps:

  1. Assess Current Processes and identify optimization opportunities
  2. Implement AWB Automation for streamlined document processing
  3. Set up Carrier Integrations for real-time data exchange
  4. Create Consolidation Workflows for efficient groupage operations
  5. Monitor and Optimize performance based on operational metrics

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

FAQ

Q: How do I create and manage AWBs in CargoWise? A: Use the CargoWise AWB Processor to create AWBs with proper validation, generate AWB numbers, and manage status updates. Implement automated workflows for routine AWB processing.

Q: What is the difference between MAWB and HAWB in CargoWise? A: MAWB (Master Air Waybill) is the main document for consolidated cargo, while HAWB (House Air Waybill) represents individual shipments within the consolidation. CargoWise manages both through the consolidation service.

Q: How can I integrate CargoWise with airline APIs? A: Use the CargoWise Airline Integration Service to connect with carrier APIs for capacity booking, flight status updates, and real-time data exchange. Implement proper authentication and error handling.

Q: What automation features are available for air freight in CargoWise? A: CargoWise provides automation for AWB processing, status updates, document generation, notifications, and workflow management. Use the automation service to streamline routine operations.

Q: How do I track air freight shipments in CargoWise? A: Implement real-time tracking through carrier integrations, status updates, and notification systems. Use the AWB Status Tracker to monitor shipment progress and send updates to stakeholders.