🚀 Complete Laca City Website with VPS Deployment

- Added complete Next.js frontend with responsive design
- Added NestJS backend with PostgreSQL and Redis
- Added comprehensive VPS deployment script (vps-deploy.sh)
- Added deployment guide and documentation
- Added all assets and static files
- Configured SSL, Nginx, PM2, and monitoring
- Ready for production deployment on any VPS

frontend/src/hooks/api.ts

@@ -1,8 +1,7 @@
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { parkingService, routingService, healthService } from '@/services/api';
+import { parkingService, healthService } from '@/services/api';
 import { 
   FindNearbyParkingRequest, 
-  RouteRequest, 
   UpdateAvailabilityRequest 
 } from '@/types';
 
@@ -14,10 +13,6 @@ export const QUERY_KEYS = {
     byId: (id: number) => ['parking', id],
     popular: (limit?: number) => ['parking', 'popular', limit],
   },
-  routing: {
-    route: (params: RouteRequest) => ['routing', 'route', params],
-    status: ['routing', 'status'],
-  },
   health: ['health'],
 } as const;
 
@@ -83,26 +78,6 @@ export function useUpdateParkingAvailability() {
   });
 }
 
-// Routing hooks
-export function useRoute(request: RouteRequest, enabled = true) {
-  return useQuery({
-    queryKey: QUERY_KEYS.routing.route(request),
-    queryFn: () => routingService.calculateRoute(request),
-    enabled: enabled && !!request.originLat && !!request.originLng && !!request.destinationLat && !!request.destinationLng,
-    staleTime: 15 * 60 * 1000, // 15 minutes
-    refetchOnWindowFocus: false,
-  });
-}
-
-export function useRoutingStatus() {
-  return useQuery({
-    queryKey: QUERY_KEYS.routing.status,
-    queryFn: routingService.getStatus,
-    staleTime: 30 * 1000, // 30 seconds
-    refetchInterval: 60 * 1000, // Refresh every minute
-  });
-}
-
 // Health hooks
 export function useHealth() {
   return useQuery({

frontend/src/hooks/useRouting.ts

@@ -1,138 +0,0 @@
-import { useState, useCallback } from 'react';
-import { Coordinates } from '@/types';
-
-export interface RouteStep {
-  instruction: string;
-  distance: number;
-  duration: number;
-  maneuver?: string;
-}
-
-export interface Route {
-  id: string;
-  distance: number; // in meters
-  duration: number; // in seconds
-  geometry: Array<[number, number]>; // [lat, lng] coordinates
-  steps: RouteStep[];
-  mode: 'driving' | 'walking' | 'cycling';
-}
-
-interface RoutingState {
-  route: Route | null;
-  alternatives: Route[];
-  isLoading: boolean;
-  error: string | null;
-}
-
-interface CalculateRouteOptions {
-  mode: 'driving' | 'walking' | 'cycling';
-  avoidTolls?: boolean;
-  avoidHighways?: boolean;
-  alternatives?: boolean;
-}
-
-export const useRouting = () => {
-  const [state, setState] = useState<RoutingState>({
-    route: null,
-    alternatives: [],
-    isLoading: false,
-    error: null
-  });
-
-  const calculateRoute = useCallback(async (
-    start: Coordinates,
-    end: Coordinates,
-    options: CalculateRouteOptions = { mode: 'driving' }
-  ) => {
-    setState(prev => ({
-      ...prev,
-      isLoading: true,
-      error: null
-    }));
-
-    try {
-      // Simulate API call delay
-      await new Promise(resolve => setTimeout(resolve, 1500));
-
-      // Mock route calculation
-      const distance = calculateDistance(start, end);
-      const mockRoute: Route = {
-        id: 'route-1',
-        distance: distance * 1000, // Convert to meters
-        duration: Math.round(distance * 180), // Rough estimate: 3 minutes per km for driving
-        geometry: [
-          [start.latitude, start.longitude],
-          [end.latitude, end.longitude]
-        ],
-        steps: [
-          {
-            instruction: `Đi từ vị trí hiện tại`,
-            distance: distance * 1000 * 0.1,
-            duration: Math.round(distance * 18)
-          },
-          {
-            instruction: `Đến ${end.latitude.toFixed(4)}, ${end.longitude.toFixed(4)}`,
-            distance: distance * 1000 * 0.9,
-            duration: Math.round(distance * 162)
-          }
-        ],
-        mode: options.mode
-      };
-
-      setState(prev => ({
-        ...prev,
-        isLoading: false,
-        route: mockRoute,
-        alternatives: []
-      }));
-
-      return { route: mockRoute, alternatives: [] };
-    } catch (error: any) {
-      setState(prev => ({
-        ...prev,
-        isLoading: false,
-        error: error.message || 'Failed to calculate route'
-      }));
-      throw error;
-    }
-  }, []);
-
-  const clearRoute = useCallback(() => {
-    setState({
-      route: null,
-      alternatives: [],
-      isLoading: false,
-      error: null
-    });
-  }, []);
-
-  return {
-    route: state.route,
-    alternatives: state.alternatives,
-    isLoading: state.isLoading,
-    error: state.error,
-    calculateRoute,
-    clearRoute
-  };
-};
-
-// Helper function to calculate distance between two coordinates
-function calculateDistance(coord1: Coordinates, coord2: Coordinates): number {
-  const R = 6371; // Earth's radius in kilometers
-  const dLat = toRadians(coord2.latitude - coord1.latitude);
-  const dLon = toRadians(coord2.longitude - coord1.longitude);
-  
-  const a = 
-    Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-    Math.cos(toRadians(coord1.latitude)) * 
-    Math.cos(toRadians(coord2.latitude)) * 
-    Math.sin(dLon / 2) * Math.sin(dLon / 2);
-  
-  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-  
-  return R * c; // Distance in kilometers
-}
-
-function toRadians(degrees: number): number {
-  return degrees * (Math.PI / 180);
-}