Forem: Robin Goudeketting

Automating Insulin Ordering: Rethinking Google Calendar Integration (Part 6)

Robin Goudeketting — Thu, 22 Aug 2024 12:38:00 +0000

After we discussed automating the prescription request and sending emails to the pharmacy, in the previous part of this series, we explored integrating a task scheduler by adding an event to Google Calendar using gcalcli. However, as promising as this solution seemed, a significant issue has arisen during using the script for a while: the need for reauthentication with Google Calendar every week.

The Issue with Google Calendar CLI (gcalcli)

gcalcli is a command-line tool that allows you to interact with your Google Calendar directly from the terminal. It’s convenient for creating, viewing, and managing events without leaving the command line. However, it relies on OAuth 2.0 authentication, and requires you to reauthorize the tool with Google every seven days if you use it via a test application.

This frequent reauthorization poses a problem for automation. A script designed to run unattended, such as the one we’ve been building to order insulin and schedule reminders, would fail after a week due to this reauthentication requirement. This makes gcalcli unsuitable for long-term, fully automated tasks, unless we want to open up your google calendar to the world (the regular reauthorization is not required on published applications).

Why Reauthentication Happens

Google’s security policies enforce a regular reauthentication process to protect user data. This is particularly stringent for tools like gcalcli that use OAuth 2.0. Even though this enhances security, it complicates the use of such tools in automated scripts where human intervention is not desired.

Alternative Approach - IFTTT

Instead of gcalcli, I've decided to use IFTTT (if this then that). This is a service that allows you to trigger actions, such as creating a calendar event, by sending an email with a specific tag.

Here’s how I set it up:

Step-by-Step Guide for IFTTT Setup

Create an IFTTT Account:
- Sign up for an account using your Google account for easier integration.
Create a New Applet:
- Click the “Create” button on the top left of the IFTTT dashboard.
Set Up the Trigger:
- Click “Add” on the “If This” section.
- Search for the Email service and select the “Send IFTTT an email tagged” trigger.
- Input a tag to trigger the event. For example, use insulin_ordered.
- Click “Create Trigger.”
Set Up the Action:
- Click “Add” on the “Then That” section.
- Search for Google Calendar and select the “Create a detailed event” action.
- Connect your Google Calendar if you haven’t done so already.
- Fill out the form using the following details:
  - Title: Pick up insulin
  - Start Time: Tomorrow 13:00
  - End Time: Tomorrow 13:15
  - All Day: Select “No”
- I left the description and location fields blank.
- Click “Create Action,” then “Continue,” and finally “Create” to finalize the applet.
Test the Setup:
- Send an email to trigger@applet.ifttt.com with the subject #insulin_ordered. If everything is set up correctly, you should see a new event in your Google Calendar.

Script to Automate Event Creation

Now, we will create a script that sends the email to IFTTT whenever we have successfully sent an email to the pharmacy and need to create a calendar event. This script uses the same SMTP credentials as the email we send to the pharmacy, so it should work without a hitch.

function create_event_in_google() {
  SMTP_SERVER="smtp.gmail.com"
  SMTP_PORT="587"
  SMTP_USERNAME="<your gmail account>"
  SMTP_PASSWORD="<app password>"
  TO="trigger@applet.ifttt.com"
  SUBJECT="#insulin_ordered"
  MESSAGE="Subject: $SUBJECT\nTo: $TO\n\n"

  curl --url "smtp://$SMTP_SERVER:$SMTP_PORT" \
      --ssl-reqd \
      --mail-from "$SMTP_USERNAME" \
      --mail-rcpt "$TO" \
      --user "$SMTP_USERNAME:$SMTP_PASSWORD" \
      --tlsv1.2 \
      -T <(echo -e "$MESSAGE")

  if [ $? -eq 0 ]; then
      echo "Done, created event in Google Calendar"
      return 0
  else
      echo "Failed to create event in Google Calendar"
      return 1
  fi
}

How It Works:

SMTP Details: The script uses the same SMTP configuration as the email sent to your pharmacy.
IFTTT Trigger: The TO field is set to IFTTT’s trigger email, and the SUBJECT contains the tag you configured in IFTTT (#insulin_ordered).
Success/Failure Handling: The script checks if the email was successfully sent and provides feedback.

This method bypasses the need for gcalcli and its reauthentication requirement, offering a simple and effective way to automate event creation in Google Calendar.

What’s Next?

With the update in place, the next step will be to have this automation run regularly in the background. I can now already order insulin with one command in my terminal, but ideal would be if it runs periodically in the background.

Stay tuned for any further enhancements and refinements to this process!

Thank you for following along! If you have any questions or suggestions, feel free to leave a comment below. Don't forget to share this post with anyone who might find it useful.

Automating Insulin Ordering: Adding an Event to Google Calendar (Part 5)

Robin Goudeketting — Thu, 06 Jun 2024 08:20:47 +0000

In the previous parts of this series, we discussed capturing the browser request to the GP's website and sending an email to the pharmacy. Now, we will focus on automating the addition of an event to Google Calendar. We're going to be using gcalcli to reduce the amount of manual labor.

Installing `gcalcli`

First, we need to install gcalcli. I'm using MacOS, so I can install in using homebrew:

brew install gcalcli

If you're on a different Operating System, check out the gcalcli docs to find your installation method.

Setting Up Google Calendar API

To enable making events, we need to create a project in the Google Developer Console and set up OAuth credentials. Otherwise Google does not allow us using the Calendar API to create events. Here are the steps I used:

Step 1. Go to Google Developers Console and create a new project, e.g., gcalcli or Insulin Orderer.

Step 2. In the left sidebar, click Enabled APIs and Services and click on "+ Enable APIs and Services". Look for the Google Calendar API and enable it.

Step 3. Create Credentials:

Go back to the project gcalcli in the Developers Console.
Navigate to the "Credentials" section in the left menu.
Click "+ Create Credentials" > "OAuth client ID".
Choose "Application type Desktop App".
Name it gcalcli.
The credentials produced here are needed in step 5.

Step 4. OAuth Consent Screen:

Navigate to the "OAuth consent screen" section in the left menu.
Select "External" users.
Fill in the App name (e.g., gcalcli), User support email, and Developer contact information with your Gmail address.
Leave the App domain blank.
For Scopes, choose all calendar API-related scopes.
Add your Gmail address as a Test user.
Save everything and then go back to the dashboard. It is important to leave the Publishing status as Testing, otherwise your google calendar will be openly available to the world.

Step 5. Authenticate locally:
There are two ways in which you can authenticate your machine to enable interacting with Google Calendar. Either you login using the OAuth screen from google or you create a configuration file.

To login using the Google OAuth screen, paste the following command into your terminal (here you of course change the values of the --client-id and --client-secret):

gcalcli --client-id "your client ID ending in ...apps.googleusercontent.com" --client-secret "your client secret" agenda

This will open your browser and allow you to login.

Alternatively, you can create a configuration file like this: touch ~/.gcalclirc. Then edit this file and add the following to it:

--client-id="your client ID ending in ...apps.googleusercontent.com" --client-secret="your client secret"

In either case, after you've done this, you should be able to run gcalcli agenda and it should show you your agenda items.

Adding a Task to Google Calendar

To check if the gcalcli command works, run:

gcalcli add

If this command runs correctly, it will ask you a few questions regarding the event you want to add. The most important parts are 'Title', 'When', 'Duration', and to which calendar to add the event to. Since I have access to multiple calendars, I needed to select the calendar to add the event to. I copied the name of the calendar to use in the command itself.

Here is the command I use to add an event to my Google Calendar:

gcalcli add --calendar 'Calendar Name' --title 'Pick up insulin' --when 'Tomorrow 13:00' --duration 15 --noprompt

This will add the event to the calendar with name Calendar Name. The title of the event will be Pick up insulin. It will be an event of 15 minutes and it will be scheduled for tomorrow at 13:00. Tomorrow is important, because it can take up to 24h before the prescription is available on my insurance card. Lastly, --noprompt will ensure that if data is missing (like the Location), it will not go into interactive mode to fill in the missing information, which is important for a script that needs to run autonomously.

The command can be added into the bash function relatively simply:

function add_calendar_task() {
  gcalcli add --calendar 'Robin Goudeketting (privé)' --title 'Pick up insulin' --when 'Tomorrow 13:00' --duration 15 --noprompt
}

What’s Next?

With the complete automation script in place, the next step will be to have this automation run regularly in the background. I can now already order insulin with one command in my terminal, but ideal would be if it runs periodically in the background.

Read part 6

Thank you for following along! If you have any questions or suggestions, feel free to leave a comment below. Don't forget to share this post with anyone who might find it useful.

Automating Insulin Ordering: Sending the Email to the Pharmacy (Part 4)

Robin Goudeketting — Wed, 05 Jun 2024 07:34:51 +0000

In this part of the series, we will focus on automating the step of sending an email to the pharmacy to pre-order insulin. We will use Gmail's SMTP server to send the email directly to the pharmacy's inbox. For this, we need the SMTP server details and our account credentials.

I made the choice to use Gmail, because my email in known in the inbox of my pharmacy and therefore my automated email will be unlikely to land in their spam. It also allows my pharmacy to answer my email without me having to worry about anything.

Setting Up Gmail SMTP

If you have 2FA enabled, you'll need to create an app password:

Go to Gmail and click on your avatar.
Select "Manage your Google Account".
Navigate to the "Security" section.
Search for "App passwords" in the search bar.
Create a new app password and use it for sending the email.

If you don't have 2FA enabled, you would need to allow less secure apps to use your email address, but I highly recommend to use 2FA for security reasons.

Sending the Email Using cURL

We will use cURL to send the email via Gmail's SMTP server. Here’s the basic structure of the cURL command:

curl --url "smtp://$SMTP_SERVER:$SMTP_PORT" \
    --ssl-reqd \
    --mail-from "$SMTP_USERNAME" \
    --mail-rcpt "$TO" \
    --user "$SMTP_USERNAME:$SMTP_PASSWORD" \
    --tlsv1.2 \
    -T <(echo -e "$MESSAGE")

Gathering the Required Data

To send the email, we need to fill in the data in the request above. This means we need the following data:

SMTP server: smtp.gmail.com
SMTP port: 587
SMTP username: Your Gmail account email
SMTP password: The app password created in your Google account management dashboard
Recipient email address: The email address of the pharmacy
Subject and body of the email: The actual content of the email

The message in the email will be added in the last line of the curl request. The email message should consist of a list of headers and then the body text. Each header is the header name, followed by a colon and then the value. The most basic setup for this would be something like: Subject: <The Subject>\n\n<Email Body>. Here, the Subject: is the header. For me, that would look something like this:

SUBJECT="Preorder insulin"
BODY=$'Hello\n\nI would like a new insulin prescription.\n\nThanks,\nRobin'

MESSAGE="Subject: $SUBJECT\n\n$BODY"

The last thing I want to do in this script is send a copy of the email to myself as a BCC address. This way, I will get a push notification from gmail every time this automation triggers. To do that, we need to ensure that the true recipient is added as a header to the message on it's own line (To: $TO). If we then add another email recipient in the curl request, it will be pushed to the BCC list. So my message would look like this:

MESSAGE="Subject: $SUBJECT\nTo: $TO\n\n$BODY"

If we then add --mail-rcpt "$SMTP_USERNAME"\ to the curl request, a BCC will be sent to the $SMTP_USERNAME email address.

Complete Script

Below is the complete script to send the email to the pharmacy. It includes error handling to ensure the email is sent successfully.

function send_pharmacy_email() {
  # Set the default value to true to prevent sending too many emails to my pharmacy while testing
  test=${1:-true}

  SMTP_SERVER="smtp.gmail.com"
  SMTP_PORT="587"
  SMTP_USERNAME="<gmail account email to use>"
  SMTP_PASSWORD="<app password>"

  # Recipient email address
  if [[ $test == 'true' ]]; then
      TO="testemail@test.com"
  else
      TO="mypharmacy@pharmacy.com"
  fi

  SUBJECT="Preorder insulin"
  BODY=$'Hello\n\nI would like a new insulin prescription.\n\nThanks,\nRobin'

  MESSAGE="Subject: $SUBJECT\nTo: $TO\n\n$BODY"

  curl --url "smtp://$SMTP_SERVER:$SMTP_PORT" \
      --ssl-reqd \
      --mail-from "$SMTP_USERNAME" \
      --mail-rcpt "$TO" \
      --mail-rcpt "$SMTP_USERNAME" \
      --user "$SMTP_USERNAME:$SMTP_PASSWORD" \
      --tlsv1.2 \
      -T <(echo -e "$MESSAGE")

  if [ $? -eq 0 ]; then
      echo "Done, e-mail sent to $TO"
      return 0
  else
      echo "Failed to send email"
      return 1
  fi
}

Testing this in my terminal result into the following output.

Moreover, the proof of the pudding as it were, in the inbox of my test email address I see the email come in correctly.

I added a test variable that defaults to true to prevent sending an overload of messages to my pharmacy while working on the script. That means that once the script should actually run automatically, we need to pass an argument to the send_pharmacy_email function in the wrapper to ensure it doesn't run in test mode anymore.

What’s Next?

In the next part of this series, we will focus on implementing the add_calendar_task function, which automates adding a task to Google Calendar to remind you to pick up the insulin.

Read part 5

Thank you for following along! If you have any questions or suggestions, feel free to leave a comment below. Don't forget to share this post with anyone who might find it useful.

Automating Insulin Ordering: Creating the Wrapping Function (Part 3)

Robin Goudeketting — Tue, 04 Jun 2024 08:20:07 +0000

In the previous parts of this series, we discussed capturing the browser request to the GP's website and converting it into a cURL command. We also created a bash function to automate this request. Now, we'll take the next step by creating a wrapping function that orchestrates the entire automation process.

Updating the order_insulin Function

To facilitate the wrapping function, we first need to update our order_insulin function to return an exit code. The function should return 0 if the prescription request is successful and 1 if it fails. I also renamed it, to actually capture the step of the process it does. Here’s the updated function:

function request_prescription() {
  insulin_order_response=$(<cURL Request>)

  if [ $? -eq 0 ]; then
      insulin_order_status=$(echo $insulin_order_response | jq -r '.status')
      insulin_order_message=$(echo $insulin_order_response | jq -r '.message')

      if [[ $insulin_order_status == "mail_sent" ]]; then
          echo "Ordered: $insulin_order_message"
          return 0
      else
          echo "Something went wrong, order via the website and update the curl request"
          return 1
      fi
  else
      echo "Something went wrong, order via the website and update the curl request"
      return 1
  fi
}

Creating the Wrapping Function

Next, we need a wrapping function that triggers the prescription request and checks the exit code. If the prescription request is successful, it will proceed to the next steps: sending an email to the pharmacy (Step 4) and adding a task to Google Calendar (Step 5). These two steps will be implemented in future articles, but we will set up the structure for them now.

function order_insulin() {
  request_prescription
  exit_code=$?

  if [[ $exit_code -ne 0 ]]; then
    echo "Prescription request failed"
    return 1
  fi

  echo "Prescription requested successfully"

  send_pharmacy_email
  email_exit_code=$?

  if [[ $email_exit_code -ne 0 ]]; then
    echo "Failed to send email to pharmacy"
    return 1
  fi

  echo "Email sent successfully"

  add_calendar_task
  calendar_exit_code=$?

  if [[ $calendar_exit_code -ne 0 ]]; then
    echo "Calendar task added successfully"
    return 0
  else
    echo "Failed to add calendar task"
    return 1
  fi
}

Of course, these two functions do not yet exist, but they will soon. I added early returns in the cases that the other methods fail, as well as returns for the error or success states. This will allow me to add some error handling in the future, if I think it's needed.

Explanation of the Wrapping Function

order_insulin Function: This is the main wrapping function that coordinates the entire process. It calls the request_prescription function and checks its exit code to determine the next steps.
Exit Code Check: The function checks if the request_prescription function returns 0 (success). If successful, it proceeds to the next steps.
Step 4 - Sending Email to Pharmacy: The function send_pharmacy_email is called. The script checks the exit code of this function to determine if the email was sent successfully.
Step 5 - Adding Task to Google Calendar: If the email was sent successfully, the function add_calendar_task is called. The script checks the exit code of this function to determine if the calendar task was added successfully.

What’s Next?

In the next part of this series, we will focus on implementing the send_pharmacy_email function, which automates sending an email to the pharmacy to pre-order the insulin.

Stay tuned as we continue to streamline the insulin ordering process, one step at a time.

Read part 4

Thank you for following along! If you have any questions or suggestions, feel free to leave a comment below. Don't forget to share this post with anyone who might find it useful.

Automating Insulin Ordering: Capturing the GP Request (Part 2)

Robin Goudeketting — Tue, 04 Jun 2024 08:19:06 +0000

In the first part of this series, I outlined the problem of manually ordering my insulin and introduced the idea of automating this process. Now, we will dive into the first step of this automation: figuring out how to send a request to my GP using a cURL command.

Capturing the Browser Request

To understand how my GP’s website processes the prescription request, I went to their site and filled out the necessary form. Before hitting the send button, I opened my browser's network tab to log all outgoing queries. This step is crucial as it allows us to see the exact request being sent to the server. Before submitting the form, I cleared all the network requests that it had already logged to ensure I would only see the query or queries that are triggered upon the form submission. Once I'd done that, I filled in the form and checked the queries that appeared.

I then submitted the form and I observed two network requests. I inspected both and saw that the one labeled Feedback was the request that actually sent my information to my GP and it contained all the information I had entered. This request is the key to our automation. The server's response was a confirmation message stating that the prescription would be uploaded to my health insurance card within 24 hours.

Analysing the Request

The requests from the network tab are easily copy-able. You just right click the request, and then copy > copy as X. I copied the request as cURL.

I moved it over to a code editor to analyse it in depth. The request included headers, the payload, and other parameters essential for successful submission. Here's a redacted version of the cURL command derived from the network request:

curl 'https://www.mygp.com/order-insulin' \
    -H 'accept: application/json, */*;q=0.1' \
    -H 'accept-language: en-GB,en;q=0.5' \
    -H 'cache-control: no-cache' \
    -H 'content-type: multipart/form-data; boundary=----WebKitFormBoundarynE0B7A3bJADDu4sV' \
    -H 'origin: https://www.mygp.com' \
    -H 'pragma: no-cache' \
    -H 'sec-ch-ua-mobile: ?0' \
    -H 'sec-fetch-dest: empty' \
    -H 'sec-fetch-mode: cors' \
    -H 'sec-fetch-site: same-origin' \
    -H 'sec-gpc: 1' \
    -H 'user-agent: MyDevice' \
    --data-raw $'------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7"\r\n\r\n834\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7_version"\r\n\r\n5.9.3\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7_locale"\r\n\r\nde_DE_formal\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7_unit_tag"\r\n\r\nwpcf7-f834-p922-o1\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7_container_post"\r\n\r\n922\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7_posted_data_hash"\r\n\r\n\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="name"\r\n\r\MYNAME\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="insurance-number"\r\n\r\nINSURANCENUMBER\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="phone"\r\n\r\nMYPHONENUMBER\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="email-195"\r\n\r\nMYEMAIL@EMAIL.COM\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="order"\r\n\r\nTHE ORDER INFORMATION GOES HERE\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="acceptance-255"\r\n\r\n1\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV--\r\n'

Breaking Down the cURL Command

Let's break down what happens in this cURL command:

curl 'https://www.mygp.com/order-insulin': This initiates a POST request to the specified URL.
-H 'accept: application/json, /;q=0.1': Specifies that the request can accept JSON responses.
-H 'accept-language: en-GB,en;q=0.5': Specifies the preferred language for the response.
-H 'cache-control: no-cache': Ensures that the request bypasses any cached responses.
-H 'content-type: multipart/form-data; boundary=----WebKitFormBoundarynE0B7A3bJADDu4sV': Sets the content type to multipart/form-data, which is required for file uploads and form submissions.
-H 'origin: https://www.mygp.com': Specifies the origin of the request.
-H 'pragma: no-cache': Similar to cache-control, it instructs the server not to cache the request.
-H 'sec-ch-ua...': These headers provide additional information about the user agent and its platform.
--data-raw '...': This flag sends the form data in the request body, including my name, insurance number, contact details, and the medication details.

Some of these headers might be superfluous, but I figured it would be best for me to just leave the request as is. That would limit the potential issues with sending it via my terminal later.

Automating the Request

To automate this process, I created a bash function that uses the cURL command to send the request to my GP's website. This function will be the backbone of our automation script, ensuring that the prescription request is sent automatically.

I am using oh-my-zsh and I have a file sourced in my .zshrc in which I add custom methods. However, it would work identically if you put the function into .bashrc or .zshrc directly.

Here's the script:

function order_insulin() {
  insulin_order_response=$(curl 'https://www.mygp.com/order-insulin' \
    -H 'accept: application/json, */*;q=0.1' \
    -H 'accept-language: en-GB,en;q=0.5' \
    -H 'cache-control: no-cache' \
    -H 'content-type: multipart/form-data; boundary=----WebKitFormBoundarynE0B7A3bJADDu4sV' \
    -H 'origin: https://www.mygp.com' \
    -H 'pragma: no-cache' \
    -H 'sec-ch-ua-mobile: ?0' \
    -H 'sec-fetch-dest: empty' \
    -H 'sec-fetch-mode: cors' \
    -H 'sec-fetch-site: same-origin' \
    -H 'sec-gpc: 1' \
    -H 'user-agent: MyDevice' \
    --data-raw $'------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7"\r\n\r\n834\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7_version"\r\n\r\n5.9.3\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7_locale"\r\n\r\nde_DE_formal\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7_unit_tag"\r\n\r\nwpcf7-f834-p922-o1\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7_container_post"\r\n\r\n922\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="_wpcf7_posted_data_hash"\r\n\r\n\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="name"\r\n\r\MYNAME\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="insurance-number"\r\n\r\nINSURANCENUMBER\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="phone"\r\n\r\nMYPHONENUMBER\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="email-195"\r\n\r\nMYEMAIL@EMAIL.COM\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="order"\r\n\r\nTHE ORDER INFORMATION GOES HERE\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV\r\nContent-Disposition: form-data; name="acceptance-255"\r\n\r\n1\r\n------WebKitFormBoundarynE0B7A3bJADDu4sV--\r\n' -s)

  if [ $? -eq 0 ]; then
      # Using jq to parse JSON and extract fields
      insulin_order_status=$(echo $insulin_order_response | jq -r '.status')
      insulin_order_message=$(echo $insulin_order_response | jq -r '.message')

      if [[ $insulin_order_status == "mail_sent" ]]; then
          echo "Ordered: $insulin_order_message"
      else
          echo "Something went wrong, order via the website and update the curl request"
      fi
  else
      echo "Something went wrong, order via the website and update the curl request"
  fi
}

Explanation

cURL Command: The curl command sends a POST request to the GP's website with the necessary headers and form data.
Response Handling: The response is captured in the insulin_order_response variable. We use the -s flag to run curl in silent mode, which suppresses progress output.
Error Checking: The script checks if the curl command executed successfully using $?. If the command fails, an error message is displayed.
Parsing JSON Response: If the curl command is successful, the script uses jq to parse the JSON response and extract the status and message fields.
Conditional Logic: Based on the status field, the script determines if the request was successful ('mail_sent') or if there was an error.

In order to get to the information I needed to make the if-statement work and to figure out the required information, I went back to my network tab. In the response there, the returned JSON looked as follows:

{
    "contact_form_id": 834,
    "status": "mail_sent",
    "message": "Prescription requested successfully.",
    "posted_data_hash": "2905f838031fbd4619d89658928fbb2a",
    "into": "#wpcf7-f834-p922-o1",
    "invalid_fields": []
}

You can clearly see the status and the reply there. Since I am only interested in the success state, I can just check for mail_sent. If the mail wouldn't be sent, then I can log an error. Since I assume that the cURL request will only fail if they change their API, I added the message:

order via the website and update the curl request.

Lastly, I started a new terminal window and tried my new script. Indeed, I saw Ordered: Prescription requested successfully. in my terminal. Does that mean I requested two prescriptions in a short time? Yes it does. I hope nobody comes knocking for that.

What’s Next?

In the next part of this series, we will focus on automating the email to the pharmacy. This involves setting up an email client within our script to send the pre-order request automatically.

Stay tuned as we continue to streamline the insulin ordering process, one step at a time.

Read Part 3

Thank you for following along! If you have any questions or suggestions, feel free to leave a comment below. Don't forget to share this post with anyone who might find it useful.

Automating Insulin Ordering: A Journey Towards Convenience (Part 1)

Robin Goudeketting — Tue, 04 Jun 2024 08:18:56 +0000

Living with Type 1 diabetes comes with its own set of challenges, one of which is managing a regular supply of insulin. As someone who relies on this life-saving medication, I've often found myself entangled in a convoluted system just to get my prescription filled. This multi-part series will walk you through my journey of automating the insulin ordering process, saving time and reducing the hassle involved. In this first part, I'll outline the problem and set the stage for the solution we'll be building.

The Problem

In my region, obtaining insulin isn't as straightforward as it might be elsewhere. Here’s a breakdown of the steps I currently need to take:

Contacting the GP: I have to get in touch with my General Practitioner (GP) to request a new prescription. This involves logging onto their website and sending a message asking them to upload the prescription to my healthcare insurance card.
Waiting for the Prescription: Once the GP uploads the prescription, I can then take my healthcare card to the pharmacy.
Pharmacy Visit: However, the pharmacy usually doesn’t have my specific insulin in stock. This means I have to go there, request the prescription to be filled, and wait for them to order it.
Second Pharmacy Visit: After they’ve ordered it, I have to return the next day to pick up my insulin.

This does not seem like too much hassle, but due to the local restrictions, I have to repeat this process every 2 weeks.

A Slight Improvement

To reduce the number of visits, I've started emailing the pharmacy in advance. I inform them of my prescription and ask them to pre-order the insulin. This way, I only need to visit the pharmacy once, to collect the prescription. While this is a step in the right direction, it still requires multiple manual steps:

Requesting the prescription from my GP.
Sending an email to the pharmacy to pre-order the insulin.
Setting a reminder to pick up the insulin the next day.

The Automation Idea

To streamline this process, I'm planning to write a terminal command that will automate these tasks and can be run in a cronjob on a schedule:

Automated Request to GP: The command will send a request to my GP to upload the prescription.
Automated Email to Pharmacy: Upon receiving a confirmation from the GP, it will send an automated email to the pharmacy to pre-order the insulin.
Google Calendar Integration: Finally, it will add a task to my Google Calendar, reminding me to pick up the insulin.

By automating these steps, I aim to minimise the manual effort and ensure that I never miss an insulin pickup. This series will detail the technical aspects of creating this automation, including writing the script, setting up a cron job, and integrating with email and calendar APIs.

What’s Next?

In the next part of this series, we'll dive into the specifics of writing a terminal command to send a request to the GP. We'll cover everything from figuring out the request to send and how to convert it to a terminal command.

Stay tuned for the next instalment where we take the first step towards a fully automated insulin ordering system.

I hope this series will not only help others facing similar challenges but also provide an interesting automation project for tech enthusiasts. If you have any questions or suggestions, feel free to leave a comment below!

Read Part 2

Thank you for reading! If you enjoyed this post, don't forget to follow me for more updates and share it with anyone who might find it useful.

Publishing my first NPM package only took 3 steps

Robin Goudeketting — Wed, 15 Jul 2020 20:42:18 +0000

Check it out! ~ TL;DR at the End
NPM ~ Github ~ Docs

Learning to code

When I started programming at the beginning of this, I had no clue how much I would like it. Starting at Codaisseur Academy I learned the basics and after 8 weeks and 50 hours of coding and hands on work per day, I officially graduated and was able to make full-stack applications.

I learned how to use NPM and use packages in the Node.js back-end applications as well as importing them into the front-end React.js applications. However, never was I told how to make and publish packages of my own. It seemed so daunting in the beginning. What do you make? How do you publish? Version control? Testing? CI? Where would you start? Then I saw this comic:

Starting the project

So a short while ago I decided to just start with making something. I picked something I encountered in my job, where we use Ruby. In Ruby there are methods, called inflections, that convert strings into (sort of) formatted strings. One of those is called titleize, which converts a string into something that represents a title. I decided to make that as a package for NPM.

I created a folder, initialised NPM, and created a file that held my function. Then there are a few things to note:

Set the "main" key in your package.json to the file that holds your function, like this:

{ 
  ...,
  "main": "./titleize.js", // or something more generic like "./index.js"
  ...,
}

Make an account on NPM. This can be done via their website, but is also easily done via the NPM cli. You can run npm adduser and it will guide you through the creation of a user. When you're done, running npm whoami should tell you your username:
Almost ready to publish your package. First we have to check if our package name is not taken by someone else, otherwise you might get stuck. My terminal started asking for a One-Time Password. Turned out, the name of my project already existed and probably I was trying to publish to that package. If you cannot find a package with the name you chose, you should be good to run npm publish.
Only thing that's left to do is installing your package into a different project. Just run

npm i titleizejs

Or whatever you called your package and import it into your files!

I also then added some Mocha/Chai test and hooked it up to Github Actions for automated testing. Also I hooked it up to Github Pages to generate a nice website for the docs. I might write about how that works if you are interested.

TL;DR

Publishing a package is super easy:

Create your package: run npm init and create you files.
Create an NPM account: run npm adduser (or npm login).
Publish your package: run npm publish.
Check out Titleize JS: run npm i titleizejs

Forem: Robin Goudeketting

Automating Insulin Ordering: Rethinking Google Calendar Integration (Part 6)

The Issue with Google Calendar CLI (gcalcli)

Why Reauthentication Happens

Alternative Approach - IFTTT

Step-by-Step Guide for IFTTT Setup

Script to Automate Event Creation

How It Works:

What’s Next?

Automating Insulin Ordering: Adding an Event to Google Calendar (Part 5)

Installing gcalcli

Setting Up Google Calendar API

Adding a Task to Google Calendar

What’s Next?

Automating Insulin Ordering: Sending the Email to the Pharmacy (Part 4)

Setting Up Gmail SMTP

Sending the Email Using cURL

Gathering the Required Data

Complete Script

What’s Next?

Automating Insulin Ordering: Creating the Wrapping Function (Part 3)

Updating the order_insulin Function

Creating the Wrapping Function

Explanation of the Wrapping Function

What’s Next?

Automating Insulin Ordering: Capturing the GP Request (Part 2)

Capturing the Browser Request

Analysing the Request

Breaking Down the cURL Command

Automating the Request

Explanation

What’s Next?

Automating Insulin Ordering: A Journey Towards Convenience (Part 1)

The Problem

A Slight Improvement

The Automation Idea

What’s Next?

Publishing my first NPM package only took 3 steps

Learning to code

Starting the project

TL;DR

Installing `gcalcli`