samuel-ng: Add all used datasets and Notebook

.github/workflows/ci.yml

@@ -0,0 +1,53 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+# Build and Deploy
+jobs:
+  build-production:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Login to docker hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{secrets.CI_DOCKER_USERNAME}}
+          password: ${{secrets.CI_DOCKER_PASSWORD}}
+
+      - name: Build the docker image
+        run: |
+          ls -la 
+          docker build . -f Dockerfile -t ${{ secrets.CI_DOCKER_USERNAME }}/${{ secrets.APP_NAME }}:${{ github.sha }}
+
+      - name: Push the docker image
+        run: |
+          docker push ${{ secrets.CI_DOCKER_USERNAME }}/${{ secrets.APP_NAME }}:${{ github.sha }}
+
+  deploy-production:
+    runs-on: ubuntu-latest
+    needs: build-production
+
+    steps:
+      - name: Deploy to Production
+        uses: appleboy/ssh-action@v0.1.7
+        with:
+          host: ${{ secrets.SSH_HOST }}
+          username: ${{ secrets.USER_NAME }}
+          key: ${{ secrets.SERVER_PROD_KEY }}
+          script: |
+            echo '${{ secrets.CI_DOCKER_PASSWORD }}' | sudo docker login --username '${{ secrets.CI_DOCKER_USERNAME }}' --password-stdin;
+            sudo docker stop '${{ secrets.APP_NAME }}';
+            sudo docker rm '${{ secrets.APP_NAME }}';
+            sudo docker pull '${{ secrets.CI_DOCKER_USERNAME }}'/'${{ secrets.APP_NAME }}':'${{ github.sha }}';
+            sudo docker run -d -p 5000:5000 --name "${{ secrets.APP_NAME }}" -e GOOGLE_MAP_API_KEY="${{ secrets.GOOGLE_MAP_API_KEY }}" -e DATABASE_URL="${{ secrets.DATABASE_URL }}" "${{ secrets.CI_DOCKER_USERNAME }}"/"${{ secrets.APP_NAME }}":"${{ github.sha }}";
+            sudo docker system prune -a -f;
+            sudo docker logout;
+

.gitignore

@@ -0,0 +1,3 @@
+.venv/
+__pycache__
+.env

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.12.3
+
+# Set the working directory
+WORKDIR /main
+
+# Copy the requirements file from 'main'
+COPY ./main/requirements.txt /main/requirements.txt
+
+# Install the dependencies
+RUN pip install --no-cache-dir --upgrade -r /main/requirements.txt
+
+# Copy the application code from the 'main/app' directory
+# COPY ./main/app /main/app
+COPY ./main /main
+
+# # Copy the run.py script
+# COPY ./main/run.py /main/run.py
+
+# Set environment variables
+ENV FLASK_APP=run.py
+ENV FLASK_RUN_HOST=0.0.0.0
+ENV FLASK_RUN_PORT=5000
+
+# Expose port 5000
+EXPOSE 5000
+
+# Define the default command (assuming you want to run run.py)
+CMD ["flask", "run"]

main/app/__init__.py

@@ -0,0 +1,33 @@
+from flask import Flask
+from pymongo import MongoClient
+from app.models.station import Station
+from app.models.user import User
+from app.controllers.station_controller import station_controller
+from app.controllers.user_controller import user_controller
+from dotenv import load_dotenv
+import os
+
+def create_app():
+    app = Flask(__name__)
+
+    # Load environment variables from .env file
+    load_dotenv()
+
+    # Access environment variables
+    app.config['GOOGLE_MAP_API_KEY'] = os.getenv('GOOGLE_MAP_API_KEY')
+    app.config['DATABASE_URL'] = os.getenv('DATABASE_URL')
+
+    # Set up MongoDB connection
+    client = MongoClient(app.config['DATABASE_URL'], tls=True, tlsAllowInvalidCertificates=True)
+
+    db = client['EVAT']
+
+    # Initialize the models
+    app.charging_stations = Station(db)
+    app.users = User(db)
+
+    # Register the controller blueprints
+    app.register_blueprint(station_controller)
+    app.register_blueprint(user_controller)
+
+    return app

main/app/controllers/station_controller.py

@@ -0,0 +1,77 @@
+from flask import Blueprint, request, jsonify, current_app
+from app.services.station_service import StationService
+import requests
+import os
+
+station_controller = Blueprint('station_controller', __name__)
+
+@station_controller.route('/stations', methods=['GET'])
+def get_stations():
+    page = int(request.args.get('page', 1))
+    size = int(request.args.get('size', 10))
+
+    station_service = StationService(current_app.charging_stations)
+    stations = station_service.get_stations(page, size)
+
+    return jsonify(stations), 200
+
+@station_controller.route('/nearest_station', methods=['GET'])
+def nearest_station():
+    GOOGLE_MAP_API_KEY = os.getenv('GOOGLE_MAP_API_KEY')
+    # Fetch user location via Geolocation API
+    geo_url = f'https://www.googleapis.com/geolocation/v1/geolocate?key={GOOGLE_MAP_API_KEY}'
+    geo_response = requests.post(geo_url, json={})
+
+    if geo_response.status_code != 200:
+        return jsonify({'error': 'Unable to fetch user location'}), 500
+
+    location_data = geo_response.json()
+    user_lat = location_data['location']['lat']
+    user_lng = location_data['location']['lng']
+
+    # Get the threshold from query parameters (default to 0.1 if not provided)
+    threshold = request.args.get('threshold', default=0.1, type=float)
+
+    # Find nearest charging stations using MongoDB geospatial query with the threshold
+    station_service = StationService(current_app.charging_stations)
+    nearest_stations = station_service.get_nearest_station(user_lat, user_lng, threshold)
+
+    if not nearest_stations:
+        return jsonify({'error': 'No charging stations found nearby'}), 404
+
+    # Calculate distance using Google Distance Matrix API
+    distance_matrix_url = 'https://maps.googleapis.com/maps/api/distancematrix/json'
+
+    # Iterate through nearest stations and calculate distance for each
+    station_distances = []
+    for station in nearest_stations:
+        station_lat = station['latitude']
+        station_lng = station['longitude']
+
+        # Prepare API parameters
+        params = {
+            'origins': f"{user_lat},{user_lng}",
+            'destinations': f"{station_lat},{station_lng}",
+            'key': GOOGLE_MAP_API_KEY
+        }
+
+        # Send request to Google Distance Matrix API
+        distance_response = requests.get(distance_matrix_url, params=params)
+
+        if distance_response.status_code != 200:
+            return jsonify({'error': 'Unable to calculate distance for station'}), 500
+
+        # Parse distance data
+        distance_data = distance_response.json()
+        distance_info = distance_data['rows'][0]['elements'][0]
+
+        # Append station info with distance details
+        station_distances.append({
+            'station_info': station,
+            'distance_text': distance_info['distance']['text'],
+            'distance_exact_value': distance_info['distance']['value'],  # Distance in meters
+            'duration': distance_info['duration']['text']
+        })
+
+    # Return the list of stations with distance info
+    return jsonify(station_distances)

main/app/controllers/user_controller.py

@@ -0,0 +1,56 @@
+from flask import Blueprint, request, jsonify, current_app
+from app.services.user_service import UserService
+
+user_controller = Blueprint('user_controller', __name__)
+
+@user_controller.route('/users', methods=['POST'])
+def add_user():
+    data = request.json
+    username = data.get('username')
+    password = data.get('password')
+
+    try:
+        user_service = UserService(current_app.users, current_app.charging_stations)
+        user_id = user_service.add_user(username, password)
+        return jsonify({"message": f"User '{username}' added", "id": str(user_id)}), 201
+    except ValueError as e:
+        return jsonify({"error": str(e)}), 400
+
+@user_controller.route('/users', methods=['GET'])
+def get_users():
+    user_service = UserService(current_app.users, current_app.charging_stations)
+    users = user_service.get_users()
+    return jsonify(users), 200
+
+@user_controller.route('/users/<user_id>/favorites', methods=['POST'])
+def add_favorite_station(user_id):
+    data = request.json
+    station_id = data.get('station_id')
+
+    try:
+        user_service = UserService(current_app.users, current_app.charging_stations)
+        user_service.add_favorite_station(user_id, station_id)
+        return jsonify({"message": f"Station '{station_id}' added to favorites"}), 201
+    except ValueError as e:
+        return jsonify({"error": str(e)}), 400
+
+@user_controller.route('/users/<user_id>/favorites', methods=['DELETE'])
+def remove_favorite_station(user_id):
+    data = request.json
+    station_id = data.get('station_id')
+
+    try:
+        user_service = UserService(current_app.users, current_app.charging_stations)
+        user_service.remove_favorite_station(user_id, station_id)
+        return jsonify({"message": f"Station '{station_id}' removed from favorites"}), 200
+    except ValueError as e:
+        return jsonify({"error": str(e)}), 400
+
+@user_controller.route('/users/<user_id>/favorites', methods=['GET'])
+def get_favorite_stations(user_id):
+    try:
+        user_service = UserService(current_app.users, current_app.charging_stations)
+        stations = user_service.get_favorite_stations(user_id)
+        return jsonify(stations), 200
+    except ValueError as e:
+        return jsonify({"error": str(e)}), 400

main/app/models/station.py

@@ -0,0 +1,51 @@
+from pymongo import MongoClient, GEOSPHERE
+from bson import ObjectId
+
+class Station:
+    def __init__(self, db):
+        self.collection = db['charging_stations']
+        self.collection.create_index([("location", GEOSPHERE)])
+
+    def to_dict(self, station):
+        return {
+            "id": str(station["_id"]),
+            "cost": station["cost"],
+            "charging_points": station["charging_points"],
+            "pay_at_location": station["pay_at_location"],
+            "membership_required": station["membership_required"],
+            "access_key_required": station["access_key_required"],
+            "is_operational": station["is_operational"],
+            "latitude": station["latitude"],
+            "longitude": station["longitude"],
+            "operator": station["operator"],
+            "connection_type": station["connection_type"],
+            "current_type": station["current_type"],
+            "charging_points_flag": station["charging_points_flag"]
+        }
+
+    def find_all(self, page, size):
+        offset = (page - 1) * size
+        return list(self.collection.find().skip(offset).limit(size))
+
+    def find_by_id(self, station_id):
+        return self.collection.find_one({"_id": ObjectId(station_id)})
+
+    def find_nearest(self, user_lat, user_lng, threshold):
+        nearest_stations = self.collection.find({
+            "$expr": {
+                "$lt": [
+                    {
+                        "$sqrt": {
+                            "$add": [
+                                { "$pow": [{ "$subtract": ["$longitude", user_lng] }, 2] },
+                                { "$pow": [{ "$subtract": ["$latitude", user_lat] }, 2] }
+                            ]
+                        }
+                    },
+                    threshold
+                ]
+            }
+        })
+
+        nearest_stations = [self.to_dict(station) for station in nearest_stations]
+        return nearest_stations if nearest_stations else None

main/app/models/user.py

@@ -0,0 +1,44 @@
+from pymongo import MongoClient
+from bson import ObjectId
+
+class User:
+    def __init__(self, db):
+        self.collection = db['users']
+
+    def to_dict(self, user):
+        return {
+            "id": str(user["_id"]),
+            "username": user["username"],
+            "make": user.get("make", ""), 
+            "model": user.get("model", ""),  
+            "variant": user.get("variant", ""),  
+            "connection_type": user.get("connection_type", ""),
+            "favorite_stations": user["favorite_stations"]
+        }
+
+    def find_all(self):
+        return list(self.collection.find())
+
+    def find_by_id(self, user_id):
+        return self.collection.find_one({"_id": ObjectId(user_id)})
+
+    def insert(self, username, password):
+        user = {
+            "username": username,
+            "password": password,
+            "favorite_stations": []
+        }
+        result = self.collection.insert_one(user)
+        return result.inserted_id
+
+    def add_favorite_station(self, user_id, station_id):
+        return self.collection.update_one(
+            {"_id": ObjectId(user_id)},
+            {"$push": {"favorite_stations": station_id}}
+        )
+
+    def remove_favorite_station(self, user_id, station_id):
+        return self.collection.update_one(
+            {"_id": ObjectId(user_id)},
+            {"$pull": {"favorite_stations": station_id}}
+        )

main/app/services/station_service.py

@@ -0,0 +1,11 @@
+class StationService:
+    def __init__(self, charging_stations):
+        self.charging_stations = charging_stations
+
+    def get_stations(self, page, size):
+        stations = self.charging_stations.find_all(page, size)
+        return [self.charging_stations.to_dict(station) for station in stations]
+
+    def get_nearest_station(self, latitude, longitude, threshold):
+        stations = self.charging_stations.find_nearest(latitude, longitude, threshold)
+        return stations