base

   1import json
   2import bcrypt
   3from flask_pymongo import PyMongo
   4from flask import Flask, request, jsonify
   5from flask_pymongo import PyMongo
   6from pymongo import MongoClient
   7import mongomock
   8from datetime import datetime, timedelta, timezone
   9from flask_jwt_extended import create_access_token,get_jwt,get_jwt_identity, \
  10                               unset_jwt_cookies, jwt_required, JWTManager
  11from datetime import datetime, timedelta
  12from functools import reduce
  13from bson import json_util 
  14from pymongo import MongoClient
  15from flasgger import Swagger
  16
  17
  18
  19api = Flask(__name__)
  20api.secret_key = 'secret'
  21api.config["JWT_SECRET_KEY"] = "softwareEngineering"
  22api.config["JWT_ACCESS_TOKEN_EXPIRES"] = timedelta(hours=1)
  23jwt = JWTManager(api)
  24mongo = None
  25
  26Swagger(api)  
  27
  28
  29def setup_mongo_client(app):
  30    global mongo
  31    if app.config['TESTING']:
  32        # Use mongomock for testing
  33        app.mongo_client = mongomock.MongoClient()
  34        mongo = app.mongo_client["test"]
  35    else:
  36        # Use a real MongoDB connection for production
  37        app.mongo_client = MongoClient('localhost', 27017)
  38        mongo = app.mongo_client["test"]
  39
  40# Call setup_mongo_client during normal (non-test) app initialization
  41setup_mongo_client(api)
  42
  43@api.route('/token', methods=["POST"]) # pragma: no cover
  44def create_token():
  45    """
  46    Create a new access token
  47
  48    ---
  49    tags:
  50      - Authentication
  51    parameters:
  52      - name: email
  53        in: formData
  54        type: string
  55        required: true
  56        description: User email
  57      - name: password
  58        in: formData
  59        type: string
  60        required: true
  61        description: User password
  62    responses:
  63      200:
  64        description: Login successful
  65      401:
  66        description: Invalid email or password
  67    """
  68    email = request.json.get("email", None)
  69    password = request.json.get("password", None)
  70    user = mongo.user.find_one({"email": email})
  71    if (user is not None and (user["password"] == password)):
  72        access_token = create_access_token(identity=email)
  73        return jsonify({"message": "Login successful", "access_token":access_token})
  74    else:
  75        print("Invalid email or password")
  76        return jsonify({"message": "Invalid email or password"}),401
  77    
  78@api.route("/google-login", methods=["POST"])
  79def google_login():
  80    email = request.json.get("email", None)
  81    firstName = request.json.get("first_name", None)
  82    lastName = request.json.get("last_name", None)
  83    user = mongo.user.find_one({"email": email})
  84    if (user is None):
  85        mongo.user.insert_one({"email": email, "first_name": firstName, "last_name": lastName})
  86    access_token = create_access_token(identity=email)
  87    return jsonify({"message": "Login successful", "access_token":access_token})
  88        
  89    
  90
  91@api.route("/register", methods=["POST"])
  92def register():
  93    """
  94    Register a new user
  95
  96    ---
  97    tags:
  98      - User Registration
  99    parameters:
 100      - name: email
 101        in: formData
 102        type: string
 103        required: true
 104        description: User email
 105      - name: password
 106        in: formData
 107        type: string
 108        required: true
 109        description: User password
 110      - name: firstName
 111        in: formData
 112        type: string
 113        required: true
 114        description: User's first name
 115      - name: lastName
 116        in: formData
 117        type: string
 118        required: true
 119        description: User's last name
 120    responses:
 121      200:
 122        description: Registration successful
 123      409:
 124        description: User already exists
 125      500:
 126        description: Registration failed
 127    """
 128
 129    email = request.json.get('email', None)
 130    password = request.json.get('password', None)
 131    first_name = request.json.get('firstName', None)
 132    last_name = request.json.get('lastName', None)
 133    new_document = {
 134    "email": email,
 135    "password": password,
 136    "first_name": first_name,
 137    "last_name": last_name,
 138    }
 139    query = {
 140        "email": email,
 141    }
 142    try:
 143        inserted = mongo.user.update_one(query, {"$set": new_document}, upsert=True)
 144        if (inserted.upserted_id):
 145            response = jsonify({"msg": "register successful"})
 146        else:   
 147            print("User already exists")
 148            response = jsonify({"msg": "User already exists"})
 149    except Exception as e:
 150        response = jsonify({"msg": "register failed"})
 151
 152    return response
 153
 154@api.route("/logout", methods=["POST"])
 155def logout():
 156    """
 157    Logout the user and clear their session
 158
 159    ---
 160    tags:
 161      - User Logout
 162    responses:
 163      200:
 164        description: Logout successful
 165    """
 166    response = jsonify({"msg": "logout successful"})
 167    unset_jwt_cookies(response)
 168    return response
 169
 170@api.route('/events', methods=['GET'])
 171def get_events():
 172    """
 173    Retrieve a list of events
 174
 175    This endpoint retrieves a list of events from the database.
 176
 177    ---
 178    tags:
 179      - Events
 180    responses:
 181      200:
 182        description: A list of events
 183        schema:
 184          type: array
 185          items:
 186            type: object
 187            properties:
 188              _id:
 189                type: string
 190              # Add more properties as needed
 191      404:
 192        description: No events found
 193    """
 194    events_collection = mongo.events
 195    events = list(events_collection.find({}))
 196    for event in events:
 197        event["_id"] = str(event["_id"]) # Convert ObjectId to string
 198    return jsonify(events)
 199
 200@api.route('/is-enrolled', methods=['POST'])
 201@jwt_required()
 202def is_enrolled():
 203    """
 204    Check if the user is enrolled in an event
 205
 206    This endpoint checks if the authenticated user is enrolled in a specific event.
 207
 208    ---
 209    tags:
 210      - Events
 211    parameters:
 212      - in: body
 213        name: data
 214        description: Data containing the eventTitle
 215        required: true
 216        schema:
 217          type: object
 218          properties:
 219            eventTitle:
 220              type: string
 221        example:
 222          eventTitle: "Event Name"
 223    security:
 224      - JWT: []
 225    responses:
 226      200:
 227        description: Indicates whether the user is enrolled
 228        schema:
 229          type: object
 230          properties:
 231            isEnrolled:
 232              type: boolean
 233      401:
 234        description: Unauthorized access
 235    """
 236
 237    data = request.json
 238    eventTitle = data['eventTitle']
 239    current_user = get_jwt_identity()
 240    enrollment = mongo.user.find_one({"email": current_user, "eventTitle": eventTitle})
 241
 242    if enrollment:
 243        return jsonify({"isEnrolled": True})
 244    else:
 245        return jsonify({"isEnrolled": False})
 246
 247
 248@api.route('/enroll', methods=['POST']) # pragma: no cover
 249@jwt_required()
 250def enroll_event(): # pragma: no cover
 251    """
 252    Enroll the user in an event
 253
 254    This endpoint allows an authenticated user to enroll in an event.
 255
 256    ---
 257    tags:
 258      - Events
 259    parameters:
 260      - in: body
 261        name: data
 262        description: Data containing the eventTitle
 263        required: true
 264        schema:
 265          type: object
 266          properties:
 267            eventTitle:
 268              type: string
 269        example:
 270          eventTitle: "Event Name"
 271    security:
 272      - JWT: []
 273    responses:
 274      200:
 275        description: User successfully enrolled in the event
 276        schema:
 277          type: object
 278          properties:
 279            status:
 280              type: string
 281              example: "Data saved successfully"
 282      500:
 283        description: An error occurred while enrolling the user
 284    """
 285    data = request.get_json()  # get data from POST request
 286    current_user = get_jwt_identity()
 287    try:
 288        # Insert data into MongoDB
 289        mongo.user.insert_one({
 290            "email": current_user,
 291            "eventTitle": data['eventTitle']
 292        })
 293        response = {"status": "Data saved successfully"}
 294    except Exception as e:
 295        response = {"status": "Error", "message": str(e)}
 296    
 297    return jsonify(response)
 298
 299@api.route('/unenroll', methods=['POST']) # pragma: no cover
 300@jwt_required()
 301def unenroll_event(): # pragma: no cover
 302    """
 303    Unenroll the user from an event
 304
 305    This endpoint allows an authenticated user to unenroll from an event.
 306
 307    ---
 308    tags:
 309      - Events
 310    parameters:
 311      - in: body
 312        name: data
 313        description: Data containing the eventTitle
 314        required: true
 315        schema:
 316          type: object
 317          properties:
 318            eventTitle:
 319              type: string
 320        example:
 321          eventTitle: "Event Name"
 322    security:
 323      - JWT: []
 324    responses:
 325      200:
 326        description: User successfully unenrolled from the event
 327        schema:
 328          type: object
 329          properties:
 330            status:
 331              type: string
 332              example: "Data saved successfully"
 333      500:
 334        description: An error occurred while unenrolling the user
 335    """
 336    data = request.get_json()  # get data from POST request
 337    current_user = get_jwt_identity()
 338    try:
 339        # Insert data into MongoDB
 340        mongo.user.delete_one({
 341            "email": current_user,
 342            "eventTitle": data['eventTitle']
 343        })
 344        response = {"status": "Data saved successfully"}
 345    except Exception as e:
 346        response = {"status": "Error", "message": str(e)}
 347    
 348    return jsonify(response)
 349
 350@api.route('/profile')
 351@jwt_required()
 352def my_profile(): # pragma: no cover
 353    """
 354    Retrieve user profile information
 355
 356    This endpoint allows an authenticated user to retrieve their profile information.
 357
 358    ---
 359    tags:
 360      - User
 361    security:
 362      - JWT: []
 363    responses:
 364      200:
 365        description: User profile information retrieved successfully
 366        schema:
 367          type: object
 368        example:
 369          {
 370            "_id": "12345",
 371            "email": "user@example.com",
 372            "first_name": "John",
 373            "last_name": "Doe",
 374            "age": 30,
 375            "weight": 70,
 376            "height": 175
 377          }
 378      401:
 379        description: Unauthorized. User must be logged in to access their profile.
 380      404:
 381        description: User profile not found.
 382      500:
 383        description: An error occurred while retrieving the user profile.
 384    """
 385    current_user = get_jwt_identity()
 386    profile = mongo.user.find_one({"email": current_user})
 387    return jsonify(json_util.dumps(profile))
 388
 389@api.route('/caloriesConsumed',methods=["POST"])
 390@jwt_required()
 391def addUserConsumedCalories(): # pragma: no cover
 392    """
 393    Add consumed calories for a user
 394
 395    This endpoint allows an authenticated user to add consumed calories for a specific date.
 396
 397    ---
 398    tags:
 399      - User
 400    security:
 401      - JWT: []
 402    parameters:
 403      - name: body
 404        in: body
 405        required: true
 406        schema:
 407          type: object
 408          properties:
 409            intakeDate:
 410              type: string
 411              format: date
 412              description: The date for which calories are being recorded (e.g., "2023-10-17").
 413            intakeFoodItem:
 414              type: string
 415              description: The name of the food item.
 416            intakeCalories:
 417              type: integer
 418              description: The number of calories consumed for the food item.
 419    responses:
 420      200:
 421        description: Calories consumed data saved successfully.
 422        schema:
 423          type: object
 424        example:
 425          {
 426            "status": "Data saved successfully"
 427          }
 428      401:
 429        description: Unauthorized. User must be logged in to add consumed calories.
 430      500:
 431        description: An error occurred while saving consumed calories data.
 432    """
 433    data = request.get_json()  # get data from POST request
 434    current_user = get_jwt_identity()
 435    try:
 436        # Insert data into MongoDB
 437        mongo.user.update_one({'email': current_user, "consumedDate": data['intakeDate']}, {"$push": {"foodConsumed": {"item":data["intakeFoodItem"],"calories":data["intakeCalories"]}}}, upsert=True)
 438        response = {"status": "Data saved successfully"}
 439        statusCode = 200
 440    except Exception as e:
 441        response = {"status": "Error", "message": str(e)}
 442        statusCode = 500
 443    return jsonify(response),statusCode
 444
 445@api.route('/profileUpdate',methods=["POST"])
 446@jwt_required()
 447def profileUpdate(): # pragma: no cover
 448    """
 449    Update user profile
 450
 451    This endpoint allows an authenticated user to update their profile information.
 452
 453    ---
 454    tags:
 455      - User
 456    security:
 457      - JWT: []
 458    parameters:
 459      - name: body
 460        in: body
 461        required: true
 462        schema:
 463          type: object
 464          properties:
 465            firstName:
 466              type: string
 467              description: The user's first name.
 468            lastName:
 469              type: string
 470              description: The user's last name.
 471            age:
 472              type: integer
 473              description: The user's age.
 474            weight:
 475              type: number
 476              description: The user's weight.
 477            height:
 478              type: number
 479              description: The user's height.
 480            sex:
 481              type: string
 482              description: The user's sex.
 483    responses:
 484      200:
 485        description: User profile updated successfully.
 486        schema:
 487          type: object
 488        example:
 489          {
 490            "msg": "Update successful"
 491          }
 492      401:
 493        description: Unauthorized. User must be logged in to update their profile.
 494      500:
 495        description: An error occurred while updating the user's profile.
 496    """
 497    current_user = get_jwt_identity()
 498    first_name = request.json.get('firstName', None)
 499    last_name = request.json.get('lastName', None)
 500    age = request.json.get('age', None)
 501    weight = request.json.get('weight', None)
 502    height = request.json.get('height', None)
 503    sex = request.json.get('sex', None)
 504    activityLevel = request.json.get('activityLevel', None)
 505    bmi = (0.453*float(weight))/((0.3048*float(height))**2)
 506    bmi = round(bmi,2)
 507    tdee = calculate_tdee(height, weight, age, sex, activityLevel)
 508    new_document = {
 509    "first_name": first_name,
 510    "last_name": last_name,
 511    "age": age,
 512    "weight": weight,
 513    "height": height,
 514    "sex": sex,
 515    "bmi": bmi,
 516    "target_calories": tdee,
 517    }
 518    query = {
 519        "email": current_user,
 520    }
 521    try:
 522        mongo.user.update_one(query, {"$set": new_document}, upsert=True)
 523        response = jsonify({"msg": "update successful"})
 524    except Exception as e:
 525        response = jsonify({"msg": "update failed"})
 526
 527    return response
 528
 529@api.route('/goalsUpdate',methods=["POST"])
 530@jwt_required()
 531def goalsUpdate(): # pragma: no cover
 532    """
 533    Update user goals
 534
 535    This endpoint allows an authenticated user to update their fitness goals, such as target weight, target calories, and target goal.
 536
 537    ---
 538    tags:
 539      - User
 540    security:
 541      - JWT: []
 542    parameters:
 543      - name: body
 544        in: body
 545        required: true
 546        schema:
 547          type: object
 548          properties:
 549            targetWeight:
 550              type: number
 551              description: The user's target weight goal.
 552            targetCalories:
 553              type: number
 554              description: The user's target daily calorie intake goal.
 555            activityLevel:
 556              type: string
 557              description: The user's activity level.
 558    responses:
 559      200:
 560        description: User goals updated successfully.
 561        schema:
 562          type: object
 563        example:
 564          {
 565            "msg": "Update successful"
 566          }
 567      401:
 568        description: Unauthorized. User must be logged in to update their goals.
 569      500:
 570        description: An error occurred while updating the user's goals.
 571    """
 572    current_user = get_jwt_identity()
 573    targetWeight = request.json.get('targetWeight', None)
 574    activityLevel = request.json.get('activityLevel', None)
 575
 576    new_document = {
 577        "target_weight": targetWeight,
 578        "activity_level": activityLevel
 579    }
 580    query = {
 581        "email": current_user,
 582    }
 583    try:
 584        profile = mongo.user.find_one(query)
 585        tdee = calculate_tdee(profile["height"], profile["weight"], profile["age"], profile["sex"], activityLevel)
 586        if tdee:  
 587          new_document["target_calories"] = tdee
 588        mongo.user.update_one(query, {"$set": new_document}, upsert=True)
 589        response = jsonify({"msg": "update successful"})
 590    except Exception as e:
 591        response = jsonify({"msg": "update failed"})
 592
 593    return response
 594
 595
 596@api.route('/caloriesBurned',methods=["POST"])
 597@jwt_required()
 598def addUserBurnedCalories(): # pragma: no cover
 599    """
 600    Add user's burned calories
 601
 602    This endpoint allows an authenticated user to add information about calories burned on a specific date.
 603
 604    ---
 605    tags:
 606      - User
 607    security:
 608      - JWT: []
 609    parameters:
 610      - name: body
 611        in: body
 612        required: true
 613        schema:
 614          type: object
 615          properties:
 616            burnoutDate:
 617              type: string
 618              format: date
 619              description: The date on which calories were burned.
 620            burntoutCalories:
 621              type: number
 622              description: The number of calories burned on the specified date.
 623    responses:
 624      200:
 625        description: Calories burned data saved successfully.
 626        schema:
 627          type: object
 628        example:
 629          {
 630            "status": "Data saved successfully"
 631          }
 632      401:
 633        description: Unauthorized. User must be logged in to add burned calories data.
 634      500:
 635        description: An error occurred while saving the burned calories data.
 636    """
 637    data = request.get_json()  # get data from POST request
 638    current_user = get_jwt_identity()
 639    try:
 640        # Insert data into MongoDB
 641        mongo.user.update_one({'email': current_user, "consumedDate": data['burnoutDate']}, {"$inc": {"burntCalories": int(data["burntoutCalories"])}}, upsert=True)
 642        response = {"status": "Data saved successfully"}
 643        statusCode = 200
 644    except Exception as e:
 645        response = {"status": "Error", "message": str(e)}
 646        statusCode = 500
 647    return jsonify(response),statusCode
 648
 649@api.route('/createFood', methods=["POST"])
 650def createFood():
 651    """
 652    Create a custom food
 653
 654    This endpoint allows an authenticated user to create their custom food item with the amount of calories it has.
 655
 656    ---
 657    tags:
 658      - User
 659    parameters:
 660      - name: body
 661        in: body
 662        required: true
 663        schema:
 664          type: object
 665          properties:
 666            foodName:
 667              type: string
 668              format: food item name
 669              description: The name of the food item being created.
 670            calories:
 671              type: number
 672              description: The number of calories in the created food item.
 673    responses:
 674      200:
 675        description: Food item created successfully
 676        schema:
 677          type: object
 678        example:
 679          {
 680            "status": "Data saved successfully"
 681          }
 682      401:
 683        description: Unauthorized. User must be logged in to create custom food.
 684      500:
 685        description: An error occurred while creating the custom food.
 686
 687    """
 688    data = request.get_json() # get data from POST request
 689    foodName = data['foodName']
 690    calories = data['calories']
 691    try:
 692        # Insert data into MongoDB
 693        mongo.food.insert_one({'food': foodName, "calories": calories})
 694        response = {"status": "Data saved successfully"}
 695        statusCode = 200
 696    except Exception as e:
 697        response = {"status": "Error", "message": str(e)}
 698        statusCode = 500
 699    return jsonify(response),statusCode
 700
 701@api.route('/createMeal', methods=["POST"])
 702@jwt_required()
 703def createMeal():
 704    """
 705    Create a custom meal
 706
 707    This endpoint allows an authenticated user to create their own meals with different food items as the ingredients.
 708
 709    ---
 710    tags:
 711      - User
 712    security:
 713      - JWT: []
 714    parameters:
 715      - name: body
 716        in: body
 717        required: true
 718        schema:
 719          type: object
 720          properties:
 721            mealName:
 722              type: string
 723              format: Meal name
 724              description: The name of the meal item being created.
 725            ingredients:
 726              type: list
 727              description: Is a list of the ingredients in the meal.
 728    responses:
 729      200:
 730        description: Meal created successfully
 731        schema:
 732          type: object
 733        example:
 734          {
 735            "status": "Data saved successfully"
 736          }
 737      401:
 738        description: Unauthorized. User must be logged in to create custom meal.
 739      500:
 740        description: An error occurred while creating the custom meal.
 741
 742    """
 743    data = request.get_json() # get data from POST request
 744    current_user = get_jwt_identity()
 745    mealName = data['mealName']
 746    ingredients = data['ingredients']
 747    calories = 0
 748    for item in ingredients:
 749        food_item = mongo.food.find_one({"food": item})
 750        calories += int(food_item["calories"])
 751    try:
 752        # Insert data into MongoDB
 753        mongo.food.insert_one({'food': mealName, "calories": calories})
 754        mongo.user.insert_one({
 755            "email": current_user,
 756            "meal_name": mealName,
 757            "ingredients": ingredients,
 758            "total_calories": calories
 759        })
 760        response = {"status": "Data saved successfully"}
 761        statusCode = 200
 762    except Exception as e:
 763        response = {"status": "Error", "message": str(e)}
 764        statusCode = 500
 765    return jsonify(response),statusCode
 766
 767@api.route('/weekHistory',methods=["POST"])
 768@jwt_required()
 769def getWeekHistory(): # pragma: no cover
 770    """
 771    Get user's weekly history
 772
 773    This endpoint allows an authenticated user to retrieve their food consumption and calories burned history for the past week.
 774
 775    ---
 776    tags:
 777      - User
 778    security:
 779      - JWT: []
 780    parameters:
 781      - name: body
 782        in: body
 783        required: true
 784        schema:
 785          type: object
 786          properties:
 787            todayDate:
 788              type: string
 789              format: date
 790              description: The date for the end of the week (today's date).
 791    responses:
 792      200:
 793        description: Successfully retrieved the user's weekly history.
 794        schema:
 795          type: array
 796          items:
 797            type: object
 798            properties:
 799              dayIndex:
 800                type: integer
 801                description: Integer from 0 to 6 representing the day index.
 802              date:
 803                type: string
 804                format: date
 805                description: The date for each day in the week.
 806              foodConsumed:
 807                type: array
 808                items:
 809                  type: object
 810                  properties:
 811                    item:
 812                      type: string
 813                      description: Food item name.
 814                    calories:
 815                      type: number
 816                      description: Calories consumed from the food item.
 817                description: A list of dictionaries containing food items and their consumed calories.
 818              caloriesConsumed:
 819                type: number
 820                description: The sum of all calories consumed for that day.
 821              exceededDailyLimit:
 822                type: boolean
 823                description: Indicates whether the calories consumed exceeded the daily limit.
 824              burntCalories:
 825                type: number
 826                description: Calories burned on that day.
 827        example:
 828          [
 829            {
 830              "dayIndex": 0,
 831              "date": "10/13/2023",
 832              "foodConsumed": [
 833                {
 834                  "item": "Chicken Salad",
 835                  "calories": 500
 836                },
 837                {
 838                  "item": "Onion Soup",
 839                  "calories": 300
 840                },
 841                {
 842                  "item": "Potato Salad",
 843                  "calories": 500
 844                },
 845                {
 846                  "item": "Cheese Burger",
 847                  "calories": 500
 848                }
 849              ],
 850              "caloriesConsumed": 1800,
 851              "exceededDailyLimit": false,
 852              "burntCalories": 1200
 853            },
 854            {
 855              "dayIndex": 1,
 856              "date": "10/12/2023",
 857              "foodConsumed": [...],
 858              "caloriesConsumed": ...,
 859              "exceededDailyLimit": ...,
 860              "burntCalories": ...
 861            },
 862            ...
 863          ]
 864      401:
 865        description: Unauthorized. User must be logged in to retrieve weekly history.
 866      500:
 867        description: An error occurred while retrieving the user's weekly history.
 868    """
 869    data = request.get_json()  # get data from POST request
 870    current_user = get_jwt_identity()
 871    todayDate = datetime.strptime(data["todayDate"],"%m/%d/%Y")
 872    dates = [(todayDate-timedelta(days=x)).strftime("%m/%d/%Y") for x in range(7)]
 873    calorieLimit = 1000
 874    result = []
 875    try:
 876        for index,dateToFind in enumerate(dates):
 877            # Every day's res item should like this
 878            # {
 879            #   dayIndex: 0,               #Interger from 0-6
 880            #   date: "10/13/2023",        #Date 0=today, 6=7th day ago from today
 881            #   foodConsumed: [            # A list of dicts, each dict contains a food item and its calories
 882            #     {
 883            #       item: "Chicken Salad",
 884            #       calories: 500,
 885            #     },
 886            #     {
 887            #       item: "Onion Soup",
 888            #       calories: 300,
 889            #     },
 890            #     {
 891            #       item: "Potato Salad",
 892            #       calories: 500,
 893            #     },
 894            #     {
 895            #       item: "Cheese Burger",
 896            #       calories: 500,
 897            #     },
 898            #   ],
 899            #   caloriesConsumed: 1800,    # the sum of all calories consumed from above list
 900            #   exceededDailyLimit: false, # true or false based on whether caloriesConsumed is > limit user set
 901            #   burntCalories: 1200,       # calories burnt out on that day
 902            # }
 903            res = {}
 904            data = mongo.user.find_one({'email': current_user, "consumedDate": dateToFind})
 905            res["dayIndex"] = index
 906            res["date"] = dateToFind
 907            if data:
 908                if "foodConsumed" in data:
 909                    res["foodConsumed"] = data["foodConsumed"]
 910                    res["caloriesConsumed"] = reduce(lambda a,b: a+b, [int(item["calories"]) for item in data["foodConsumed"]])
 911                    res["exceededDailyLimit"] = res["caloriesConsumed"]>calorieLimit
 912                if "burntCalories" in data:
 913                    res["burntCalories"] = data["burntCalories"]
 914            if "foodConsumed" not in res:
 915                res["foodConsumed"] = []
 916            if "caloriesConsumed" not in res:
 917                res["caloriesConsumed"] = 0
 918            if "burntCalories" not in res:
 919                res["burntCalories"] = 0
 920            if "exceededDailyLimit" not in res:
 921                res["exceededDailyLimit"] = False
 922            result.append(res)
 923        response = result
 924        statusCode = 200
 925    except Exception as e:
 926        response = {"status": "Error", "message": str(e)}
 927        statusCode = 500
 928    return jsonify(response),statusCode
 929
 930@api.route("/myMeals",methods=["GET"])
 931@jwt_required()
 932def getMyMeals():
 933    """
 934    Get My Meals
 935
 936    This endpoint allows an authenticated user to retrieve the custom meals that they have created.
 937
 938    ---
 939    tags:
 940      - User
 941      - Meals
 942    security:
 943      - JWT: []
 944    responses:
 945      200:
 946        description: Successfully retrieved the custom meals created by user
 947        schema:
 948          type: object
 949          properties:
 950            mealName:
 951              type: string
 952              description: Name of the custom meal
 953            ingredients:
 954              type: array
 955              description: List of ingredients in the meal
 956          example:
 957            {
 958            "mealName":"My meal",
 959            "ingredients":["Eggs","Toast"],
 960            }
 961      401:
 962        description: Unauthorized. User must be logged in to retrieve the food calorie mapping.
 963      500:
 964        description: An error occurred while retrieving the food calorie mapping.
 965    """
 966    current_user = get_jwt_identity()
 967    result = []
 968    try:
 969        data = mongo.user.find({"email": current_user,"meal_name":{"$exists": True}})
 970        for meal in data:
 971            cal_info = []
 972            for item in meal['ingredients']:
 973                food_item = mongo.food.find_one({'food':item})
 974                cal_info.append({str(item):food_item['calories']})
 975            res={}
 976            res['meal_name']=meal['meal_name']
 977            res['ingredients']=meal['ingredients']
 978            res['total_calories']=meal['total_calories']
 979            result.append(res)
 980        response = result
 981        statusCode = 200
 982    except Exception as e:
 983        response = {"status": "Error", "message": str(e)}
 984        statusCode = 500
 985    return jsonify(response),statusCode
 986        
 987
 988@api.route('/foodCalorieMapping',methods=["GET"])
 989@jwt_required()
 990def getFoodCalorieMapping(): 
 991    """
 992    Get food calorie mapping
 993
 994    This endpoint allows an authenticated user to retrieve a mapping of food items to their respective calorie values.
 995
 996    ---
 997    tags:
 998      - Food
 999    security:
1000      - JWT: []
1001    responses:
1002      200:
1003        description: Successfully retrieved the food calorie mapping.
1004        schema:
1005          type: object
1006          properties:
1007            foodItem:
1008              type: integer
1009              description: Food item name.
1010            calories:
1011              type: number
1012              description: Calories associated with the food item.
1013        example:
1014          {
1015            "Potato": 50,
1016            "Acai": 20,
1017            "Cheeseburger": 80,
1018            ...
1019          }
1020      401:
1021        description: Unauthorized. User must be logged in to retrieve the food calorie mapping.
1022      500:
1023        description: An error occurred while retrieving the food calorie mapping.
1024    """
1025    try:
1026        data = mongo.food.find()
1027        # Response should be in this format {foodItem: calories, foodItem: calories....} 
1028        # For Example { Potato: 50, Acai: 20, Cheeseburger: 80 }
1029        response = {item["food"]:item["calories"] for item in data}
1030        statusCode = 200
1031    except Exception as e:
1032        response = {"status": "Error", "message": str(e)}
1033        statusCode = 500
1034    return jsonify(response),statusCode
1035
1036@api.route('/usersEvents',methods=["GET"]) 
1037@jwt_required()
1038def getUserRegisteredEvents(): 
1039    """
1040    Get user's registered events
1041
1042    This endpoint allows an authenticated user to retrieve the events they are registered for.
1043
1044    ---
1045    tags:
1046      - Events
1047    security:
1048      - JWT: []
1049    responses:
1050      200:
1051        description: Successfully retrieved the user's registered events.
1052        schema:
1053          type: array
1054          items:
1055            type: object
1056            properties:
1057              eventName:
1058                type: string
1059                description: Name of the event.
1060              date:
1061                type: string
1062                format: date
1063                description: Date of the event.
1064            example:
1065              [
1066                {
1067                  "eventName": "Yoga",
1068                  "date": "2023-12-11"
1069                },
1070                {
1071                  "eventName": "Swimming",
1072                  "date": "2023-11-10"
1073                },
1074                ...
1075              ]
1076      401:
1077        description: Unauthorized. User must be logged in to retrieve their registered events.
1078      500:
1079        description: An error occurred while retrieving the user's registered events.
1080    """
1081    try:
1082        # current_user = get_jwt_identity()
1083        current_user = get_jwt_identity()
1084        data = mongo.user.find({"email": current_user, "eventTitle":{"$exists": True}})
1085        response = []
1086        date="10/23/2023"
1087        for item in data:
1088            res = {"eventName": item["eventTitle"], "date": date}
1089            response.append(res)
1090        # Response should be in this format [{eventName: Yoga, date: "12/11/2023"},{eventName: Swimming, date: "11/10/2023"}]
1091        # For Example { Potato: 50, Acai: 20, Cheeseburger: 80 }
1092        statusCode = 200
1093    except Exception as e:
1094        response = {"status": "Error", "message": str(e)}
1095        statusCode = 500
1096    return jsonify(response),statusCode
1097
1098def calculate_tdee(height,weight,age,sex,activityLevel):
1099    if height and weight and age and sex and activityLevel:
1100        pass
1101    else:
1102        return None
1103    kg_weight = float(weight)*0.45359237
1104    cm_height = float(height)*30.48
1105    common_calc_for_male_female = (10*kg_weight) + (6.25*cm_height) - (5*int(age))
1106    if sex == "Male":
1107        bmr = common_calc_for_male_female + 5
1108    else:
1109        bmr = common_calc_for_male_female - 161
1110    personal_activity_levels = {'Minimal': 1.2,'Light': 1.375, 'Moderate': 1.55, 'Heavy':1.725, 'Athlete': 1.9}
1111    tdee = int((bmr * personal_activity_levels[activityLevel]))
1112    return tdee