fitbit_web_api_code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e8f15771",
   "metadata": {},
   "source": [
    "# Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "21fff0e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import fitbit\n",
    "import gather_keys_oauth2 as Oauth2\n",
    "import pandas as pd \n",
    "import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "import hashlib\n",
    "import random\n",
    "from pymongo import MongoClient\n",
    "import requests\n",
    "from datetime import timedelta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5396517",
   "metadata": {},
   "source": [
    "# API Authorization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1a799468",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[06/May/2023:23:20:30] ENGINE Listening for SIGTERM.\n",
      "[06/May/2023:23:20:30] ENGINE Bus STARTING\n",
      "CherryPy Checker:\n",
      "The Application mounted at '' has an empty config.\n",
      "\n",
      "[06/May/2023:23:20:30] ENGINE Set handler for console events.\n",
      "[06/May/2023:23:20:30] ENGINE Started monitor thread 'Autoreloader'.\n",
      "[06/May/2023:23:20:30] ENGINE Serving on http://127.0.0.1:8080\n",
      "[06/May/2023:23:20:30] ENGINE Bus STARTED\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "127.0.0.1 - - [06/May/2023:23:20:46] \"GET /?code=81c2495e157d1c0723ef50482ef01f108ef1b483&state=hmj4E1HDap79oKZqhn0QdlCgTNk1g3 HTTP/1.1\" 200 122 \"\" \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36\"\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[06/May/2023:23:20:47] ENGINE Bus STOPPING\n",
      "[06/May/2023:23:20:47] ENGINE HTTP Server cherrypy._cpwsgi_server.CPWSGIServer(('127.0.0.1', 8080)) shut down\n",
      "[06/May/2023:23:20:47] ENGINE Stopped thread 'Autoreloader'.\n",
      "[06/May/2023:23:20:47] ENGINE Removed handler for console events.\n",
      "[06/May/2023:23:20:47] ENGINE Bus STOPPED\n",
      "[06/May/2023:23:20:47] ENGINE Bus EXITING\n",
      "[06/May/2023:23:20:47] ENGINE Waiting for child threads to terminate...\n",
      "[06/May/2023:23:20:47] ENGINE Bus EXITED\n",
      "[06/May/2023:23:20:47] ENGINE Waiting for thread Thread-18.\n"
     ]
    }
   ],
   "source": [
    "# YOU NEED TO PUT IN YOUR OWN CLIENT_ID AND CLIENT_SECRET\n",
    "CLIENT_ID=''\n",
    "CLIENT_SECRET=''\n",
    "\n",
    "server=Oauth2.OAuth2Server(CLIENT_ID, CLIENT_SECRET)\n",
    "server.browser_authorize()\n",
    "ACCESS_TOKEN=str(server.fitbit.client.session.token['access_token'])\n",
    "REFRESH_TOKEN=str(server.fitbit.client.session.token['refresh_token'])\n",
    "auth2_client=fitbit.Fitbit(CLIENT_ID,CLIENT_SECRET,oauth2=True,access_token=ACCESS_TOKEN,refresh_token=REFRESH_TOKEN)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "511844ea",
   "metadata": {},
   "source": [
    "# Get Fitbit Data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc4ad760",
   "metadata": {},
   "source": [
    "## Automated process with a function to access each of the variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a7a3249c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_fitbit(activity, base_date, end_date, token):\n",
    "    url = 'https://api.fitbit.com/1.2/user/-/' + activity + '/date/' + base_date + '/' + end_date + '.json'\n",
    "    response = requests.get(url=url, headers={'Authorization':'Bearer ' + token}).json()\n",
    "\n",
    "    return response"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9873b7f",
   "metadata": {},
   "source": [
    "## Function trasforming the data in the appropriate form and storing them in MongoDb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6944c554",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data(dictItem,typeItem):\n",
    "    data_list = []\n",
    "    # create a random hash ID\n",
    "    hash_object = hashlib.sha256(str(random.getrandbits(256)).encode())\n",
    "    id = hash_object.hexdigest()  \n",
    "    # create a new dictionary with the id, type, and data fields\n",
    "    new_dict = {\n",
    "        'id': id,\n",
    "        'type': typeItem,\n",
    "        'data': dictItem\n",
    "      }           \n",
    "        # append the new dictionary to the output list\n",
    "    collection.insert_one(new_dict)\n",
    "    return data_list "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76b85aaf",
   "metadata": {},
   "source": [
    "## Sleep Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d81a7f91",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getSleepData():\n",
    "\n",
    "    sleepList = df_fitbit('sleep', base_date, end_date, token)['sleep']\n",
    "\n",
    "    for sleepItem in sleepList:\n",
    "        mainSleep = sleepItem['isMainSleep']\n",
    "        if mainSleep == True:\n",
    "            \n",
    "            startTimeDict = {\n",
    "                \"dateTime\": sleepItem['dateOfSleep'],\n",
    "                \"value\": sleepItem['startTime']\n",
    "            }\n",
    "            create_data(startTimeDict,\"sleep_startTime\")\n",
    "\n",
    "            endTimeDict = {\n",
    "                \"dateTime\": sleepItem['dateOfSleep'],\n",
    "                \"value\": sleepItem['endTime']\n",
    "            }\n",
    "            create_data(endTimeDict,\"sleep_endTime\")\n",
    "\n",
    "            timeInBedDict = {\n",
    "                \"dateTime\": sleepItem['dateOfSleep'],\n",
    "                \"value\": sleepItem['timeInBed']\n",
    "            }\n",
    "            create_data(timeInBedDict,\"timeInBed\")\n",
    "\n",
    "            minutesAsleepDict = {\n",
    "                \"dateTime\": sleepItem['dateOfSleep'],\n",
    "                \"value\": sleepItem['minutesAsleep']\n",
    "            }\n",
    "            create_data(minutesAsleepDict,\"minutesAsleep\")\n",
    "\n",
    "            minutesAwakeDict = {\n",
    "                \"dateTime\": sleepItem['dateOfSleep'],\n",
    "                \"value\": sleepItem['minutesAwake']\n",
    "            }\n",
    "            create_data(minutesAwakeDict,\"minutesAwake\")\n",
    "\n",
    "            efficiencyDict = {\n",
    "                \"dateTime\": sleepItem['dateOfSleep'],\n",
    "                \"value\": sleepItem['efficiency']\n",
    "            }\n",
    "            create_data(efficiencyDict,\"sleep_efficiency\")\n",
    "\n",
    "            summaryDeepDict = {\n",
    "                \"dateTime\": sleepItem['dateOfSleep'],\n",
    "                \"value\": sleepItem['levels']['summary']['deep']['minutes']\n",
    "            }\n",
    "            create_data(summaryDeepDict,\"sleep_Deep\")\n",
    "\n",
    "            summaryLightDict = {\n",
    "                \"dateTime\": sleepItem['dateOfSleep'],\n",
    "                \"value\": sleepItem['levels']['summary']['light']['minutes']\n",
    "            }\n",
    "            create_data(summaryLightDict,\"sleep_Light\")\n",
    "\n",
    "            summaryRemDict = {\n",
    "                \"dateTime\": sleepItem['dateOfSleep'],\n",
    "                \"value\": sleepItem['levels']['summary']['rem']['minutes']\n",
    "            }\n",
    "            create_data(summaryRemDict,\"sleep_Rem\")\n",
    "\n",
    "            summaryWakeDict = {\n",
    "                \"dateTime\": sleepItem['dateOfSleep'],\n",
    "                \"value\": sleepItem['levels']['summary']['wake']['minutes']\n",
    "            }\n",
    "            create_data(summaryWakeDict,\"sleep_Wake\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2ab1e20",
   "metadata": {},
   "source": [
    "## User Engagement Data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2951ac8",
   "metadata": {},
   "source": [
    "### Activity Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8e2812f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getActivityData():\n",
    "\n",
    "    # List of activity types to retrieve from Fitbit API\n",
    "    activityList = ['activities/minutesSedentary', 'activities/minutesLightlyActive','activities/minutesFairlyActive',\n",
    "                    'activities/minutesVeryActive', 'activities/heart']\n",
    "    \n",
    "    # Retrieve activity data from Fitbit API for specified date range and activity types\n",
    "    minutesSedentary = df_fitbit(activityList[0], base_date, end_date, token)['activities-minutesSedentary']\n",
    "    minutesLightlyActive = df_fitbit(activityList[1], base_date, end_date, token)['activities-minutesLightlyActive']\n",
    "    minutesFairlyActive = df_fitbit(activityList[2], base_date, end_date, token)['activities-minutesFairlyActive']\n",
    "    minutesVeryActive = df_fitbit(activityList[3], base_date, end_date, token)['activities-minutesVeryActive']\n",
    "    heartRate = df_fitbit(activityList[4], base_date, end_date, token)['activities-heart']\n",
    "    \n",
    "    # Loop through sedentary minutes data and create new data entries for each type of activity\n",
    "    for sedentary in minutesSedentary:\n",
    "        datetimeSed = sedentary['dateTime']\n",
    "        totalTime = int(sedentary['value'])\n",
    "        \n",
    "        # Find matching heart rate data for the sedentary minute and add to the total time\n",
    "        for heart in heartRate:\n",
    "            if heart['dateTime'] == datetimeSed:\n",
    "                if totalTime == 1440:\n",
    "                    totalTime = 0\n",
    "                minutesSedentaryDict = {\n",
    "                    \"dateTime\": datetimeSed, \n",
    "                    \"value\": totalTime, \n",
    "                    } \n",
    "                create_data(minutesSedentaryDict,\"minutesSedentary\")\n",
    "\n",
    "                # Find matching lightly active minutes data for the sedentary minute and add to the total time\n",
    "                for lightlyActive in minutesLightlyActive:\n",
    "                    if datetimeSed == lightlyActive['dateTime']:\n",
    "                        minutesLightlyActiveDict = {\n",
    "                            \"dateTime\": datetimeSed, \n",
    "                            \"value\": int(lightlyActive['value']), \n",
    "                            } \n",
    "                        create_data(minutesLightlyActiveDict,\"minutesLightlyActive\")\n",
    "                        totalTime += int(lightlyActive['value'])\n",
    "                \n",
    "                # Find matching fairly active minutes data for the sedentary minute and add to the total time\n",
    "                for fairlyActive in minutesFairlyActive:\n",
    "                    if datetimeSed == fairlyActive['dateTime']:\n",
    "                        minutesFairlyActiveDict = {\n",
    "                            \"dateTime\": datetimeSed, \n",
    "                            \"value\": int(fairlyActive['value']), \n",
    "                            } \n",
    "                        create_data(minutesFairlyActiveDict,\"minutesFairlyActive\")\n",
    "\n",
    "                        totalTime += int(fairlyActive['value'])\n",
    "\n",
    "                # Find matching very active minutes data for the sedentary minute and add to the total time\n",
    "                for veryActive in minutesVeryActive:\n",
    "                    if datetimeSed == veryActive['dateTime']:\n",
    "                        minutesVeryActiveDict = {\n",
    "                            \"dateTime\": datetimeSed, \n",
    "                            \"value\": int(veryActive['value']), \n",
    "                            } \n",
    "                        create_data(minutesVeryActiveDict,\"minutesVeryActive\")\n",
    "                    \n",
    "                        totalTime += int(veryActive['value'])\n",
    "\n",
    "        # Create a new data entry for total wear time for the day\n",
    "        activityDict = {\n",
    "            \"dateTime\": datetimeSed, \n",
    "            \"value\": totalTime, \n",
    "            }    \n",
    "    \n",
    "        create_data(activityDict,\"totalWearTime\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e633999",
   "metadata": {},
   "source": [
    "### Steps data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e765d068",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getStepsData():\n",
    "    # Get steps count data from the Fitbit API for the specified date range\n",
    "    steps_count = df_fitbit('activities/steps', base_date, end_date, token)['activities-steps']\n",
    "\n",
    "    # Initialize an empty list to store the dates with over 10,000 steps\n",
    "    highly_active_days = []\n",
    "\n",
    "    # Loop through each item in the steps count data\n",
    "    for i in range(0, len(steps_count)):\n",
    "        # Get the number of steps and the date for the current item\n",
    "        steps = steps_count[i].get('value')\n",
    "        date = steps_count[i].get('dateTime')\n",
    "        \n",
    "        # Create a dictionary for the steps count data for the current date\n",
    "        stepsDict = {\n",
    "            \"dateTime\": date, \n",
    "            \"value\": steps, \n",
    "        }\n",
    "        \n",
    "        create_data(stepsDict,\"steps\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63180834",
   "metadata": {},
   "source": [
    "# Inserting data into MongoDB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f0194ece",
   "metadata": {},
   "outputs": [],
   "source": [
    "token = ACCESS_TOKEN\n",
    "base_date = '2023-03-29'\n",
    "end_date = (datetime.datetime.today() - datetime.timedelta(days=1)).strftime('%Y-%m-%d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "173c734f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Connected successfully!!!\n"
     ]
    }
   ],
   "source": [
    "# establing connection\n",
    "try:\n",
    "    connect = MongoClient()\n",
    "    print(\"Connected successfully!!!\")\n",
    "except:\n",
    "    print(\"Could not connect to MongoDB\")\n",
    "\n",
    "# connecting or switching to the database\n",
    "db = connect.fitbitDB\n",
    "\n",
    "# creating or switching to fitbitCollection\n",
    "collection = db.fitbitCollection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7f07f436",
   "metadata": {},
   "outputs": [],
   "source": [
    "# call the functions that create and insert the data\n",
    "getSleepData()\n",
    "getActivityData()\n",
    "getStepsData()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a439594b",
   "metadata": {},
   "source": [
    "### If you want to delete the records in the database in order to run the code again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e7c0db6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#collection.delete_many({})"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}