Input/Output requests. Demo ways to Input to your full stack feature.

  • Using frontend show API request and present API response. (live demo)
    Image
  • Using postman to show raw API request and RESTful response (error code(s) and JSON)
    Image
    Image
    Image
  • Using db_init, db_restore, db_backup to show tester data creation and data recovery.
    Image
    Image

List requests. Use of list, dictionaries and database. Code descriptions of area where you work with list (rows) and dictionaries (columns) of the database.

Image

  • Discuss formatting response data (JSON) from API into DOM
    Image
    frontend: DOM
    Image
  • Discuss queries from database where you extract a Python List (rows). Mention how these queries are provide by a 3rd. party library.
    Image
  • Discuss methods in “class” you created to work with columns (create, read, update, delete) create:
    Image read:
    Image update:
    Image delete:
    Image

Algorithmic code request. Show the definition of code blocks to handle a request.

  • Discuss API class (code block) you used to perform get, post, put, and delete methods.
    Image
    Image
  • Discuss a method/procedure in class that contains sequencing, selection, and iteration.
    Image
  • Discuss the parameters (body of request) and return type (jasonify) of the function.
    Image

Call to Algorithm request. Show the definition of code block to make a request.

  • Discuss the call/request to the method with Algorithm (fetch to endpoint).
    Image
    Defines groupName as ‘Culinary Posts’, which is the name of the group of channels being requested. responseData is an object that includes the group_name field, which will be sent in the request body.

  • Discuss the return/response from the method with Algorithm (fetch) and how you handle data.
    The fetch() function sends an HTTP request to the backend. The request method is POST, meaning data is sent to the server. The body is converted into JSON format (JSON.stringify(responseData)).
    fetching data: The function sends { group_name: ‘Culinary Posts’ } to the API. After Fetching (Output from API) The API returns an array of objects, each representing a channel:

  • Show how changing data or method triggers a different response, specifically normal conditions and error conditions.

Purpose of Individual Feature

  • This is what the flowchart begun: Image
  • This is a screenshot of the current flowchart of the tables I have been working on Image
  • In this screenshot you can see that I organized all of the countries to be connected to the groups.py
  • I noticed that all of our postings on our review pages would only show up in our channel table in the backend, so I followed the flowchart to see which tables it was connected to
  • I found that the Channel table was also the only table connected to the posts.py, so I follwed those tables to find code that would connect the countries to the posts.py
  • I successfully connected the nigerias table to the posts table, which I think is a step forward to my end goal

Areas to work on / Burn down list

  • Connect the rest of the countries to the posts table (Use same code as nigerias)
  • Allow the backend to connect to the frontend
  • Once the backend is connected to the frontend, have the frontend show the review on our website
  • Get rid of failed to fetch error
  • Here is a screenshot of my latest burndown list: Image

Purpose of Groups Program

Input/Output:

  • Posting feature for API Request and response
  • to show the RESTful API, we can plug in a URL into Postman (ex: http://127.0.0.1:8887/api/food), which then displays all the information under the “food” class of our code under our maps.
  • We created various table in SQLite using the CRUD method. The following commands allow us to creat, save, and remake the tables. (db_init, db_restore, db_backup). First we run db_init to make, db_backup to save the table, and db_restore to re make. List Requests:
  • About me Page: Each of the names and role assignments are our basic JSON data, which we then convert into API by attatching it to the API URL. By then attatching this URL to the frontend, it shows up as a part of our UI.
  • Working with columns was done by using the CRUD method, as well as making different classses. For example, in our About Me Page, every memeber in our group has their own defined class. When displayed in the frontent, these classes will show up as their own induvidual columns. Algorithmic Code Requests:
  • Staying on our About Me Page, we have a seperate code in our Frontend that specifies the method of GET, PULL, POST, or etc. Because of the specifies path, the URL then gets fetched and displayed on our website.
    • Therefore, we have created our body of request in the backend which them shows up as a jasonify-ed version of our data in the frontend
    • This process of code is also know as Iteration, because of how we looped the information of everyone in this group. Call to Algorithm Request:
  • Call and Requesting through Postman can be done by adding a breakpoint. The error that Postman gives us after adding the breakpoint, and then the debugging process shows how we handle data.
  • Changing the data within our backend files immediatley affects other things. For example, in our code that creates SQLite tables, we can easily edit our tester data. When we remake the table, it will display with new information, ass a result of the changed data.

Group’s Plan

  • As a group we worked together to get our posting in our review page for our countries to work from backend to frontend.
  • A function that we added was changing the group name for asia to japan when posting a review, which organizes our posts into categories
  • This image shows how when we type in our review (Restarunt Name, Stars, and Description) it runs through our backed and is shown on our website through our frontend Image
  • This image shows our table in our bakend that stores the data of our review Image