Build a Store Locator API with Python Flask

# Sample store data (replace with database queries in production)
STORES = [
    {
        "id": 1,
        "name": "Downtown Store",
        "address": "123 Main St",
        "city": "Beverly Hills",
        "state": "CA",
        "zipcode": "90210",
        "phone": "+1-555-0100",
        "hours": "Mon-Sat 9AM-9PM, Sun 10AM-6PM"
    },
    {
        "id": 2,
        "name": "Westside Location",
        "address": "456 Oak Ave",
        "city": "Beverly Hills",
        "state": "CA",
        "zipcode": "90211",
        "phone": "+1-555-0101",
        "hours": "Mon-Sat 9AM-9PM, Sun 10AM-6PM"
    },
    {
        "id": 3,
        "name": "Airport Plaza",
        "address": "789 LAX Blvd",
        "city": "Los Angeles",
        "state": "CA",
        "zipcode": "90045",
        "phone": "+1-555-0102",
        "hours": "Mon-Sun 8AM-10PM"
    },
    {
        "id": 4,
        "name": "Beach Store",
        "address": "321 Beach Dr",
        "city": "Santa Monica",
        "state": "CA",
        "zipcode": "90401",
        "phone": "+1-555-0103",
        "hours": "Mon-Sun 9AM-9PM"
    },
    {
        "id": 5,
        "name": "Valley Center",
        "address": "555 Valley Rd",
        "city": "Sherman Oaks",
        "state": "CA",
        "zipcode": "91403",
        "phone": "+1-555-0104",
        "hours": "Mon-Sat 10AM-8PM, Sun 11AM-6PM"
    }
]

def get_stores():
    """Get all stores (can be replaced with database query)"""
    return STORES

def get_store_by_id(store_id):
    """Get a single store by ID"""
    return next((store for store in STORES if store["id"] == store_id), None)

def get_stores_by_zipcodes(zipcodes):
    """Filter stores by list of ZIP codes"""
    return [store for store in STORES if store["zipcode"] in zipcodes]

from flask import Flask, request, jsonify
from flask_cors import CORS
import requests
import os
from dotenv import load_dotenv
from stores import get_stores, get_store_by_id, get_stores_by_zipcodes

# Load environment variables
load_dotenv()

app = Flask(__name__)
CORS(app)  # Enable CORS for frontend access

RAPIDAPI_KEY = os.getenv('RAPIDAPI_KEY')
RAPIDAPI_HOST = 'zip-code-api8.p.rapidapi.com'

@app.route('/api/health', methods=['GET'])
def health_check():
    """Health check endpoint"""
    return jsonify({
        'status': 'healthy',
        'message': 'Store Locator API is running'
    })

@app.route('/api/stores', methods=['GET'])
def get_all_stores():
    """Get all stores"""
    try:
        stores = get_stores()
        return jsonify({
            'success': True,
            'count': len(stores),
            'stores': stores
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/stores/<int:store_id>', methods=['GET'])
def get_single_store(store_id):
    """Get a single store by ID"""
    store = get_store_by_id(store_id)
    
    if store:
        return jsonify({
            'success': True,
            'store': store
        })
    else:
        return jsonify({
            'success': False,
            'error': 'Store not found'
        }), 404

@app.route('/api/stores/nearby', methods=['GET'])
def find_nearby_stores():
    """Find stores near a ZIP code within a radius"""
    
    # Get query parameters
    zipcode = request.args.get('zipcode')
    radius = request.args.get('radius', '25')  # Default 25 miles
    
    # Validate inputs
    if not zipcode:
        return jsonify({
            'success': False,
            'error': 'ZIP code is required'
        }), 400
    
    if not zipcode.isdigit() or len(zipcode) != 5:
        return jsonify({
            'success': False,
            'error': 'Invalid ZIP code format'
        }), 400
    
    try:
        # Call ZIP Code API radius search
        url = f"https://{RAPIDAPI_HOST}/radius"
        
        headers = {
            "X-RapidAPI-Key": RAPIDAPI_KEY,
            "X-RapidAPI-Host": RAPIDAPI_HOST
        }
        
        params = {
            "zipcode": zipcode,
            "radius": radius
        }
        
        response = requests.get(url, headers=headers, params=params, timeout=10)
        response.raise_for_status()
        
        radius_data = response.json()
        
        # Extract ZIP codes from radius search results
        nearby_zipcodes = set()
        if radius_data.get('results'):
            for result in radius_data['results']:
                nearby_zipcodes.add(result['zipcode'])
        
        # Filter stores by nearby ZIP codes
        nearby_stores = get_stores_by_zipcodes(nearby_zipcodes)
        
        # Enhance stores with distance information
        stores_with_distance = []
        for store in nearby_stores:
            # Find matching radius result for distance
            distance_info = next(
                (r for r in radius_data.get('results', []) 
                 if r['zipcode'] == store['zipcode']),
                None
            )
            
            store_copy = store.copy()
            store_copy['distance_miles'] = distance_info['distance'] if distance_info else None
            stores_with_distance.append(store_copy)
        
        # Sort by distance (closest first)
        stores_with_distance.sort(
            key=lambda s: s['distance_miles'] if s['distance_miles'] is not None else float('inf')
        )
        
        return jsonify({
            'success': True,
            'search': {
                'zipcode': zipcode,
                'radius': radius,
                'center': radius_data.get('center')
            },
            'count': len(stores_with_distance),
            'stores': stores_with_distance
        })
        
    except requests.exceptions.RequestException as e:
        return jsonify({
            'success': False,
            'error': 'Failed to search radius',
            'details': str(e)
        }), 500
    except Exception as e:
        return jsonify({
            'success': False,
            'error': 'Internal server error',
            'details': str(e)
        }), 500

@app.route('/api/stores/search', methods=['GET'])
def search_stores():
    """Search stores by city, state, or ZIP code"""
    city = request.args.get('city', '').lower()
    state = request.args.get('state', '').upper()
    zipcode = request.args.get('zipcode')
    
    stores = get_stores()
    filtered = stores
    
    if city:
        filtered = [s for s in filtered if city in s['city'].lower()]
    
    if state:
        filtered = [s for s in filtered if s['state'] == state]
    
    if zipcode:
        filtered = [s for s in filtered if s['zipcode'] == zipcode]
    
    return jsonify({
        'success': True,
        'count': len(filtered),
        'stores': filtered
    })

@app.errorhandler(404)
def not_found(error):
    return jsonify({
        'success': False,
        'error': 'Endpoint not found'
    }), 404

@app.errorhandler(500)
def internal_error(error):
    return jsonify({
        'success': False,
        'error': 'Internal server error'
    }), 500

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)