added exercises

Author: CodeBrew28

README.md

@@ -1,4 +1,4 @@
-# Flask Routes
+# Flask Take Home Exercises
 
 This creates an application instance
 __name__ is used to determine the root path of the application folder
@@ -22,43 +22,38 @@ def my_first_route():
 	return "<h1> Hello World! </h1>"
 ```
 You can have multiple routes. So for instance, the code below would run on http://127.0.0.1:5000/route/aria,
-"aria" in this case is the parameter name, which can be anything you want. This is taken asn a input into the function my_second_route, and then the name is printed to the screen. 
+"aria" in this case is the parameter name, which can be anything you want. This is taken as an a input into the function my_second_route, and then the name is printed to the screen. 
 
 ```python
 @app.route('/route/<name>')
 def my_second_route(name):
      return name
 ```
 
-**Problem 1: Write a route that takes a first name, last name, and graduating year in the route**
+**Problem 1**
+**Write a route that takes a first name, last name, and graduating year in the route. If this route is hit, wit print out the line "<firstname> <lastname> will graduate in <graudating_year>"**
 
 
-So, what are we using Flask for and why are routes useful. 
+So, what are we using Flask for and why are routes useful ... to build at API.
 
 An API, or Application Programming Interface, is a set of subroutine definitions, protocols, and tools for building application software. It defines communication between various software components. 
 
 Lets give an example. Let's say on the frontend you want to display all a list of names that are stored in your database. You are going to send a GET request that will be sent to one of these routes that you define in Flask. The function to handle the route will understand that you are trying to get some information, retrieve it from the database, and set in back to the frontend in a json format. 
 
-```python
-@app.route('/get_users', methods=['GET'])
-def get_all_users():
-    if request.method == 'GET':
-    # Accesses the database and gets a list of names stored in the variable called data 
-	# (ignore how you access the database for now, we'll come back to it)
-	    return jsonify({'status': 'success', 'data':  ['aria', 'tim', 'varun', 'alex']})
-    else:
-        return jsonify({"status": "failed")
-```
 
 The GET request is part of a protocol called REST, which stands for Representational State Transfer. 
 
 There are many types of requests, put the most important ones are: 
-	GET: gets information from a database
-	POST: adds information to a database
-	PUT: modifies information in a database
-	DELETE: deletes information in a database
 
-From the nnb project, you can see an example of a get request that uses postgress database. Maps.query.all() goes into postgress, finds the table labeled Maps, and gets everything. The data is then put into a list and turned into a json object. If it fails, it will send the correct error message
+GET: gets information from a database
+
+POST: adds information to a database
+
+PUT: modifies information in a database
+
+DELETE: deletes information in a database
+
+From the nnb project from last semester, you can see an example of a get request that uses postgress database. Maps.query.all() goes into postgress, finds the table labeled Maps, and gets everything. The data is then put into a list and turned into a json object. If it fails, it will send the correct error message
 ```python
 #Gets all maps
 @app.route('/maps', methods=['GET'])
@@ -73,11 +68,71 @@ def getallyears():
         return jsonify({"status": "failed", "message": "Endpoint, /years, needs a GET request"})
 ```
 
+Here's a POST request example from the same project 
+```python
+#Add a map
+@app.route('/maps', methods=['POST'])
+# @login_required
+def addmapforyear():
+    if request.method == 'POST':
+        try:
+            json_dict = json.loads(request.data)
+            result = Maps(
+                image_url = json_dict['image_url'],
+                year = (int)(json_dict['year'])
+            )
+            db.session.add(result)
+            db.session.commit()
+            return jsonify({"status": "success", "message": "successfully added maps and year"})
+        except Exception as ex:
+            raise InvalidUsage('Error: ' + str(ex), status_code=404)
+    else:
+        return jsonify({"status": "failed", "message": "Endpoint, /maps, needs a GET or POST request"})
+```
+
 Everything that I described above is what you're going to be working on in the Flask backend. This means figuring out how to design your database, and then define the API to make changes in your database. 
 
-**Problem 2: Download Postman, go to the url for get_all_users, and set a GET request. If you make the wrong type of request, you will get an error message**
 
-Setting up the database and defining it is alot of work, so we'll leave that for your tech leads to teach you :P 
-For now, we're going to try actually using a public API to get more familair with it.
 
-**Problem 3: Write an endpoint that will take an input, search for that term on wikipeida using the API, and then return back a list of titles of the top matches**
+**Problem 2:**
+
+**So instead of making you guys actually use a database, simply make an array called *users* thats global in your app.py file. Each element in the array is a user with a id, name, and age**
+
+For example 
+```json
+
+   users = [
+       {
+            "id": 1,
+            "name": "Aria", 
+            "age": 19
+       }, 
+        {
+            "id": 2,
+            "name": "Tim", 
+            "age": 20
+        }, 
+        {
+            "id": 1,
+            "name": "Varun", 
+            "age": 23
+        }, 
+        {
+            "id": 1,
+            "name": "Alex", 
+            "age": 24
+        } 
+   ] 
+```
+
+**Then create a route for /get_all_users that will receive a GET request and return the list of all current users in a json format. It will return an error message for everything other than a GET request.**
+
+**Next create a route called /add_user that will receieve a POST request. Inside the request data there will be a user with an id, name, and age. The function will take the request data and add a new user to the globale list of users. Also, add appropriate sucess/error responses in a json format.**
+
+**Next create a route called /modify_user that will receieve a PUT request. In the request data have an id so they know which user is being modified, and then have a new name or age for the user. In the function, edit the user with that id in the global list of users. Also, add appropriate sucess/error responses in a json format.**
+
+**Next create a route called /delete_user that will receieve a DELETE request and a name. The request data will have an id,and then that user is deleted from teh global array. Also, add appropriate sucess/error responses in a json format.**
+
+**To test everything, download postman and make requests**
+
+Setting up the database and defining it is alot of work, so we'll leave that for your tech leads to teach you. Also, for the course of this intro project, we're doing everything in app.py. In your projects though, you are going to organize the endpoints into different files, have a folder to define the models, and other files for the database connection. 

app.py

@@ -17,5 +17,6 @@ def get_all_users():
 	    return jsonify({'status': 'success', 'data':  ['aria', 'tim', 'varun', 'alex']})
     else:
         return jsonify({"status": "failed")
+        
 if __name__ == '__main__':
 	app.run(debug=True)