This is a title slide for "Flask CRUD Operations." The subtitle notes it uses hardcoded user data without a database.

Flask CRUD Operations

Using Hardcoded User Data (No Database)

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

The slide "What is CRUD?" features a table outlining the four core database operations and their HTTP methods. It lists Create (POST: Add new data), Read (GET: Fetch existing data), Update (PUT: Modify existing data), and Delete (DELETE: Remove data).

What is CRUD?

{ "headers": [ "Operation", "HTTP Method", "Meaning" ], "rows": [ [ "Create", "POST", "Add new data" ], [ "Read", "GET", "Fetch existing data" ], [ "Update", "PUT", "Modify existing data" ], [ "Delete", "DELETE", "Remove data" ] ] }

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

The slide displays hardcoded user data as a Python list of two dictionaries, each containing a user's ID, email, password, and age. It outlines key characteristics: a list of dictionaries serving as an in-memory data store, with data lost on server restart.

User Data (Hardcoded Data Source)

| users = [ {"id": 1, "email": "a@test.com", "password": "1234", "age": 20}, {"id": 2, "email": "b@test.com", "password": "abcd", "age": 22} ] | • List of dictionaries

• In-memory data store
• Each dictionary represents one user
• Data lost on server restart |

The slide "User Data Structure Explained" features a table listing key user data fields, their types, and descriptions. It covers id (Integer: unique identifier), email (String: user email), password (String: plain text), and age (Integer: user age).

User Data Structure Explained

{ "headers": [ "Field", "Type", "Description" ], "rows": [ [ "id", "Integer", "Unique identifier" ], [ "email", "String", "User email" ], [ "password", "String", "User password (plain text)" ], [ "age", "Integer", "User age" ] ] }

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

The slide "Flask Application Setup" features basic setup code on the left, importing Flask, request, and jsonify while creating an app instance with app = Flask(name). On the right, it explains key components: Flask as the core class, request for reading client data, jsonify for Python-to-JSON conversion, and app as the WSGI object.

Flask Application Setup

| from flask import Flask, request, jsonify

app = Flask(name) | • Flask: Core class

• request: Reads client data
• jsonify: Python to JSON
• app: WSGI app object |

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

The slide shows Flask route code for the "/users" GET endpoint, which returns a JSON list of all users with a 200 OK status code. The technical explanation notes it fetches hardcoded user records from an in-memory list and responds in JSON format.

GET All Users (READ)

| @app.route("/users", methods=["GET"]) def get_users(): return jsonify(users), 200 | • Endpoint: /users

• GET method
• Returns JSON list of all users
• 200 OK status code

Fetches all hardcoded user records from the in-memory list and responds with JSON. |

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

The slide presents Flask code for a GET /users/<int:userid> route that searches a hardcoded users list by ID, returning the matching user as JSON (200 OK) or a "not found" message (404). Its technical explanation highlights URL parameter capture, list iteration for matches, and the simplicity of this READ operation on static data.

GET User by ID (READ)

| @app.route("/users/<int:userid>", methods=["GET"]) def getuser(userid): for user in users: if user["id"] == userid: return jsonify(user), 200 return jsonify({"message": "User not found"}), 404 | • URL param: <int:userid> captures ID from path

• Iterates users list to find match
• Returns user JSON (200 OK) or error (404 Not Found)

Simple READ operation on hardcoded data. |

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

The slide presents Flask route code for a POST /users endpoint that reads JSON input, generates an incremental user ID, appends the new user to an in-memory list, and returns a 201 response with the user data. The right column explains key aspects: POST method, JSON body parsing, ID generation, list append, and 201 Created status with user details.

POST Create User (CREATE)

| @app.route("/users", methods=["POST"]) def createuser(): data = request.json newuser = { "id": users[-1]["id"] + 1 if users else 1, "email": data["email"], "password": data["password"], "age": data["age"] } users.append(newuser) return jsonify({"message": "User created", "user": newuser}), 201 | • HTTP Method: POST

• Reads JSON body from client
• Generates unique ID incrementally
• Appends new user to in-memory list
• Returns 201 Created status with new user data

(20 words) |

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

The slide presents Flask code for a PUT route /users/<int:userid> that partially updates a user's email, password, and age from JSON data, preserving old values if unspecified, and returns the updated user (200 OK) or 404 if not found. The right column explains its use of HTTP PUT for efficient partial updates on existing users, ideal for modifying specific fields without full data resends.

PUT Update User (UPDATE)

| @app.route("/users/<int:userid>", methods=["PUT"]) def updateuser(userid): data = request.json for user in users: if user["id"] == user_id: user["email"] = data.get("email", user["email"]) user["password"] = data.get("password", user["password"]) user["age"] = data.get("age", user["age"]) return jsonify({"message": "User updated", "user": user}), 200 return jsonify({"message": "User not found"}), 404 | • HTTP Method: PUT

• Updates existing user data
• data.get() preserves old values if not provided
• Supports partial updates
• Returns updated user and 200 OK
• 404 if user not found

Ideal for modifying specific fields without resending all data. |

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

The slide shows Flask route code for a DELETE /users/<int:userid> endpoint that removes a matching user from an in-memory list and returns a 200 response. Key features include in-memory deletion and 200 confirmation.

DELETE User (DELETE)

| @app.route("/users/<int:userid>", methods=["DELETE"]) def deleteuser(userid): for user in users: if user["id"] == user_id: users.remove(user) return jsonify(...), 200 | • In-memory delete

• 200 confirmation |

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

The slide outlines the Flask request-response workflow: a client sends an HTTP request, which Flask routes by matching URL and method, executes the target function with extracted parameters, and runs business logic on a hardcoded users list. A JSON response with appropriate status codes (e.g., 200, 404) is then generated and returned.

Request & Response Flow

{ "headers": [ "Step", "Action", "Details" ], "rows": [ [ "1. Client HTTP request", "Client sends HTTP request", "Includes URL, method (GET/POST/etc.), headers, and optional body data" ], [ "2. Flask matches URL+method", "Flask router processes request", "Matches URL path and HTTP method to registered route decorator" ], [ "3. Route executes", "Target route function is called", "Parameters (e.g., <int:user_id>) are extracted and passed" ], [ "4. Business logic", "Core application logic runs", "Performs CRUD operations on hardcoded users list" ], [ "5. JSON response + status codes", "Response generated and sent", "jsonify() converts data to JSON; appropriate HTTP status (200, 201, 404, etc.) returned" ] ] }

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

Hardcoded data lacks persistence, losing all information on server restarts, and provides no authentication mechanisms. It also stores plain text passwords, rendering it highly insecure and unsuitable for production use.

Limitations of Hardcoded Data

• ❌ No persistence: data lost on server restarts
• ❌ No authentication mechanisms
• ❌ Plain text passwords (highly insecure)
• ❌ Not suitable for production use

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

The slide "What Comes Next?" outlines the next development steps for the project. These include migrating data to SQLAlchemy and a database, adding password hashing, implementing JWT authentication, and incorporating input validation.

What Comes Next?

• Move data to SQLAlchemy + Database
• Add password hashing
• Add JWT authentication
• Add input validation

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)

The summary slide highlights mastered Flask basics: CRUD operations, Flask routing, HTTP methods, and REST API structure. It encourages practicing by building your own API next.

Summary

✔ CRUD operations ✔ Flask routing ✔ HTTP methods ✔ REST API structure

Mastered Flask basics! Practice building your own API next.

Source: Flask CRUD Operations Using Hardcoded User Data (No Database)