refactor code, update README

Author: chebro

.gitignore

@@ -1,3 +1,2 @@
-tests
-*.env
-*.json
+config/env
+data/response.json

README.md

@@ -1,40 +1,56 @@
 # arduino-gmail-client
 
-A simple gmail client that makes cURL requests using gmail API to check for unread emails, the response is then used to control arduino pins. So if you connect an LED to the right pins, it will light up everytime you recieve an email!
+A simple gmail API client that makes cURL requests to check for unread emails, and controls arduino GPIO pins. So.. when you get an email, an LED lights up!
 
-This was something I wanted to try when I first stumbled upon gmail API and OAuth 2.0 protocol, finally got an arduino to implement it!!
+This is a proof of concept, something I wanted to try back when I came across gmail API and OAuth 2.0 for the first time, finally got an arduino to implement it!!
 
 ### How Does It Work?
 
-The code is extremely simple if you understand OAuth 2.0, if you don't, read [this article from google](https://developers.google.com/identity/protocols/oauth2). In a nutshell, to access information from a user (a.k.a the resource owner), a client must do the following:
-1. Get the authorization grant from the resource owner (for example, via a [consent screen](https://developers.google.com/identity/protocols/oauth2/web-server#userconsentprompt)).
-2. In exchange to the grant, you recieve an authorization code. 
-3. Exchange the authorization code for access and refresh tokens from the authorization server.
-4. Use the access tokens to make API calls on behalf of the user.
-5. If the access token expires, use the refresh token to request another access token.
+Getting the unread email count using gmail API is not a simple task, since email is a private service a client cannot get access to information without permission. 
 
-Note: Refresh tokens are only provided on the first request. The IETF documentation on the OAuth 2.0 framework can be found [here](https://tools.ietf.org/html/rfc6749).
+OAuth 2.0 is a framework that lays out guidelines for this interaction, before requesting senstive information, getting consent from the user (a.k.a resource owner) is mandatory. Once obtained, the client can exchange it (consent) for temporary access tokens, which must be sent with every future API call that is requesting user data ([more info](https://developers.google.com/identity/protocols/oauth2)).
 
-### What You'll Need To Run This Locally
+Signals are sent to the arduino board based on the response obtained from the API requests, GPIO pins are controlled using standard firmata protocol, python APIs for the same are provided by the pyFirmata library.
 
-#### Setting Up the API Client
+### How Do I Run This?
 
-You'll need to just follow [this tutorial](https://developers.google.com/identity/protocols/oauth2/web-server#top_of_page) and get the following fields:
+#### Set Up an API Client
+
+To obtain your access token and refresh tokens, [follow this guide](https://developers.google.com/identity/protocols/oauth2/web-server#top_of_page).
+
+For future reference, I obtained the authorization grant (code), by browsing:
+
+```sh
+https://accounts.google.com/o/oauth2/v2/auth?client_id=CLIENT_ID&scope=https://www.googleapis.com/auth/gmail.readonly&response_type=code&access_type=offline&redirect_uri=http://localhost
 ```
+
+and exchanged the authorisation code for access tokens via a POST request to [oauth2.googleapis.com/token](https://oauth2.googleapis.com):
+
+```sh
+curl -X POST "https://oauth2.googleapis.com/token" \
+    -d client_id=CLIENT_ID              \
+    -d client_secret=CLIENT_SECRET      \
+    -d code=CODE                        \
+    -d grant_type=authorization_code    \
+    -d redirect_uri=http://localhost
+```
+
+Once you're done, you should have all of the following fields:
+
+```sh
  API_KEY [created on the google developer console]
  CLIENT_ID [registered on google developer console]
  CLIENT_SECRET
  EMAIL_ID [which authorized your client, and whose access + refresh tokens you own]
  ACCESS_TOKEN
  REFRESH_TOKEN
- ```
-You'll only need to do this once because the once you have one access token and the refresh token, you are set. Follow the remaining setps:
+```
 
-1. Rename the `config/template` to `config/.env` and replace the first 5 fields with their respective values. 
-2. Move `data/access_token.json` to `/bin/data/access_token.json` and replace the `<YOUR_ACCESS_TOKEN>` field with the respective value.
+Rename the `config/template` to `config/env` and replace the first 5 fields with their respective values.
 
 #### Required Libraries
 
-You'll need the following libraries the `pyfirmata` python library to communicate with the arduino board, and you'll need to flash your arduino with the [standrard firmata](https://github.com/firmata/arduino/blob/master/examples/StandardFirmata/StandardFirmata.ino), firmata is a generic protocol for communicating with microcontrollers from software on a host computer. And you're all set! 
+- `pyfirmata`
+- flash your arduino with the [standrard firmata](https://github.com/firmata/arduino/blob/master/examples/StandardFirmata/StandardFirmata.ino), firmata is a generic protocol for communicating with microcontrollers from software on a host computer. 
 
-Connect an LED in the pins mentioned in `gmailLEDControl.py` and run `python gmailLEDControl.py` to start making cURL requests every 2 seconds.
+Connect an LED to the pin specified in `gpio_pin_control.py`, and run the python script to make cURL requests every 10 seconds <3

bin/getUnreadEmailCount.sh

@@ -1,7 +1,7 @@
-export API_KEY='YOUR_API_KEY'
-export EMAIL_ID='GMAIL_WHOSE_ACCESSAND_REFRESH_TOKENS_YOUR_HAVE'
-export CLIENT_ID='YOUR_CLIENT_ID'
-export CLIENT_SECRET='YOUR_CLIENT_SECRET'
-export REFRESH_TOKEN='YOUR_REFRESH_TOKEN'
+export API_KEY=''
+export EMAIL_ID=''
+export CLIENT_ID=''
+export CLIENT_SECRET=''
+export REFRESH_TOKEN=''
+export GRANT_TYPE='refresh_token'
 
-export GRANT_TYPE='refresh_token'

bin/refreshAccessToken.sh

@@ -0,0 +1,18 @@
+#! /bin/bash
+
+source "./config/env"
+RESP="./data/response.json"
+
+curl "https://gmail.googleapis.com/gmail/v1/users/$EMAIL_ID/messages?q=is:unread&key=$API_KEY"  \
+    -H "Authorization: Bearer $1"   \
+    -H "Accept: application/json"   \
+    --compressed > "$RESP"
+
+IS_ERR=$(grep "code" "$RESP" | cut -d":" -f2 | cut -d"," -f1)
+RESULT=$(grep "resultSizeEstimate" "$RESP" | cut -d":" -f2)
+
+if [ "$IS_ERR" ]; then
+    ./refresh_access_token.sh
+else
+    echo "$RESULT"
+fi

config/template

@@ -1,6 +1,6 @@
 {
-  "access_token": "<YOUR_ACCESS_TOKEN>",
+  "access_token": "YOUR_ACCESS_TOKEN",
   "expires_in": 3599,
-  "scope": "https://mail.google.com/",
+  "scope": "https://www.googleapis.com/auth/gmail.readonly",
   "token_type": "Bearer"
 }

count_unread_email.sh

@@ -0,0 +1,40 @@
+#!/bin/env/python
+
+"Arduino GPIO PIN control with pyfirmata and gmail API"
+
+import os
+import json
+import time
+
+from pyfirmata import Arduino
+
+class PinController(object):
+
+    def __init__(self):
+        self.board = Arduino('/dev/ttyACM0')
+        self.pin = 13
+
+    def switch_led_state(self, state):
+        "Controls LED State"
+        self.board.digital[self.pin].write(state)
+
+def main():
+    "Main Fucntion"
+
+    pcr = PinController()
+    interval = 10
+
+    while True:
+        token = json.load(open('./data/access_token.json', 'r'))['access_token']
+        res = os.popen(f'./count_unread_email.sh {token}').read()
+        print('Total Unread Emails:', res)
+
+        if res != '' and int(res):
+            pcr.switch_led_state(1)
+        else:
+            pcr.switch_led_state(0)
+
+        time.sleep(interval)
+
+if __name__ == "__main__":
+    main()

data/access_token.json

@@ -0,0 +1,11 @@
+#! /bin/bash
+
+source "./config/env"
+
+curl -X POST                                        \
+    "https://www.googleapis.com/oauth2/v4/token?"   \
+    -d client_id="$CLIENT_ID"                       \
+    -d client_secret="$CLIENT_SECRET"               \
+    -d grant_type="$GRANT_TYPE"                     \
+    -d refresh_token="$REFRESH_TOKEN" > ./data/access_token.json
+