Shipments Service

import { createShipmentService } from '@/services/shipments/shipments.service';
import { httpClient } from '@/services/http.service';

const shipmentsService = createShipmentService(httpClient);

shipmentsService.list(query: Query): ApiResponse<GetShipmentsResponse>

import { shipmentsService } from '@/services';

try {
  const response = await shipmentsService.list({
    page: 1,
    limit: 20,
    status: 'in_transit',
  });

  console.log(`Total shipments: ${response.data.meta.totalItems}`);
  console.log(`Current page: ${response.data.meta.currentPage}`);
  response.data.items.forEach(shipment => {
    console.log(`${shipment.reference}: ${shipment.status}`);
  });
} catch (error) {
  console.error('Failed to fetch shipments:', error.message);
}

shipmentsService.getRiderLatestOrders(riderId: string): ApiResponse<GetShipmentsResponse>

try {
  const response = await shipmentsService.getRiderLatestOrders('rider-123');
  
  console.log(`Latest orders for rider: ${response.data.items.length}`);
  response.data.items.forEach(order => {
    console.log(`${order.reference}: ${order.dropOffCity}`);
  });
} catch (error) {
  console.error('Failed to fetch rider orders:', error.message);
}

shipmentsService.getByReference(reference: string): ApiResponse<Shipment>

try {
  const response = await shipmentsService.getByReference('SHIP-2024-0001');
  const shipment = response.data;
  
  console.log(`Shipment: ${shipment.reference}`);
  console.log(`Status: ${shipment.status}`);
  console.log(`From: ${shipment.pickupCity}, ${shipment.pickupArea}`);
  console.log(`To: ${shipment.dropOffCity}, ${shipment.dropOffArea}`);
  
  if (shipment.rider) {
    console.log(`Rider: ${shipment.rider.fullName}`);
  }
  
  if (shipment.shipmentCost) {
    console.log(`Total Cost: ${shipment.shipmentCost.totalCost}`);
    console.log(`Rider Commission: ${shipment.shipmentCost.riderCommission}`);
  }
} catch (error) {
  if (error.status === 404) {
    console.error('Shipment not found');
  } else {
    console.error('Failed to fetch shipment:', error.message);
  }
}

shipmentsService.updateStatus(
  shipmentId: string, 
  data: FormData
): ApiResponse<Shipment>

import * as ImagePicker from 'expo-image-picker';

try {
  // Create FormData for status update
  const formData = new FormData();
  formData.append('status', 'delivered');
  formData.append('description', 'Package delivered successfully');
  
  // Add proof of delivery image
  const imageResult = await ImagePicker.launchCameraAsync({
    mediaTypes: ImagePicker.MediaTypeOptions.Images,
    quality: 0.8,
  });
  
  if (!imageResult.canceled) {
    formData.append('image', {
      uri: imageResult.assets[0].uri,
      type: 'image/jpeg',
      name: 'proof_of_delivery.jpg',
    } as any);
  }
  
  const response = await shipmentsService.updateStatus(
    'shipment-123',
    formData
  );
  
  console.log('Status updated:', response.data.status);
  console.log('History entries:', response.data.history.length);
} catch (error) {
  console.error('Failed to update status:', error.message);
}

interface Shipment {
  id: string;
  createdAt: string;
  updatedAt: string;
  deletedAt: any;
  pickupCity: string;
  pickupArea: string;
  senderPhone: string;
  pickupDate: any;
  dropOffCity: string;
  dropOffArea: string;
  recipientPhone: string;
  dropOffDate: any;
  extraInformation: string | null;
  shipmentOption: string;
  modeOfShipment: string;
  status: string;
  reference: string;
  rider: Rider | null;
  history: ShipmentHistory[];
  shipmentCost: ShipmentCost | null;
}

interface ShipmentHistory {
  id: string;
  createdAt: string;
  updatedAt: string;
  deletedAt: any;
  status: string;
  description: any;
  data: Record<string, any>;
}

interface ShipmentCost {
  id: string;
  createdAt: string;
  updatedAt: string;
  deletedAt: any;
  pickupFee: number;
  deliveryFee: number;
  riderCommission: number;
  repackagingFee: number;
  paid: boolean;
  includeRepackagingFee: boolean;
  paidAt: string;
  totalCost: number;
}

interface GetShipmentsResponse {
  meta: PaginationMeta;
  items: Shipment[];
}

const fetchActiveDeliveries = async (riderId: string) => {
  try {
    const response = await shipmentsService.list({
      riderId,
      status: 'in_transit',
      limit: 50,
    });
    
    return response.data.items;
  } catch (error) {
    console.error('Error fetching active deliveries:', error);
    return [];
  }
};

const trackShipment = async (reference: string) => {
  try {
    const response = await shipmentsService.getByReference(reference);
    const shipment = response.data;
    
    return {
      status: shipment.status,
      currentLocation: shipment.rider ? 'En route' : 'Au dépôt',
      history: shipment.history.map(h => ({
        status: h.status,
        timestamp: h.createdAt,
        description: h.description,
      })),
    };
  } catch (error) {
    throw new Error('Unable to track shipment');
  }
};

const completeDelivery = async (
  shipmentId: string,
  proofImageUri: string,
  signature: string
) => {
  const formData = new FormData();
  formData.append('status', 'delivered');
  formData.append('description', 'Colis livré avec succès');
  
  // Add proof image
  formData.append('image', {
    uri: proofImageUri,
    type: 'image/jpeg',
    name: `delivery_${shipmentId}.jpg`,
  } as any);
  
  // Add signature
  formData.append('signature', signature);
  
  try {
    const response = await shipmentsService.updateStatus(shipmentId, formData);
    return response.data;
  } catch (error) {
    throw new Error('Failed to complete delivery');
  }
};

{
  "message": "Ressource non trouvée",
  "status": 404,
  "isApiError": true
}

{
  "message": "Erreur de validation",
  "status": 422,
  "data": {
    "message": "Invalid status transition",
    "errors": ["Cannot transition from delivered to in_transit"]
  },
  "isApiError": true
}