1 Overview

In this MP you will both build and use web service APIs. In particular,

• You’ll build a microservice that reports the weather of the next meeting of a given course
  • It will respond to POST requests with path /weather and one request body field, course
  • It will respond to GET requests with path /weatherCache
• You’ll use a microservice we provide that reports meeting times of a given course
  • It has a less-permissive course identification form than your service will have
  • You’ll need to figure out the date of the next meeting
• You’ll use the National Weather Service API to find the weather at a given time
  • This API uses request caps to prevent it being overrun with requests, so you will cache results to disk to avoid over-querying the API during testing

The code comes with a simple web front-end that lets you interact with your completed service through your web browser.

2 Initial Files

In your CS 340 directory, merge the initial starting files with the following commands:

git fetch release
git merge release/mp7 --allow-unrelated-histories -m "Merging initial files"

3 Courses Microservice

We have fully implemented a course meeting time microservice for you. You can find it in the courses_microservice directory. This, like the microservice you will implement, uses flask to automate many of the tedious parts of running a webserver.

Running on http://127.0.0.1:34000/ (Press CTRL+C to quit)

{
  "course": "CS 340",
  "Days of Week": "TR",
  "Start Time": "12:30 PM"
}

{
  "course": "CS 300",
  "error": "No course data available for CS 300"
}

4 Machine Problem

Your task for this MP is to complete the flask app.py route for POST /weather that will respond with the weather forecast for the next meeting of the class provided in the request. Specifically:

• Accept course identification in the form submission field course.

• Accept course identification in several forms (CS 340, cs340, or other such combinations). You may assume it is an all-alphabetic course mnemonic followed by a 3-digit course number.

• Use the provided courses_microservice via web API requests to get the course meeting days and time.

  You must use the environmental variable COURSES_MICROSERVICE_URL to find the location of the courses_microservice.

  • You can find COURSES_MICROSERVICE_URL via the following Python code:

    server_url = os.getenv('COURSES_MICROSERVICE_URL')

  • The value of this variable will be http://127.0.0.1:34000 (no trailing slash).

• Use the National Weather Service API to get the weather forecast https://www.weather.gov/documentation/services-web-api.

• Cache calls to the National Weather Service API. In particular, if I ask for the same course twice in a row the second must not contact the API, instead remembering how to answer the query without that.

• Use (40.11,-88.24) as the GPS coordinates for all locations.

• Get the forecast for the specific hour when the course begins to meet (not the high temperature for the day).

  You will need to write logic to calculate the next course meeting relative to the current datetime. The Python command datetime.now() will provide you with a datetime object with the current time.

  • You should NOT account for holidays, the end of semester, spring break, or anything else.
  • That means you should always assume the next course meeting is the next datetime that occurs after the current datetime when the course would meet.

• Use the requests library to make a request to the API.

• You must report the data back in a response JSON with the following structure with a 200 response:

  {
    "course": "CS 340",
    "nextCourseMeeting": "2022-10-25 02:00:00",
    "forecastTime": "2022-10-25 02:00:00",
    "temperature": 60,
    "shortForecast": "Mostly Sunny"
  }

• Due to limitations of the weather API, hourly forecast information is only available up to 156 hours (6.5 days) in the future. To address this, if a course’s next meeting time is more than 144 hours (6 days) in the future, you must set the "temperature" and "shortForecast" items to the string "forecast unavailable":

  {
    "course": "CS 340",
    "nextCourseMeeting": "2022-10-19 02:00:00",
    "forecastTime": "2022-10-19 02:00:00",
    "temperature": "forecast unavailable",
    "shortForecast": "forecast unavailable"
  }

• On any other sort of error (ex: when the course cannot be found), respond with a 400 response and a JSON object containing the key "error" and a message describing what went wrong.

Additionally, complete the flask app.py route for GET /weatherCache to return a JSON representation of your cache. Specifically,

• If the cache is empty, return {}.

• If the cache is not empty, return JSON that includes at least enough information to handle repeat queries without contacting the weather service API. This must include the temperature and short forecast from every previous request, but will likely include more than that.

5 Testing Your Application

A frontend has been provided for you to test your web application. To run your service, you must do three things in three different windows:

• In one terminal, launch the courses_microservice from the courses_microservice directory.
• In a second terminal, launch your mp7 microservice from the mp7 directory.
• Finally, on a browser, connect to http://127.0.0.1:5000/ to view your app!

6 Submission

Once you have locally passed all the tests, you will need to submit and grade your code. First commit using the standard git commands:

git add -A
git commit -m "MP submission"
git push