@vulog/aima-booking 1.1.89 → 1.1.91

package/README.md

@@ -1,26 +1,308 @@
 # @vulog/aima-booking
 
+Booking management module for the AIMA platform. This module provides functionality to manage booking requests, stations, and subscription bookings.
+
+## Installation
+
 ```bash
-npm i @vulog/aima-client @vulog/aima-core @vulog/aima-booking
+npm install @vulog/aima-client @vulog/aima-core @vulog/aima-booking
+```
+
+## Usage
+
+### Initialize Client
+
+```javascript
+import { getClient } from '@vulog/aima-client';
+import { 
+    getBookingRequests, 
+    getScheduleBookingRequests, 
+    getSubscriptionBookingRequests,
+    getSATBookingRequests,
+    getBookingRequestById,
+    getBookingRequestByTrip,
+    getSubscriptionBookingRequestById,
+    getStations,
+    getStationById
+} from '@vulog/aima-booking';
+
+const client = getClient({
+    apiKey: 'your-api-key',
+    baseUrl: 'https://your-api-base-url',
+    clientId: 'your-client-id',
+    clientSecret: 'your-client-secret',
+    fleetId: 'your-fleet-id',
+});
+```
+
+## API Reference
+
+### Booking Requests
+
+#### getBookingRequests
+
+Retrieve booking requests with optional filtering.
+
+```javascript
+const bookingRequests = await getBookingRequests(client, 'ONGOING', {
+    limit: 50,
+    offset: 0,
+    userId: 'user-uuid-here'
+});
+```
+
+**Parameters:**
+- `client`: AIMA client instance
+- `status`: Booking request status ('ONGOING', 'COMPLETED', 'CANCELLED', 'EXPIRED')
+- `filters`: Optional filter object
+  - `limit`: Maximum number of results
+  - `offset`: Number of results to skip
+  - `userId`: Filter by user ID
+  - `vehicleId`: Filter by vehicle ID
+  - `stationId`: Filter by station ID
+
+#### getScheduleBookingRequests
+
+Get scheduled booking requests.
+
+```javascript
+const scheduledRequests = await getScheduleBookingRequests(client, {
+    startDate: '2024-01-01T00:00:00Z',
+    endDate: '2024-01-31T23:59:59Z'
+});
+```
+
+#### getSubscriptionBookingRequests
+
+Get subscription-based booking requests.
+
+```javascript
+const subscriptionRequests = await getSubscriptionBookingRequests(client, {
+    status: 'ACTIVE',
+    userId: 'user-uuid-here'
+});
+```
+
+#### getSATBookingRequests
+
+Get SAT (Scheduled Access Time) booking requests.
+
+```javascript
+const satRequests = await getSATBookingRequests(client, 'PENDING');
+```
+
+### Individual Booking Requests
+
+#### getBookingRequestById
+
+Retrieve a specific booking request by ID.
+
+```javascript
+const bookingRequest = await getBookingRequestById(client, 'bb493049-5b4f-43ea-8a65-964a13aec549');
+```
+
+#### getBookingRequestByTrip
+
+Get booking request associated with a trip.
+
+```javascript
+const bookingRequest = await getBookingRequestByTrip(client, '33E8E42710144E15A5CC447E4D3524F4');
+```
+
+#### getSubscriptionBookingRequestById
+
+Get subscription booking request by ID.
+
+```javascript
+const subscriptionRequest = await getSubscriptionBookingRequestById(client, 'b7faa2a2-e8fc-4a29-8de7-09ce783b9797');
+```
+
+### Stations
+
+#### getStations
+
+Retrieve stations with optional includes.
+
+```javascript
+const stations = await getStations(client, ['OPEN_HOUR', 'INFO']);
+```
+
+**Parameters:**
+- `client`: AIMA client instance
+- `includes`: Array of data to include ('OPEN_HOUR', 'INFO', 'VEHICLES', 'ZONES')
+
+#### getStationById
+
+Get a specific station by ID.
+
+```javascript
+const station = await getStationById(client, 'station-id-here', ['OPEN_HOUR', 'INFO']);
+```
+
+## Types
+
+### BookingRequest
+
+```typescript
+interface BookingRequest {
+    id: string;
+    userId: string;
+    vehicleId: string;
+    stationId: string;
+    status: 'PENDING' | 'ONGOING' | 'COMPLETED' | 'CANCELLED' | 'EXPIRED';
+    startTime: string;
+    endTime: string;
+    createdAt: string;
+    updatedAt: string;
+}
+```
+
+### Station
+
+```typescript
+interface Station {
+    id: string;
+    name: string;
+    address: string;
+    coordinates: {
+        latitude: number;
+        longitude: number;
+    };
+    isActive: boolean;
+    openHours: OpenHours[];
+    info: StationInfo;
+    vehicles: Vehicle[];
+    zones: Zone[];
+}
+```
+
+### BookingRequestStatus
+
+```typescript
+type BookingRequestStatus = 'PENDING' | 'ONGOING' | 'COMPLETED' | 'CANCELLED' | 'EXPIRED';
+```
+
+### ServiceType
+
+```typescript
+type ServiceType = 'CAR_SHARING' | 'BIKE_SHARING' | 'SCOOTER_SHARING' | 'MULTIMODAL';
 ```
 
+## Error Handling
+
+All functions include validation and will throw appropriate errors if:
+- Required parameters are missing
+- Invalid booking request or station IDs are provided
+- Invalid status values are used
+- Network errors occur
+
+## Examples
+
+### Complete Booking Management Workflow
+
 ```javascript
 import { getClient } from '@vulog/aima-client';
-import { getBookingRequests } from '@vulog/aima-booking';
+import { 
+    getBookingRequests, 
+    getStations, 
+    getBookingRequestById 
+} from '@vulog/aima-booking';
 
 const client = getClient({
-    apiKey: '...',
-    baseUrl: '...',
-    clientId: '...',
-    clientSecret: '...',
-    fleetId: '...',
+    apiKey: 'your-api-key',
+    baseUrl: 'https://your-api-base-url',
+    clientId: 'your-client-id',
+    clientSecret: 'your-client-secret',
+    fleetId: 'your-fleet-id',
 });
 
-const response = await getBookingRequests(client, 'ONGOING');
+async function bookingWorkflow() {
+    try {
+        // Get all ongoing booking requests
+        const ongoingRequests = await getBookingRequests(client, 'ONGOING');
+        console.log(`Found ${ongoingRequests.length} ongoing booking requests`);
+        
+        // Get stations with full information
+        const stations = await getStations(client, ['OPEN_HOUR', 'INFO', 'VEHICLES']);
+        console.log(`Found ${stations.length} stations`);
+        
+        // Get specific booking request
+        const bookingRequest = await getBookingRequestById(client, 'bb493049-5b4f-43ea-8a65-964a13aec549');
+        console.log('Booking request details:', bookingRequest);
+        
+        return { ongoingRequests, stations, bookingRequest };
+    } catch (error) {
+        console.error('Booking workflow error:', error);
+        throw error;
+    }
+}
+```
 
-const station = await getStations(client, ['OPEN_HOUR', 'INFO']);
+### Station Analysis
 
-const br1 = await getBookingRequestById(client, 'bb493049-5b4f-43ea-8a65-964a13aec549');
-const br2 = await getBookingRequestByTrip(client, '33E8E42710144E15A5CC447E4D3524F4');
-const sub = await getSubscriptionBookingRequestById(client, 'b7faa2a2-e8fc-4a29-8de7-09ce783b9797');
+```javascript
+async function analyzeStations(client) {
+    try {
+        const stations = await getStations(client, ['OPEN_HOUR', 'INFO', 'VEHICLES']);
+        
+        const analysis = {
+            totalStations: stations.length,
+            activeStations: stations.filter(s => s.isActive).length,
+            stationsWithVehicles: stations.filter(s => s.vehicles && s.vehicles.length > 0).length,
+            averageVehiclesPerStation: stations.reduce((sum, s) => sum + (s.vehicles?.length || 0), 0) / stations.length,
+            stationsByZone: stations.reduce((acc, station) => {
+                station.zones?.forEach(zone => {
+                    acc[zone.name] = (acc[zone.name] || 0) + 1;
+                });
+                return acc;
+            }, {})
+        };
+        
+        console.log('Station Analysis:');
+        console.log(`Total Stations: ${analysis.totalStations}`);
+        console.log(`Active Stations: ${analysis.activeStations}`);
+        console.log(`Stations with Vehicles: ${analysis.stationsWithVehicles}`);
+        console.log(`Average Vehicles per Station: ${analysis.averageVehiclesPerStation.toFixed(2)}`);
+        console.log('Stations by Zone:', analysis.stationsByZone);
+        
+        return analysis;
+    } catch (error) {
+        console.error('Station analysis error:', error);
+        throw error;
+    }
+}
+```
+
+### Booking Request Monitoring
+
+```javascript
+async function monitorBookingRequests(client) {
+    try {
+        const [ongoing, completed, cancelled] = await Promise.all([
+            getBookingRequests(client, 'ONGOING'),
+            getBookingRequests(client, 'COMPLETED'),
+            getBookingRequests(client, 'CANCELLED')
+        ]);
+        
+        const monitoring = {
+            ongoing: ongoing.length,
+            completed: completed.length,
+            cancelled: cancelled.length,
+            total: ongoing.length + completed.length + cancelled.length,
+            completionRate: completed.length / (completed.length + cancelled.length) * 100
+        };
+        
+        console.log('Booking Request Monitoring:');
+        console.log(`Ongoing: ${monitoring.ongoing}`);
+        console.log(`Completed: ${monitoring.completed}`);
+        console.log(`Cancelled: ${monitoring.cancelled}`);
+        console.log(`Total: ${monitoring.total}`);
+        console.log(`Completion Rate: ${monitoring.completionRate.toFixed(2)}%`);
+        
+        return monitoring;
+    } catch (error) {
+        console.error('Booking monitoring error:', error);
+        throw error;
+    }
+}
 ```

package/dist/index.js

@@ -358,7 +358,7 @@ var getStationById = async (client, id, includes = []) => {
   });
   if (station && includes.includes("INFO")) {
     const poi = await client.get(
-      `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/poi/${station.poiId}`,
+      `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/pois/${station.poiId}`,
       {
         headers: { accept: "application/vnd.geo+json" }
       }

package/dist/index.mjs

@@ -324,7 +324,7 @@ var getStationById = async (client, id, includes = []) => {
   });
   if (station && includes.includes("INFO")) {
     const poi = await client.get(
-      `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/poi/${station.poiId}`,
+      `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/pois/${station.poiId}`,
       {
         headers: { accept: "application/vnd.geo+json" }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vulog/aima-booking",
-    "version": "1.1.89",
+    "version": "1.1.91",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
     "types": "dist/index.d.ts",
@@ -19,8 +19,8 @@
     "author": "Vulog",
     "license": "MIT",
     "dependencies": {
-        "@vulog/aima-client": "1.1.89",
-        "@vulog/aima-core": "1.1.89"
+        "@vulog/aima-client": "1.1.91",
+        "@vulog/aima-core": "1.1.91"
     },
     "peerDependencies": {
         "es-toolkit": "^1.39.9",

package/src/getStation.test.ts

@@ -227,7 +227,7 @@ describe('getStationById', () => {
                     config: {}
                });
             }
-            if (url === `/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/${POI_ID}` ) {
+            if (url === `/boapi/proxy/geoloc/fleets/${FLEET_ID}/pois/${POI_ID}` ) {
                 return Promise.resolve({
                     data: {
                         type: 'FeatureCollection',
@@ -262,7 +262,7 @@ describe('getStationById', () => {
                     config: {}
                });
             }
-            if (url.startsWith(`/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/`)) {
+            if (url.startsWith(`/boapi/proxy/geoloc/fleets/${FLEET_ID}/pois/`)) {
                 return Promise.resolve({
                     data: {
                         type: 'FeatureCollection',
@@ -369,7 +369,7 @@ describe('getStationById', () => {
         expect(getMock).toBeCalledTimes(2);
         expect(getMock).toBeCalledWith(`/boapi/proxy/user/scheduledBooking/fleets/${FLEET_ID}/stations/${STATION_ID}`);
         expect(getMock).toBeCalledWith(
-            `/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/${POI_ID}`,
+            `/boapi/proxy/geoloc/fleets/${FLEET_ID}/pois/${POI_ID}`,
             { headers: { accept: 'application/vnd.geo+json' } }
         );
         expectStation(station, STATION);
@@ -400,7 +400,7 @@ describe('getStationById', () => {
         expect(getMock).toBeCalledTimes(3);
         expect(getMock).toBeCalledWith(`/boapi/proxy/user/scheduledBooking/fleets/${FLEET_ID}/stations/${STATION_ID}`);
         expect(getMock).toBeCalledWith(
-            `/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/${POI_ID}`,
+            `/boapi/proxy/geoloc/fleets/${FLEET_ID}/pois/${POI_ID}`,
             { headers: { accept: 'application/vnd.geo+json' } }
         );
         expect(getMock).toBeCalledWith(`/boapi/proxy/user/fleets/${FLEET_ID}/stations/details?showTimetable=false`);

package/src/getStation.ts

@@ -66,7 +66,7 @@ export const getStationById = async (
     if (station && includes.includes('INFO')) {
         const poi = await client
             .get<{ features: any[] }>(
-                `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/poi/${station.poiId}`,
+                `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/pois/${station.poiId}`,
                 {
                     headers: { accept: 'application/vnd.geo+json' },
                 }