Loading availability...
;
if (!availability) return
{new Date(date).getDate()}
${dayData.price}
{dayData.restrictions.minNights > 1 && (
{dayData.restrictions.minNights}n min
)}
);
};
return (
Data from: {availability.source}
{availability.lastSyncAt && (
Last updated: {new Date(availability.lastSyncAt).toLocaleString()}
)}
{/* Calendar grid rendering logic */}
{availability.availabilities.map(day => renderDay(day.date))}
{availability.bookingConflicts.length > 0 && (
Booking Conflicts:
{availability.bookingConflicts.map((conflict, index) => (
{conflict.checkInDate} to {conflict.checkOutDate}
({conflict.type})
{conflict.expiresAt && (
- expires {new Date(conflict.expiresAt).toLocaleString()}
)}
))}
)}
);
};
```
### Booking Validation [#booking-validation]
```typescript
const validateBookingDates = (availability, checkIn, checkOut) => {
const checkInData = availability.availabilities.find(a => a.date === checkIn);
const stayDates = availability.availabilities.filter(a =>
a.date >= checkIn && a.date < checkOut
);
const validation = {
valid: true,
errors: [],
warnings: [],
totalCost: 0
};
// Check if check-in date exists and is available
if (!checkInData) {
validation.valid = false;
validation.errors.push('Check-in date not found in availability data');
return validation;
}
if (!checkInData.isAvailable) {
validation.valid = false;
validation.errors.push('Check-in date is not available');
}
if (checkInData.restrictions?.closedForArrival) {
validation.valid = false;
validation.errors.push('Check-in date is closed for arrivals');
}
// Check minimum nights requirement
const nights = stayDates.length;
if (checkInData.restrictions?.minNights > nights) {
validation.valid = false;
validation.errors.push(`Minimum ${checkInData.restrictions.minNights} nights required`);
}
// Check maximum nights requirement
if (checkInData.restrictions?.maxNights && nights > checkInData.restrictions.maxNights) {
validation.valid = false;
validation.errors.push(`Maximum ${checkInData.restrictions.maxNights} nights allowed`);
}
// Check all stay dates are available
const unavailableDates = stayDates.filter(day => !day.isAvailable);
if (unavailableDates.length > 0) {
validation.valid = false;
validation.errors.push(`Unavailable dates: ${unavailableDates.map(d => d.date).join(', ')}`);
}
// Check for booking conflicts
const conflicts = availability.bookingConflicts.filter(conflict => {
const conflictStart = new Date(conflict.checkInDate);
const conflictEnd = new Date(conflict.checkOutDate);
const stayStart = new Date(checkIn);
const stayEnd = new Date(checkOut);
return stayStart < conflictEnd && stayEnd > conflictStart;
});
if (conflicts.length > 0) {
const pendingConflicts = conflicts.filter(c => c.type === 'pending_payment_intent');
const confirmedConflicts = conflicts.filter(c => c.type === 'confirmed_booking');
if (confirmedConflicts.length > 0) {
validation.valid = false;
validation.errors.push('Dates conflict with confirmed booking');
}
if (pendingConflicts.length > 0) {
validation.warnings.push('Dates have pending payment intent (may expire soon)');
}
}
// Calculate total cost
validation.totalCost = stayDates.reduce((sum, day) => sum + day.price, 0);
return validation;
};
```
### Price Trend Analysis [#price-trend-analysis]
```typescript
const analyzePriceTrends = (availability) => {
const prices = availability.availabilities
.filter(day => day.isAvailable)
.map(day => ({ date: day.date, price: day.price }));
if (prices.length === 0) return null;
const minPrice = Math.min(...prices.map(p => p.price));
const maxPrice = Math.max(...prices.map(p => p.price));
const avgPrice = prices.reduce((sum, p) => sum + p.price, 0) / prices.length;
const bestValueDates = prices
.filter(p => p.price === minPrice)
.map(p => p.date);
const premiumDates = prices
.filter(p => p.price === maxPrice)
.map(p => p.date);
return {
minPrice,
maxPrice,
avgPrice: Math.round(avgPrice * 100) / 100,
bestValueDates,
premiumDates,
priceSpread: maxPrice - minPrice,
availability: {
total: availability.availabilities.length,
available: prices.length,
percentage: Math.round((prices.length / availability.availabilities.length) * 100)
}
};
};
```
## Data Sources [#data-sources]
### Source Priority [#source-priority]
1. **LiteAPI**: Real-time hotel inventory systems
2. **Strapi**: Property management system data
3. **None**: No availability data found
### Source Characteristics [#source-characteristics]
- **LiteAPI**: Real-time rates and availability, industry standard
- **Strapi**: Direct property data, may include unique inventory
- **Conflict Checking**: Cross-source booking conflict detection
### Data Freshness [#data-freshness]
- **Real-time**: LiteAPI provides live data
- **Batch Sync**: Strapi data synced periodically
- **Conflict Detection**: Real-time checking against active bookings
## Booking Conflicts [#booking-conflicts]
### Conflict Types [#conflict-types]
- **Pending Payment Intent**: Temporary hold on inventory, expires automatically
- **Confirmed Booking**: Definite reservation, blocks availability
### Conflict Resolution [#conflict-resolution]
```typescript
const resolveConflicts = (conflicts) => {
const now = new Date();
return conflicts.map(conflict => {
if (conflict.type === 'pending_payment_intent' && conflict.expiresAt) {
const expiresAt = new Date(conflict.expiresAt);
const isExpired = now > expiresAt;
return {
...conflict,
isExpired,
remainingTime: isExpired ? 0 : Math.max(0, expiresAt - now)
};
}
return conflict;
});
};
```
## Related Endpoints [#related-endpoints]
- [Get Batch Availability](/api-reference/public/availabilities/get-batch-availability) - Multiple properties at once
- [Get Property Rates](/api-reference/public/rates/get-property-rates) - Detailed pricing information
- [Property Search](/api-reference/public/properties/search) - Search with availability filtering