Project

---

Overview

The project for this course is to build a web application for a blog. You will be designing and implementing your own REST API along with creating a web application front-end. The application need to enable users to log in and out and post blog entries.

The theme of the blog is open for you to decide. For example, you can dedicate it to sports, recipes, games, fashion, etc.

The database schema support posts and users. See the following descriptions.

The user table

				                      Table "public.blog_user"
  Column  |          Type          | Collation | Nullable | Default
----------+------------------------+-----------+----------+---------
 id       | integer                |           | not null |
 username | character varying(256) |           | not null |
 password | text                   |           |          |
Indexes:
    "blog_user_pkey" PRIMARY KEY, btree (id)
Referenced by:
    TABLE "blog_comment" CONSTRAINT "blog_comment_user_id_fkey" FOREIGN KEY (user_id) REFERENCES blog_user(id)
    TABLE "post" CONSTRAINT "post_user_id_fkey" FOREIGN KEY (user_id) REFERENCES blog_user(id)

The post table

				                 Table "public.post"
  Column   |  Type   | Collation | Nullable | Default
-----------+---------+-----------+----------+---------
 id        | integer |           | not null |
 user_id   | integer |           | not null |
 post_date | date    |           | not null |
 post_text | text    |           | not null |
 extra     | json    |           | not null |
Indexes:
    "post_pkey" PRIMARY KEY, btree (id)
Foreign-key constraints:
    "post_user_id_fkey" FOREIGN KEY (user_id) REFERENCES blog_user(id)
Referenced by:
    TABLE "blog_comment" CONSTRAINT "blog_comment_post_id_fkey" FOREIGN KEY (post_id) REFERENCES post(id)

Out of the table definitions, the most interesting thing is the extra column in the post table. The column stores JSON data which allows you to store whatever additional structured data per post that you want. For example, if this was a recipe blog, storing the ingredients and instructions in the extra column. For a chocolate chip cookie recipe, the entry might look like this:

{"ingredients":["1 cup of butter", "1 cup of brown sugar", "1/2 cup of sugar", "3/4 teaspoon of baking soda", "1/2 teaspoon of salt", "2 eggs", "1 teaspoon of vanilla", "2 1/2 cups of flour", "1 pack of chocolate chips"], "instructions":"Pre-heat the oven to 375. Mix the butter, sugar, salt, baking soda and other wet ingredients. Mix in one cup of flour at a time until all of it is included. Mix in chocolate chips. Scoop up balls of cookie dough and place on a cookie sheet and bake for 8 to 10 minutes."}

Think creatively about what you may store in this column. At the very least, the information you store here could be displayed specially on the blog. Again, this column can be used for whatever you like, just make sure it fits with the theme of your application.

Requirements

The projects has two halves: the REST API backend and the web application front-end. For this project, you must both design and implement the REST API along with a web application that uses the API.

REST API

The REST API needs to support the at least following:

• Login and logout for users
• CRUD operations for blog posts

The API needs to support the additional fields stored in the JSON column of the post table. Also the API must be well documented in your project's README.MD file.

Front End

The front-end needs to support at least the following:

• An "landing" page that shows the most recent post from every user
• Page(s) to log in and sign up.
• A page to search by user and see all their blog posts.
• Page(s) for a user to create, delete or update their posts.

The site must also run smoothly and look nice. It should be intuitive to navigate and use. Also, you need to error check and validate user input and interactions and present sensible error messages for bad inputs.

Milestones

The project will be broken into a series of milestones.

Milestone 1

This milestone has two major components:

1. A prototype of the frontend
2. A "stubbed-out" backend

For the front-end prototype, you need to create a landing page, a page or pages to create, update, and delete blog posts, and a page to search for and view blog posts by user. These pages need to make requests to a "stubbed-out" backend, be navigable, and styled with CSS.

The backend needs to be defined and documented in the README.md and be able to provide hard-coded fake data upon request. That is, the backend needs to be functional enough to allow the frontend to make requests and receive data. It does not need to use the database, validate user data, or authenticate the user.

Commit your code to branch m1 to turn in this milestone. After the due date, be sure to not commit any more changes to this branch, move onto the next milestone's branch!

Milestone 2

This milestone will have two components as well:

1. Completing the CRUD functionality for blog posts
2. Ensuring that your UI uses the API

In theory the second point should be straight forward since it already works the stubbed out API. However, you may need to alter the definition of your API or your UI as you integrated it with the backend. Be sure to note changes to your API along with providing accurate documentation in your README.md.

Commit your code to branch m2 to turn in this milestone. After the due date, be sure to not commit any more changes to this branch, move onto the next milestone's branch!

Milestone 3

This milestone will consist of:

1. Completing the authentication API
2. Adding authentication verification to the blog post API
3. Completing the page(s) sign-in and sign up.

Also this includes fixing any bugs and/or finishing up anything else that needs to be done to complete the project.

Commit your code to branch m3 to turn in this milestone.

1. GFU
2. CSIS
3. J. Walker Orr
4. CSIS 314
5. Environment