david-fisher / 320-f20-track-ii

track 2's repo

320-F20-Track-II

Track 2 Repo: https://github.com/david-fisher/320-F20-Track-II

Track 4 Repo: https://github.com/david-fisher/320-F20-Track-IV

Differential Team database: how to build

1. Install postgreSQL:
   https://www.postgresql.org/download/

2. Add PostgreSQL/[version, either 12 or 13]/bin and PostgreSQL/[version, either 12 or 13]/lib to PATH (on Windows) or make it an environment variable on Mac/Linux

3. in command prompt or terminal, call psql -U postgres -f [full filepath to database_setup.sql]. note: The file database_setup.sql can currently be found in the erd-implementation branch in the database folder.

how to connect to database from react.js

1. run npm install all within the directory containing package.json to install all dependencies for the pg package, which is the library used to communicate between the PostgreSQL database and the react.js app, as well as all other dependencies outlined in the package_lock.json file

2. In goon-universe, the app can be run with node app.js.

3. Using the functions outlined in queries.js, which implements the REST API enumerated in app.js, frontend teams can now interact with the database from their React.js app as usual.

4. Worth noting: the pg package's use depends on certain user credentials used to access a common database (namely, the username/password for the postgresql database which you've set up using database_setup.sql). Since the git repository is public, it's a security risk to store these credentials in public on the clear web. Thus, we are using a .env file (locally, for now) to store these credentials. You will not be able to access the database from the React app without a properly configured .env file!

how to run the frontend react app

1. Install Node.js:
   https://nodejs.org/en/download/

2. Go into the folder frontend in the command line.

3. Run npm install in the command line to install all dependencies required to run the app.

4. Run npm start in the command line to start the app.

For testing: populating the database with dummy data

1. in command prompt or terminal, run psql -U [user] -f [full filepath to insert_example_data.sql]. This file can currently be found in the erd-implementation branch in the database directory.

320-f20-track-ii's Issues

Student view analysis (“Consequences”, “Final Reflection” and “Conclusion”)

Implement back-end (database) component

Your team is responsible for the database of the scenario player.
In your implementation, you will need to coordinate with the other back-end team on your track. Please work together to decide what the stack of the scenario player will be.
You will also need to coordinate with Track IV, who will make the corresponding
scenario editor.

Finalize tech stack

Test issue. Create something

-step1
-step2

complete user story

Instructor scenario create

Student receives the project task and responds to initial questions

Student View Analysis and Instructor Login Acceptance Test

basic outline for database schema

Create a rough sketch of our potential database schema

• Database schema for scenarios (coordinate with Track IV)
• Database schema for scenario responses

Coordinate with Track IV to decide on a database and a schema

We (Differential Team) decided on PostgreSQL, while other teams may have decided on something different. Agreement needs to be reached on the following:

• Decide on a database program to use (PostgreSQL)
• Decide on a database schema for storing scenarios
• Decide on a database schema for storing scenario results (so that the editor team can present these results to scenario creators)

Download node and postgres

Review goonuniverse's document

Anastasia - User
Satwik - Instructor

Student Login

Add Table of Content

Implement Scenario Player Backend

This should be integrated with the other teams on your track (front end and database) and the editor team (track 4)

implement Router to other pages

Create draft of "issue coverage" page

Results/ Selecting stakeholders mockups

Instructor login

Discuss performance and FERPA compliance and add to document

Find node tutorial

go over reviews in our documentation

implement radar plot using chartjs

Create your team wiki page

Revise and add userstories. Pick 1 -2 comments to fix in either David or Dasha's comments, ping in slack when fixed before next meeting on Saturday

Add mockups to user stories document

Mock Up for Scenario Delete

Radar Plot with actual data/add variables

Instructor check student results

Instructor view as a student

Add Stepper

Define security non-functional requirements

Discuss non-functional requirements with customer

Implement the scenario player frontend

This will be your goal for throughout the semester. Track 4 will be creating the editor. Be sure to break this up into smaller issues as stories get finished. This likely will be the last issue you move to 'done'!

Add 2 new student/player stories to user stories document

“Middle reflection” and “Final Action”

Follow the tutorial on using MySQL with node.js and the MySQL js client https://www.sitepoint.com/using-node-mysql-javascript-client/

Elaborate on non functional requirements in user story document

Instructor scenario edit

Create ER diagram for database schema

• Add 'users' table to ERD
• Add 'students' table to ERD
• Add 'instructors' table to ERD
• Add 'courses table to ERD
• Add 'scenarios' table to ERD
• Add 'stakeholders table to ERD
• Add tables for pages to ERD
• Add MCQ questions and options tables to ERD
• Add MCQ responses table to ERD
• Add stakeholder choices table to ERD

Presentation Student View Analysis Content

Set up mock postgres server

Create draft of progress indicator/table of contents

Presentation Theme

Investigate FERPA compliance requirements

Instructor scenario delete

Acceptance Test for instructor scenario edit and instructor check student result

Add the text box, nav buttons, and title to "issue coverage" draft

Students picking stakeholders

Add potential library to use to create the graphs/radar plots to user stories document

Student interacting with stakeholders

Draft the information gathered component