henrym2 / sweng-11 Goto Github PK

We need to setup a react enviroment with typescript

The following example should be enough to get us started

Create react app with typescript

Time estimate: 2 - 3 days

The current basic express app is okay but should be extended to help on boarding and to make sure development is clean

• Expand commenting to describe routes
• Add quality of life packages (Body parser ect)
• Create example files to demo importing
• Create quality of life methods for logging, errors and other basic functions

We need for Microsoft employees to be able to login using their Microsoft credentials. Most likely through OAuth

• Setup Oauth credentials on the Backend
• Modify the Database to accept Oauth credentials

Time estimate: 4 - 5 days? depends on how complex or awkward Oauth gets

Need to write the requirements document for Macu, Due on 4th week of college.

The Stretch goal for the admin page breaks down into a couple of different features. Though its probably work making a quick design for each of them even if we don't actually build each feature.

• Design Main admin panel
• Design FloorPlan and heatmap page
• Design Manual element control flow
• Design Admin Login

This 'Feature' is pretty in flux, we'll only work on the bits we need and theres no huge bother in not getting bits done if we don't decide to do the stretches

Time estimation: 5-6 Days

Prepare requirements presentation for Tuesday the 11th. #1

We need to finalize a document that covers our deliverable to microsoft.
This should include

• What we plan to deliver
• How we plan to deliver it
• When we plan on delivering it
• Priority lists of features

Accessibility is paramount in the construction of any web application. In our case we need to ensure both of the following are met.

• Site can be navigated with keyboard only
• Site can be navigated using a screen reader

These are testable and should be ensured with every release.

The expected sensor data schema must be agreed on. At present I would expect it to look like the following. Please comment any other specification changes. I would imagine that once every minute or once every 5 minutes would suffice.

{
    "id": "String",
    "location": "String",
    "temperature": "Float",
    "time": "timeStamp (String)"
}

Time estimate 1 day

All machines need to have nodejs installed and setup to beginning working on it.

We need to design and declare the information that we plan on providing Maintenance and also how we would describe the request to increase the temperature in a particular location

• Formalize wording of the request
• Decide on the information to provide
• Discover how maintenance currently handles these requests

Time estimate: 1-2 days

Write up a list of what features/functionality should be included in the Admin panel. We'll derive our wireframes and layout from this.

To keep in line with making the system ready for production some form of monitoring, logging and other CI supports should be built.

• Create monitoring system to ensure uptime
• Create logging to keep track of submissions and other actions of the system
• Create Debugging/logging endpoints
• Implement a CI pipeline for deployments

Time estimate: 1 or 2 weeks

We need a basic express app framework setup for the backend
This should include the directory structure.
It must also be committed to github.

Time estimate: 2 days

This route, should take in the user submission from the front end. This should include their name, a timestamp and their "vote" in regards to satisfaction.

• The route will be named /userSubmission
• Satisfaction will be measured on an integer scale
• The route will have the following format for incoming data

{
    "username": "String",
    "satisfaction": "Integer", 
    "time": "TimeStamp (String)"
}

• The route will store user data (In memory) using the username as the key in a dictionary
• At present user data should be overwritten if a new vote is cast

Time estimate 2-3 days

When a user attempts to vote, the backend service will check and see if the user has voted before.
If they have, the service will check to see if that vote was made in a recent timeframe (i.e 1 minute).
One of two things should happen after this check is made,

1. The time between current vote and last vote is > 1 minute, and the users vote is stored. A 200 response is sent along with an acknowledgement response to the fronted. { voted: true }
2. The time between current vote and last vote is < 1 minute, the users vote is not stored. A status 429 response is sent, along with a Retry-after header, this should be handled by an alert on the frontend
   Time estimate: 2 days

(Anything in italics is a change based on customer input)

We need to break down the larger Epics into smaller more sensibly sized tickets that include things like

• Authentication
• Error handling
• Expectations of edge cases
• Design considerations

Setup two routes: /submit and /admin

In our back-end service we need to be able to retrieve, manipulate and store IOT sensor data.

For now we can should probably mock this data from some simple service

• Figure out the format of the data that will come in.
• Retrieve the most up to date sensor information
• Store the sensor information in the database

Time estimate: 4 - 5 days, give or take setup time

We need to be able to tell maintenance that dissatisfaction has reached a critical level and that something needs to change.

• Decide on the "Critical" level before alerting maintenance
• Read X amount of time's worth of user submissions
• Decide on the change that needs to be made
• Send a notification to Maintenance (Email? Microsoft Teams?)

Time estimation: 4 days, give or take Research time required for communication type.

Due 9th March

Create two scripts/tests for mocking API requests:

• Submission request for sending mock user vote data.
• Temperature request for mocking consistent temperature sensor data.

These scripts should be triggerable in the back end for testing completeness of the vote submission and temperature submission routes. The schemas should match what are decided in #34,#32 and #36

The customer wants us to be able to deploy the backend service on Azure for production.

• Investigate how to deploy to Azure
• Deploy service to Azure
• Expose service to the internet

Time estimate: Uh..not sure yet. 2 or 3 days if we get the frontend one done early?

In UserSubmissionPage.tsx, in the login() function, account for error cases - if the input is empty, null, etc. Maybe show an alert if so: "alert('Invalid input');" (this shows an alert to the user in the browser).

We need to, initially, be able to store submissions for individual users. Initially doing so in memory without stateless backups. Using a dictionary in NodeJs would make the most sense.

• We should only store the most recent user submission
• the users name or ID should be used as the reference to the data

Time estimate: 2 days

A complicated frontend system for sure, this will have to be broken out into a few different tickets but we can list some here.

• Pull in dynamic temperature data
• Associate temperature data with given locations on the floor plan
• Accurately display the floorplan
• Dynamically change heat representations as the temperature data changes
• Build some 2 way interactions so temperatures can be changed via the floormap

Prettttttty big feature

Time estimate: 2 and a half weeks, maybe

Draw up some basic mockups for the admin panel. Once approved these will be our blueprints for developing out the UI.

The largest stretch goal. Will need to be broken down again in the future.

• Investigate how to tell elements to change temperature
• Decide on what metrics to use in changing temperature dynamically
• Create interface for changing temperature on specific elements
• Create endpoints for interface
• Build dynamic model for changing temperature based on submissions
• Interface dynamic model with backend

This ticket/Feature is enormous, will definitely need help from clients

time estimation: 3 weeks+

The endpoint, using nodeJS should receive a POST request from the sensors. This post request should contain the data decided on in ticket #31.

• The route will be named /sensorSubmit
• The router will extract the Json information
• For now the information will be stored in memory in a dictionary
• We will use the sensor ID as a reference when storing it

Time estimate: 2-3 days

We need a mechanism on the server side to alert Maintenance. At present this mechanism should send an email to maintenance alerting them that satisfaction has reached a critical mass and that the temperature should be changed. This function would be triggered by the algorithm decided in #33.

• The system will send an email to maintenance (email address stored in a configuration file i.e environment)
• The email should detail:
  • TBD

SendGrid is a potential solution for this issue.

Time estimate: 3-4 days

Need to design the following pages

• Submission page
• Login/Registration page

Microsoft suggested we check out Office UI Fabric

Admittedly for the MVP those two pages could be made into one?

Probably should MockFlow for wireframing? Maybe overkill for the start

Time estimate : 1 or 2 days max

This shouldn't be too hard I imagine, but worth taking the time to figure it out carefully

• Research Azure rate limiting/load balancing features
• Implement infrastructure side rate limiting
• Build interface to track number of user submissions
• Limit user submissions by time
• Send alert on login to user that they have voted too many times in x time
• Log additional attempts after the limit

time estimation: 1 week (give or take)

To prevent over notification of maintenance we should store the last result of the last aggregate of votes. This should then be compared against the most recent results. If they are the same then another notification should (probably) not be sent. To be confirmed with client

Create a bot for Microsoft Teams that will:

• Take votes from users
• Send votes to the API

Time estimate: 2 - 3 days

The backend needs to be able to receive and manipulate submission made by users

• Expose backend service to the internet/localnet
• Make an endpoint that can be POSTed to by the frontend
• Process the inputted user data
• Pass the inputted data to the database
• Endpoint for sensor data

For some quick reading on what an API actually is see WTF is an API

Time estimate: 3-4 days

To ensure that emails are to a high standard and are readable we should build a simple engine for creating emails as opposed to just appending strings. The basics of this should include:

• MailEngine class for interfacing with templates
• Templates for Temperature Change, sensor fails and temperature fails

Linked with #61 #38

Users are going to submit their current satisfaction with the current temperature. How this question is asked should be irrelevant to the general algorithm. It needs to be able to do the following.

• Retrieve the user records from where they're stored (Memory for now)
• Combine the satisfaction values to get an average or total across all users
• Decide on the "critical mass" required before alerting maintenance
• Trigger the maintenance alert and provide it with some detail about the vote (handled by #38)

Time estimate 2-3 days

If we're going to display data on a heatmap we're going to need a sensible way to supply it

• Investigate how to associate locations with temperature data
• Modify data models to include locations with temperature data
• Ensure database can handle new data changes
• Provide fronted with location specific temperature data

Time estimate: 1 and a half weeks (give or take)

Related to #14

Build out the submission page which will

• Ask the user for their name, location and office climate preferences.
• Send the submission to the database
• Potentially display current average temperature of the office

Time estimate: 4-5 days, factoring in setup time

Blocked by #3

As per client requirements, the product needs to be deploy-able on Azure cloud services.
We need to

• Research Azure cloud
• Create a resource group and box for hosting the front-end
• Expose the front-end on the internet
• Look into continuous integration

Time estimate: 3-4 days

If we're using Oauth we need to have a new login or submission page.

• Design Login page
• Implement Oauth on the login page
• Ensure the backend gets the correct credentials submitted from the frontned

Time estimate: 4 -5 days, depending on Oauth difficulties and testing with the backend