Location Operations

Copy

• Copy for LLM

  Copy page as Markdown for LLMs
• View as Markdown

  Open this page as Markdown
• Open in ChatGPT

  Get insights from ChatGPT
• Open in Claude

  Get insights from Claude
• Connect to Cursor

  Install MCP server on Cursor
• Connect to VS Code

  Install MCP server on VS Code

GET /locations?query={query}

Authorization: Bearer YOUR_ACCESS_TOKEN

curl -X GET "https://api.pro.yolcu360.com/api/v1/locations?query=istanbul" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

[
  {
    "placeId": "ChIJOwg_06VPwokRYv534QaPC8g",
    "description": "Istanbul, Turkey",
    "mainText": "Istanbul",
    "secondaryText": "Turkey",
    "types": [
      "locality",
      "political"
    ]
  },
  {
    "placeId": "ChIJB3uraJq9yhQRvHRAVQ6KFT4",
    "description": "Istanbul Airport (IST), Tayakadın, Arnavutköy/İstanbul, Turkey",
    "mainText": "Istanbul Airport (IST)",
    "secondaryText": "Tayakadın, Arnavutköy/İstanbul, Turkey",
    "types": [
      "airport",
      "establishment",
      "point_of_interest"
    ]
  },
  {
    "placeId": "ChIJ8dYSQGq8yhQRy_TlKn0Qmgg",
    "description": "Sabiha Gökçen International Airport (SAW), Pendik/İstanbul, Turkey",
    "mainText": "Sabiha Gökçen International Airport (SAW)",
    "secondaryText": "Pendik/İstanbul, Turkey",
    "types": [
      "airport",
      "establishment",
      "point_of_interest"
    ]
  },
  {
    "placeId": "ChIJh8tEqiq9yhQR4Es7hO_KWw8",
    "description": "Istanbul Atatürk Airport (ISL), Yeşilköy, Bakırköy/İstanbul, Turkey",
    "mainText": "Istanbul Atatürk Airport (ISL)",
    "secondaryText": "Yeşilköy, Bakırköy/İstanbul, Turkey",
    "types": [
      "airport",
      "establishment",
      "point_of_interest"
    ]
  },
  {
    "placeId": "ChIJu46S-ZNjyhQROG9z8KiBUUs",
    "description": "Sultanahmet, Fatih/İstanbul, Turkey",
    "mainText": "Sultanahmet",
    "secondaryText": "Fatih/İstanbul, Turkey",
    "types": [
      "neighborhood",
      "political"
    ]
  }
]

GET /locations/{placeId}

curl -X GET https://api.pro.yolcu360.com/api/v1/locations/ChIJOwg_06VPwokRYv534QaPC8g \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

{
  "placeId": "ChIJOwg_06VPwokRYv534QaPC8g",
  "name": "Istanbul",
  "city": "Istanbul",
  "countryCode": "TR",
  "timezone": "Europe/Istanbul",
  "point": {
    "lat": 41.0082,
    "lon": 28.9784
  }
}

class LocationAutocomplete {
    constructor(inputElement, apiToken) {
        this.input = inputElement;
        this.token = apiToken;
        this.debounceTimer = null;
        this.cache = new Map();

        this.setupEventListeners();
    }

    setupEventListeners() {
        this.input.addEventListener('input', (e) => {
            this.handleInput(e.target.value);
        });
    }

    handleInput(query) {
        // Clear previous timer
        clearTimeout(this.debounceTimer);

        // Validate minimum length
        if (query.length < 2) {
            this.clearResults();
            return;
        }

        // Debounce the search
        this.debounceTimer = setTimeout(() => {
            this.searchLocations(query);
        }, 300);
    }

    async searchLocations(query) {
        // Check cache first
        if (this.cache.has(query)) {
            this.displayResults(this.cache.get(query));
            return;
        }

        try {
            const response = await fetch(
                `/api/v1/locations?query=${encodeURIComponent(query)}`,
                {
                    headers: {
                        'Authorization': `Bearer ${this.token}`
                    }
                }
            );

            if (!response.ok) {
                throw new Error('Search failed');
            }

            const locations = await response.json();

            // Cache the results
            this.cache.set(query, locations);

            // Display results
            this.displayResults(locations);

        } catch (error) {
            console.error('Location search error:', error);
            this.showError('Failed to search locations');
        }
    }

    displayResults(locations) {
        // Implementation for displaying search results
        const resultsContainer = document.getElementById('location-results');
        resultsContainer.innerHTML = '';

        locations.forEach(location => {
            const item = document.createElement('div');
            item.className = 'location-item';
            item.innerHTML = `
        <div class="main-text">${location.mainText}</div>
        <div class="secondary-text">${location.secondaryText}</div>
      `;

            item.addEventListener('click', () => {
                this.selectLocation(location);
            });

            resultsContainer.appendChild(item);
        });
    }

    async selectLocation(location) {
        try {
            // Get detailed location information
            const response = await fetch(
                `/api/v1/locations/${location.placeId}`,
                {
                    headers: {
                        'Authorization': `Bearer ${this.token}`
                    }
                }
            );

            if (!response.ok) {
                throw new Error('Failed to get location details');
            }

            const locationDetails = await response.json();

            // Update input and trigger selection event
            this.input.value = location.description;
            this.input.dispatchEvent(new CustomEvent('locationSelected', {
                detail: locationDetails
            }));

            this.clearResults();

        } catch (error) {
            console.error('Location selection error:', error);
            this.showError('Failed to select location');
        }
    }

    clearResults() {
        const resultsContainer = document.getElementById('location-results');
        if (resultsContainer) {
            resultsContainer.innerHTML = '';
        }
    }

    showError(message) {
        // Implementation for showing error messages
        console.error(message);
    }
}

// Usage
const pickupInput = document.getElementById('pickup-location');
const autocomplete = new LocationAutocomplete(pickupInput, accessToken);

pickupInput.addEventListener('locationSelected', (event) => {
    const location = event.detail;
    console.log('Selected location:', location);

    // Store coordinates for vehicle search
    window.pickupCoordinates = {
        lat: location.point.lat,
        lon: location.point.lon
    };
});

async function validateLocation(placeId) {
    try {
        const response = await fetch(`/api/v1/locations/${placeId}`, {
            headers: {
                'Authorization': `Bearer ${accessToken}`
            }
        });

        if (!response.ok) {
            if (response.status === 404) {
                throw new Error('Location not found or not supported');
            }
            throw new Error('Location validation failed');
        }

        const location = await response.json();

        // Validate that location has required fields
        if (!location.point || !location.point.lat || !location.point.lon) {
            throw new Error('Location does not have valid coordinates');
        }

        return location;

    } catch (error) {
        console.error('Location validation error:', error);
        throw error;
    }
}

function calculateDistance(location1, location2) {
    const R = 6371; // Earth's radius in kilometers
    const dLat = (location2.lat - location1.lat) * Math.PI / 180;
    const dLon = (location2.lon - location1.lon) * Math.PI / 180;

    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
        Math.cos(location1.lat * Math.PI / 180) * Math.cos(location2.lat * Math.PI / 180) *
        Math.sin(dLon / 2) * Math.sin(dLon / 2);

    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    const distance = R * c;

    return distance; // Distance in kilometers
}

function validateLocationDistance(pickupLocation, dropoffLocation) {
    const distance = calculateDistance(
        pickupLocation.point,
        dropoffLocation.point
    );

    // Warn if locations are very far apart (>500km)
    if (distance > 500) {
        return {
            valid: true,
            warning: `Pickup and drop-off locations are ${distance.toFixed(0)}km apart`
        };
    }

    return {valid: true};
}

{
  "code": 1001,
  "description": "Invalid query parameter",
  "details": {
    "field": "query",
    "message": "Query must be at least 2 characters long"
  }
}