यह पोस्ट आपको टॉमटॉम मैप्स एपीआई का उपयोग करके राइड-ए-रिक्वेस्ट एप्लिकेशन बनाने के बारे में बताएगी। यह एप्लिकेशन उपयोगकर्ताओं को कई पिक-अप और ड्रॉप-ऑफ स्थानों को इनपुट करने, इष्टतम मार्ग की गणना करने और इसे मानचित्र पर प्रदर्शित करने की अनुमति देगा। हम एपीआई कुंजी प्राप्त करने से लेकर मानचित्र पर अनुकूलित मार्ग प्रस्तुत करने तक सब कुछ कवर करेंगे।

चरण 1: टॉमटॉम एपीआई की स्थापना
कोड में गोता लगाने से पहले, आपको टॉमटॉम डेवलपर पोर्टल पर साइन अप करना होगा और एक एपीआई कुंजी प्राप्त करनी होगी। यह कुंजी आपको टॉमटॉम की सेवाओं जैसे रूटिंग, जियोकोडिंग और मानचित्र तक पहुंचने की अनुमति देगी।

चरण 2: सवारी अनुरोध कार्यक्षमता को लागू करना
एप्लिकेशन के मूल में पते एकत्र करना, उन्हें निर्देशांक में परिवर्तित करना और इष्टतम मार्ग की गणना करना शामिल है। यहां बताया गया है कि आप यह कैसे कर सकते हैं:

def ride_request(request):
    if request.method == 'POST':
        form = RideForm(request.POST)
        if form.is_valid():
            ride = form.save(commit=False)
            # Get coordinates for the pickup and drop locations
            pickup_coords = get_coordinates(ride.pickup_address)
            pickup_coords_1 = get_coordinates(ride.pickup_address_1)
            pickup_coords_2 = get_coordinates(ride.pickup_address_2)
            drop_coords = get_coordinates(ride.drop_address)

            # Ensure all coordinates are available
            if all([pickup_coords, pickup_coords_1, pickup_coords_2, drop_coords]):
                # Set the coordinates
                ride.pickup_latitude, ride.pickup_longitude = pickup_coords
                ride.pickup_latitude_1, ride.pickup_longitude_1 = pickup_coords_1
                ride.pickup_latitude_2, ride.pickup_longitude_2 = pickup_coords_2
                ride.drop_latitude, ride.drop_longitude = drop_coords

                # Save the ride and redirect to the success page
                try:
                    ride.save()
                    return redirect('success_page', pickup_lon=ride.pickup_longitude, pickup_lat=ride.pickup_latitude,
                                    pickup_lon_1=ride.pickup_longitude_1, pickup_lat_1=ride.pickup_latitude_1,
                                    pickup_lon_2=ride.pickup_longitude_2, pickup_lat_2=ride.pickup_lat_2,
                                    drop_lon=ride.drop_longitude, drop_lat=ride.drop_latitude)
                except IntegrityError as e:
                    messages.error(request, f'IntegrityError: {str(e)}')
            else:
                messages.error(request, 'Error getting coordinates. Please try again.')
    else:
        form = RideForm()

    return render(request, 'maps/ride_request.html', {'form': form})

इस स्निपेट में, एप्लिकेशन कई पतों के लिए उपयोगकर्ता इनपुट स्वीकार करता है, get_codependents फ़ंक्शन का उपयोग करके इन पतों को निर्देशांक में परिवर्तित करता है, और बाद में उपयोग के लिए डेटा को सहेजता है।

def get_coordinates(address):
    """
    Get coordinates (latitude, longitude) for a given address using TomTom Geocoding API.
    """
    api_key = 'YOUR_TOMTOM_API_KEY'
    base_url = 'https://api.tomtom.com/search/2/geocode/{address}.json'

    # Prepare the URL with the address and API key
    url = base_url.format(address=address)
    params = {'key': api_key}

    # Make the request to TomTom Geocoding API
    response = requests.get(url, params=params)
    data = response.json()

    # Check if the request was successful
    if response.status_code == 200 and data.get('results'):
        # Extract coordinates from the response
        result = data['results'][0]
        if 'position' in result:
            coordinates = result['position']
            return coordinates.get('lat'), coordinates.get('lon')
        else:
            print(
                f"Error getting coordinates for {address}: 'position' key not found in the response.")
            return None
    else:
        # Handle errors or return a default value
        print(
            f"Error getting coordinates for {address}: {data.get('message')}")
        return None

चरण 3: अनुकूलित मार्ग की गणना करना
एक बार जब आपके पास निर्देशांक हों, तो अगला कदम अनुकूलित मार्ग की गणना करना है। टॉमटॉम का वेपॉइंट ऑप्टिमाइज़ेशन एपीआई कई बिंदुओं के बीच सबसे कुशल पथ निर्धारित करने में मदद करता है।

def get_optimized_route(*pickup_coords, drop_coords):
    api_key = 'YOUR_TOMTOM_API_KEY'

    # Prepare the payload for the API
    payload = {
        'waypoints': [{'point': {'latitude': lat, 'longitude': lon}} for lon, lat in pickup_coords],
        'options': {'travelMode': 'car'},
    }

    # Add the drop location to the waypoints
    payload['waypoints'].append({'point': {'latitude': drop_coords[1], 'longitude': drop_coords[0]}})

    # API request
    response = requests.post(f'https://api.tomtom.com/routing/waypointoptimization/1',
                             params={'key': api_key},
                             json=payload)

    if response.status_code == 200:
        data = response.json()
        if 'optimizedOrder' in data:
            # Extract the optimized route
            return [get_route_geometry(pickup_coords[i], pickup_coords[j]) 
                    for i, j in zip(data['optimizedOrder'], data['optimizedOrder'][1:])]
    return None

यह फ़ंक्शन टॉमटॉम एपीआई को एक अनुरोध भेजता है, वेपॉइंट का अनुकूलित क्रम प्राप्त करता है, और फिर मार्ग ज्यामिति की गणना करता है।

चरण 4: मानचित्र और मार्ग का प्रतिपादन
अंत में, अनुकूलित मार्ग डेटा प्राप्त करने के बाद, आपके successful_page.html पर मानचित्र को प्रस्तुत करने का समय आ गया है।

{% load static %}



    

        

    
    
    

यह HTML कोड टॉमटॉम मानचित्र को आरंभ करता है, पिकअप और ड्रॉप-ऑफ बिंदुओं पर मार्कर लगाता है, और उनके बीच का मार्ग बनाता है।

परिणाम: सवारी अनुरोध प्रपत्र और सफलता मानचित्र

नोट: ऊपर दिया गया कोड टॉमटॉम के एपीआई का उपयोग करके सवारी का अनुरोध करने और मार्गों की गणना करने की बुनियादी कार्यक्षमता को प्रदर्शित करने के लिए एक सरल उदाहरण है। वास्तविक कार्यान्वयन भिन्न हो सकता है और इसमें विशिष्ट आवश्यकताओं के आधार पर अतिरिक्त सुविधाएँ या विविधताएँ शामिल हो सकती हैं। अधिक विस्तृत जानकारी और उन्नत उपयोग के लिए, कृपया आधिकारिक टॉमटॉम डेवलपर दस्तावेज़ीकरण देखें।