7.   Development Tools

7.1    Jupyter Notebook

We will combine coding experience with written explanations for teaching purposes. The tool we're using is Jupyter Notebook, which allows us to mix code, output, and markdown text in a single document. (However, there are several options for creating this kind of interactive teaching material, including Visual Studio Code with Jupyter extension.)  Here is the features of Jupyter Notebooks:

o Uses: Python, R, and many other languages

o Good for: Interactive coding, data analysis, and explanations

o How to use: Install Jupyter, create a new notebook, alternate between code cells and markdown cells

Our workflow:

1.      Open VS Code with Jupyter extension

2.      Create a new .ipynb file

3.      Add a markdown cell for introduction:

markdown

# Introduction to AI Programming

In this lesson, we'll cover the basics of setting up a Flask application for AI-driven recommendations.

4.      Add a code cell with our Python code

5.      Add another markdown cell explaining the code

6.      Continue alternating between explanations and code

This approach allows us to create interactive, editable content locally. When we're ready to publish, we can either use the notebook directly (if our platform supports it) or export to a more widely shareable format like HTML or PDF.

7.2    Combining Free Tabnine and Free ChatGPT

Combing free ChatGPT and free Tabnine (+free Mistral) in terms of their software development and debugging capabilities seems the best strategy.  Using ChatGPT or other LLMs for discussing software requirements and design allows for a more conversational and detailed exchange, with the ability to reference past discussions. On the other hand, IDE AI tool Tabnine excel in assisting with real-time coding and testing within the development environment but lack the capability to maintain a long-term conversation history.

By combining both tools, we can leverage the strengths of each: using LLMs for planning, designing, and understanding your project while utilizing IDE AI tools for specific coding tasks and quick assistance during development. This dual approach can help streamline our workflow and ensure that you are both well-prepared in the planning phase and efficient in the implementation phase.

Tabnine's focus on privacy and security, especially when combined with models like Mistral, is a significant selling point for industries where protecting intellectual property and sensitive information is crucial, such as in banking, defense, and manufacturing. These industries often handle confidential data and require AI tools that can perform effectively without compromising security.

Using both ChatGPT (or other LLMs) and tools like Tabnine is a practical strategy. ChatGPT excels in understanding and discussing complex requirements and design, while Tabnine, with its privacy features and performance optimizations, is well-suited for coding assistance within the constraints of secure environments. This combination allows you to leverage the strengths of each tool, ensuring both efficiency and security in your software development process.

7.3    Development phases

We're looking to prioritize and phase the implementation, starting with a minimum-function prototype. This approach aligns well with the Minimum Viable Product (MVP) concept, allowing us to test core functionalities quickly and iterate based on user feedback. Let's break this down into phases:

Phase 1: Minimum-Function Prototype (MVP)

Focus: Core functionality with a simplified architecture

1.      Cloud-Based Core Services:

o Basic user authentication and profiles

o Simple job/course listing service

o Rudimentary matching algorithm

2.      Web-Based Frontend:

o Responsive design for basic mobile access

o Simple user interface for browsing and applying/enrolling

3.      Basic API Layer:

o RESTful endpoints for core functions

4.      Data Storage:

o Centralized database (e.g., PostgreSQL)

5.      Minimal AI Integration:

o Basic keyword matching for job/course recommendations

Priority Features:

·         User registration and login

·         Job/course listing and search

·         Simple profile creation

·         Basic recommendation system

Phase 2: Enhanced Personalization and AI

1.      Improved AI Services:

o Implement more advanced NLP for content analysis

o Enhance recommendation engine with machine learning

2.      User Feedback Mechanism:

o Collect and store user interactions and ratings

3.      Content Generation:

o Basic AI-assisted content creation (e.g., job description summaries)

4.      Mobile App Development:

o Basic native app for improved mobile experience

5.      Analytics Integration:

o Implement basic usage analytics

Phase 3: Advanced Features and Edge Computing

1.      Edge Computing Integration:

o Develop edge computing capabilities for faster, offline-capable experience

o Implement sync mechanism between edge and cloud

2.      Enhanced Personalization:

o Utilize edge computing for real-time personalization

o Implement more sophisticated AI models

3.      Expanded Mobile Capabilities:

o Full-featured mobile app with offline functionality

4.      Advanced Analytics:

o Implement comprehensive user behavior analytics

Phase 4: Decentralization and Web3 Features

1.      Decentralized Data Storage and Federated Learning:

o Begin migrating some user data to Federated Learning and decentralized storage

2.      Blockchain Integration:

o Implement basic blockchain features (e.g., for verifiable credentials)

3.      Smart Contracts:

o Implement basic smart contracts for automated processes

4.      Token System:

o Introduce a basic token economy for incentives

Phase 5: Full Web3 and Advanced AI Integration

1.      Fully Decentralized Architecture:

o Complete transition to a decentralized data model where appropriate

2.      Advanced AI and Edge Computing:

o Implement federated learning

o Deploy complex AI models to edge devices

3.      Comprehensive Web3 Features:

o Fully developed token economy

o Decentralized governance features

Implementation Strategy:

1.      Start with a monolithic architecture for the MVP, focusing on core functionalities.

2.      Gradually refactor into a microservices architecture as you add more complex features.

3.      Introduce edge computing elements incrementally, starting with non-critical features.

4.      Implement Web3 features cautiously, ensuring they add tangible value before full integration.

Key Considerations:

·         Ensure each phase delivers value to users and gathers meaningful feedback.

·         Maintain flexibility in the architecture to accommodate future changes.

·         Prioritize security and data privacy from the beginning.

·         Continuously reassess the roadmap based on user feedback and technological advancements.

This phased approach allows you to quickly launch a functional product while laying the groundwork for more advanced features. It also provides opportunities to pivot or adjust your strategy based on real-world usage and feedback.

7.4    Coding for Prototype

Let us focus on MVP prototyping with Python to code the five points in MVP: (1) core services, (2) web frontend, (3) api RESTful endpoints, (4) PostgreSQL, and (5) keyword matching for recommendations.

We'll start by providing a basic implementation for the core services of the MVP using Python. We'll use Flask for the web framework and SQLAlchemy for database interactions. This implementation will cover the basic structure for user authentication, job/course listings, and a simple matching algorithm.

Let's begin with the core services:

python

# app.py

from flask import Flask, request, jsonify

from flask_sqlalchemy import SQLAlchemy

from werkzeug.security import generate_password_hash, check_password_hash

import os

app = Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL', 'postgresql://localhost/mvp_db')

app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

# Models

class User(db.Model):

id = db.Column(db.Integer, primary_key=True)

username = db.Column(db.String(80), unique=True, nullable=False)

email = db.Column(db.String(120), unique=True, nullable=False)

password_hash = db.Column(db.String(128))

def set_password(self, password):

     self.password_hash = generate_password_hash(password)

def check_password(self, password):

     return check_password_hash(self.password_hash, password)

class Job(db.Model):

id = db.Column(db.Integer, primary_key=True)

title = db.Column(db.String(100), nullable=False)

description = db.Column(db.Text, nullable=False)

keywords = db.Column(db.String(200))

class Course(db.Model):

id = db.Column(db.Integer, primary_key=True)

title = db.Column(db.String(100), nullable=False)

description = db.Column(db.Text, nullable=False)

keywords = db.Column(db.String(200))

# Routes

@app.route('/register', methods=['POST'])

def register():

data = request.json

user = User(username=data['username'], email=data['email'])

user.set_password(data['password'])

db.session.add(user)

db.session.commit()

return jsonify({'message': 'User registered successfully'}), 201

@app.route('/login', methods=['POST'])

def login():

data = request.json

user = User.query.filter_by(username=data['username']).first()

if user and user.check_password(data['password']):

     return jsonify({'message': 'Login successful'}), 200

return jsonify({'message': 'Invalid credentials'}), 401

@app.route('/jobs', methods=['GET'])

def get_jobs():

jobs = Job.query.all()

return jsonify([{'id': job.id, 'title': job.title, 'description': job.description} for job in jobs])

@app.route('/courses', methods=['GET'])

def get_courses():

courses = Course.query.all()

return jsonify([{'id': course.id, 'title': course.title, 'description': course.description} for course in courses])

@app.route('/recommend', methods=['POST'])

def recommend():

data = request.json

keywords = data['keywords'].split(',')

jobs = Job.query.filter(Job.keywords.contains(keywords[0])).all()

courses = Course.query.filter(Course.keywords.contains(keywords[0])).all()

return jsonify({

     'jobs': [{'id': job.id, 'title': job.title} for job in jobs],

     'courses': [{'id': course.id, 'title': course.title} for course in courses]

})

if __name__ == '__main__':

db.create_all()

app.run(debug=True)

This code provides a basic structure for the core services. Here's a breakdown of what it includes:

1. User, Job, and Course models for database structure.

2. Routes for user registration and login.

3. Routes to get all jobs and courses.

4. A simple recommendation route based on keywords.

To complete the MVP, we'll need to add the following:

1. Web Frontend: We can use a frontend framework like React or Vue.js, or for simplicity, you can use Flask's template rendering with HTML and JavaScript.

2. API RESTful endpoints: The current implementation already includes basic RESTful endpoints. You may want to expand these based on your specific needs.

3. PostgreSQL: The code is set up to use PostgreSQL. We'll need to set up a PostgreSQL database and set the DATABASE_URL environment variable.

4. Keyword matching for recommendations: A basic keyword matching is implemented in the /recommend route. This can be enhanced with more sophisticated matching algorithms as needed.

To run this MVP:

1. Install required packages: pip install flask flask_sqlalchemy psycopg2

2. Set up a PostgreSQL database and set the DATABASE_URL environment variable.

3. Run the application: python app.py

This provides a starting point for your MVP. We can expand on this structure, add more sophisticated matching algorithms, and enhance the frontend as you move forward with our development.

7.5      Database Setup for Prototype

7.5.1      Database installation

For Windows:

1.      Go to the official PostgreSQL download page: https://www.postgresql.org/download/windows/

2.      Click on the download link for the installer.

3.      Once downloaded, run the installer.

4.      Follow the installation wizard:

o Choose your installation directory

o Select the components you want to install (you can usually keep the default selections)

o Choose a data directory

o Enter a password for the database superuser (remember this： admin)

o Select the port number (default is usually fine)

o Select the locale (default is usually fine)

5.      Complete the installation.

For Linux (Ubuntu/Debian):

1.      Open a terminal window.

2.      Update your system's package list:

sudo apt update

3.      Install PostgreSQL:

sudo apt install postgresql postgresql-contrib

4.      PostgreSQL should start automatically. You can verify it's running with:

sudo systemctl status postgresql

Here is installation info on Windows:

Installation Directory: C:\Program Files\PostgreSQL\16

Server Installation Directory: C:\Program Files\PostgreSQL\16

Data Directory: D:\QIData\sql

Database Port: 5432

Database Superuser: postgres

Operating System Account: NT AUTHORITY\NetworkService

Database Service: postgresql-x64-16

Command Line Tools Installation Directory: C:\Program Files\PostgreSQL\16

pgAdmin4 Installation Directory: C:\Program Files\PostgreSQL\16\pgAdmin 4

Stack Builder Installation Directory: C:\Program Files\PostgreSQL\16

Installation Log: C:\Users\Charlie\AppData\Local\Temp\install-postgresql.log

After Installation (for all systems):

1.      On Windows, to access PostgreSQL, you first “C:\Program Files\PostgreSQL\16\bin” as path environment variable.  Note that use the psql with no other parameters under command-line tool will prompt you for password, and neither “postgres” or “admin” as password will work.  You must do the following: (the following command line is important!)

psql -U postgres

2.      You'll be prompted for the password I set during installation, “admin”.

3.      To create a new database for your project:

CREATE DATABASE mvpdb;

CREATE USER Charlie WITH PASSWORD 'admin';

CREATE DATABASE mvpdb OWNER Charlie;

It responds as follows:

CREATE ROLE

CREATE DATABASE

4.      To connect to your new database:

\c mvpdb

It responds with “您现在已经连接到数据库 "mvpdb",用户 "postgres"”.

5.      Now you can run the SQL commands we discussed below in the database schema to create your tables.

Additional Tools:

·         pgAdmin: A popular GUI tool for managing PostgreSQL databases. You can download it from https://www.pgadmin.org/download/

·         DBeaver: Another excellent database tool that supports PostgreSQL and many other database systems. Available at https://dbeaver.io/download/

Remember to note down the following details during installation:

·         The port number PostgreSQL is running on (default is usually 5432)

·         The password for the 'postgres' superuser

·         The name of the database you create for your project

These details will be needed when you configure your Flask application to connect to the database.

7.5.2      Database Schema

Designing a database schema is an important step in building your application. Based on the core services we've outlined earlier, a PostgreSQL schema is created for our job-seeking and training platform. This schema will cover the basic entities we've discussed and allow for future expansion.

Here's a SQL script to create the database schema:

sql

-- Create Users table

CREATE TABLE users (

id SERIAL PRIMARY KEY,

username VARCHAR(80) UNIQUE NOT NULL,

email VARCHAR(120) UNIQUE NOT NULL,

password_hash VARCHAR(128) NOT NULL,

created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP

);

-- Create Jobs table

CREATE TABLE jobs (

id SERIAL PRIMARY KEY,

title VARCHAR(100) NOT NULL,

description TEXT NOT NULL,

company VARCHAR(100),

location VARCHAR(100),

salary_range VARCHAR(50),

keywords TEXT,

created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP

);

-- Create Courses table

CREATE TABLE courses (

id SERIAL PRIMARY KEY,

title VARCHAR(100) NOT NULL,

description TEXT NOT NULL,

instructor VARCHAR(100),

duration VARCHAR(50),

level VARCHAR(20),

keywords TEXT,

created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP

);

-- Create UserProfiles table for additional user information

CREATE TABLE user_profiles (

id SERIAL PRIMARY KEY,

user_id INTEGER UNIQUE NOT NULL,

full_name VARCHAR(100),

bio TEXT,

skills TEXT,

experience TEXT,

education TEXT,

FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE

);

-- Create JobApplications table to track job applications

CREATE TABLE job_applications (

id SERIAL PRIMARY KEY,

user_id INTEGER NOT NULL,

job_id INTEGER NOT NULL,

status VARCHAR(20) DEFAULT 'applied',

applied_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,

FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE,

FOREIGN KEY (job_id) REFERENCES jobs (id) ON DELETE CASCADE

);

-- Create CourseEnrollments table to track course enrollments

CREATE TABLE course_enrollments (

id SERIAL PRIMARY KEY,

user_id INTEGER NOT NULL,

course_id INTEGER NOT NULL,

status VARCHAR(20) DEFAULT 'enrolled',

enrolled_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,

FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE,

FOREIGN KEY (course_id) REFERENCES courses (id) ON DELETE CASCADE

);

-- Create index on commonly searched fields

CREATE INDEX idx_job_keywords ON jobs USING GIN (to_tsvector('english', keywords));

CREATE INDEX idx_course_keywords ON courses USING GIN (to_tsvector('english', keywords));

This schema includes:

1.      users: Stores basic user information.

2.      jobs: Stores job listings.

3.      courses: Stores course information.

4.      user_profiles: Stores additional user information, linked to the users table.

5.      job_applications: Tracks job applications made by users.

6.      course_enrollments: Tracks course enrollments by users.

Key features:

·         Use of SERIAL for auto-incrementing primary keys.

·         TIMESTAMP WITH TIME ZONE for all date fields to handle different time zones.

·         FOREIGN KEY constraints to maintain referential integrity.

·         Text search indexes on keywords fields for efficient searching.

To use this schema:

1.      Connect to your PostgreSQL database.

postgres=# \c mvpdb 您现在已经连接到数据库 "mvpdb",用户 "postgres".

2.      Run this SQL script to create the tables and indexes.

mvpdb=# \i D:\QIData\sql\script.sql

D:: Permission denied （this is because you use “\” instead of “/”）

mvpdb=# \i D:/QIData/sql/script.sql

(no error message! But when validate with “\dt”, the system says no relation found.  I then copied the sql statements in the script.sql file ONE-BY-ONE after the mvpdb=#, and that works.  Cloude checked my script.sql and suggested several possibilities of mistakes of the file, but I kind of lazy to check.  Although I understand in the future it is still important to find out why.)

Here is Cloude’s suggestion:

Given that the commands work when executed one-by-one but not when run as a script, the issue might be related to how PostgreSQL is processing the file. Here are a few potential reasons and solutions:

a.       Encoding Issues: Sometimes, file encoding can cause problems. Ensure your script.sql is saved with UTF-8 encoding without BOM (Byte Order Mark).

b.      Line Endings: Different operating systems use different line endings. Make sure your file uses the correct line endings for your system (Windows usually uses CRLF, while Unix-like systems use LF).

c.       Transaction Handling: Try wrapping the entire script in a transaction block:

sql

BEGIN;

-- Your existing SQL commands here

COMMIT;

Add these lines at the beginning and end of your script.

d.      Error Handling: Add error handling to your script:

sql

\set ON_ERROR_STOP on

Add this line at the beginning of your script. This will cause psql to stop if it encounters an error.

e.       Verbose Output: Add this to the beginning of your script to see more detailed output:

sql

\set ECHO all

f.        Semicolons: Ensure each command ends with a semicolon. Your script looks good in this regard, but it's worth double-checking.

g.      File Permissions: Make sure the PostgreSQL service has read permissions for the script file.

h.      Try psql Command Line: Instead of using \i in psql, try running the script directly from the command line:

psql -U postgres -d mvpdb -f D:/QIData/sql/script.sql

This might provide more informative error messages if there are any issues.

i.        Check for Hidden Characters: Open the file in a text editor that can show hidden characters to ensure there are no unexpected characters in the file.

3.      Update the schema

If you make a mistake or want to start over, you can update the schema, drop the database and recreate it:

sql

DROP DATABASE mvpdb;

CREATE DATABASE mvpdb;

\c mvpdb

Then run your script again.

4.      Update your Flask application's models to match this schema.

Here's how you might update your Flask models to reflect this schema:

python

from datetime import datetime

from app import db

class User(db.Model):

__tablename__ = 'users'

id = db.Column(db.Integer, primary_key=True)

username = db.Column(db.String(80), unique=True, nullable=False)

email = db.Column(db.String(120), unique=True, nullable=False)

password_hash = db.Column(db.String(128), nullable=False)

created_at = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)

class Job(db.Model):

__tablename__ = 'jobs'

id = db.Column(db.Integer, primary_key=True)

title = db.Column(db.String(100), nullable=False)

description = db.Column(db.Text, nullable=False)

company = db.Column(db.String(100))

location = db.Column(db.String(100))

salary_range = db.Column(db.String(50))

keywords = db.Column(db.Text)

created_at = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)

class Course(db.Model):

__tablename__ = 'courses'

id = db.Column(db.Integer, primary_key=True)

title = db.Column(db.String(100), nullable=False)

description = db.Column(db.Text, nullable=False)

instructor = db.Column(db.String(100))

duration = db.Column(db.String(50))

level = db.Column(db.String(20))

keywords = db.Column(db.Text)

created_at = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)

# Add models for UserProfile, JobApplication, and CourseEnrollment as needed

This schema provides a solid foundation for your application. As you develop further, you may need to add more tables or columns to meet additional requirements.

7.6         RESTful Endpoints for Prototype Core Functions

7.6.1      What Are RESTful Endpoints?

RESTful endpoints are an important part of web applications because they define how the application interacts with clients through HTTP methods. These endpoints allow clients to perform CRUD (Create, Read, Update, Delete) operations on resources such as users, jobs, courses, etc.

Here are the RESTful endpoints for the core functions of your application:

a.       User Management:

1. 1. Register: POST /register

   2. Login: POST /login

   3. Delete User: DELETE /delete_user/<int:user_id>

b.      Job Management:

2. 1. Get All Jobs: GET /jobs

   2. Get Job by ID: GET /jobs/<int:job_id>

   3. Create Job: POST /jobs

   4. Update Job: PUT /jobs/<int:job_id>

   5. Delete Job: DELETE /jobs/<int:job_id>

c.       Course Management:

3. 1. Get All Courses: GET /courses

   2. Get Course by ID: GET /courses/<int:course_id>

   3. Create Course: POST /courses

   4. Update Course: PUT /courses/<int:course_id>

   5. Delete Course: DELETE /courses/<int:course_id>

d.      Job Application Management:

4. 1. Apply for Job: POST /apply

   2. Get All Applications for User: GET /applications/<int:user_id>

   3. Update Application Status: PUT /applications/<int:application_id>

   4. Delete Application: DELETE /applications/<int:application_id>

e.       Course Enrollment Management:

5. 1. Enroll in Course: POST /enroll

   2. Get All Enrollments for User: GET /enrollments/<int:user_id>

   3. Update Enrollment Status: PUT /enrollments/<int:enrollment_id>

   4. Delete Enrollment: DELETE /enrollments/<int:enrollment_id>

7.6.2      Why RESTful Endpoints Are Important

1. Standardization: They provide a standardized way of accessing and manipulating resources.

2. Separation of Concerns: They separate the client and server concerns, making the application more modular and easier to maintain.

3. Scalability: They allow for better scalability as the application can handle more clients by using stateless HTTP methods.

4. Interoperability: They enable interoperability between different systems and platforms as they adhere to standard HTTP methods and conventions.

7.6.3      Coding RESTful Endpoints in Flask

Here’s how you can code these endpoints in your app.py:

7.6.4      User Management Endpoints

python

@app.route('/register', methods=['POST'])

def register():

data = request.json

user = User(username=data['username'], email=data['email'])

user.set_password(data['password'])

db.session.add(user)

db.session.commit()

return jsonify({'message': 'User registered successfully'}), 201

@app.route('/login', methods=['POST'])

def login():

data = request.json

user = User.query.filter_by(username=data['username']).first()

if user and user.check_password(data['password']):

     return jsonify({'message': 'Login successful'}), 200

return jsonify({'message': 'Invalid credentials'}), 401

@app.route('/delete_user/<int:user_id>', methods=['DELETE'])

def delete_user(user_id):

user = User.query.get(user_id)

if user:

     db.session.delete(user)

     db.session.commit()

     return jsonify({'message': 'User deleted successfully'}), 200

return jsonify({'message': 'User not found'}), 404

7.6.5      Job Management Endpoints

python

@app.route('/jobs', methods=['GET'])

def get_jobs():

jobs = Job.query.all()

return jsonify([job.to_dict() for job in jobs])

@app.route('/jobs/<int:job_id>', methods=['GET'])

def get_job(job_id):

job = Job.query.get(job_id)

if job:

     return jsonify(job.to_dict())

return jsonify({'message': 'Job not found'}), 404

@app.route('/jobs', methods=['POST'])

def create_job():

data = request.json

job = Job(**data)

db.session.add(job)

db.session.commit()

return jsonify({'message': 'Job created successfully'}), 201

@app.route('/jobs/<int:job_id>', methods=['PUT'])

def update_job(job_id):

data = request.json

job = Job.query.get(job_id)

if job:

     for key, value in data.items():

         setattr(job, key, value)

     db.session.commit()

     return jsonify({'message': 'Job updated successfully'}), 200

return jsonify({'message': 'Job not found'}), 404

@app.route('/jobs/<int:job_id>', methods=['DELETE'])

def delete_job(job_id):

job = Job.query.get(job_id)

if job:

     db.session.delete(job)

     db.session.commit()

     return jsonify({'message': 'Job deleted successfully'}), 200

return jsonify({'message': 'Job not found'}), 404

7.6.6      Course Management Endpoints

python

@app.route('/courses', methods=['GET'])

def get_courses():

courses = Course.query.all()

return jsonify([course.to_dict() for course in courses])

@app.route('/courses/<int:course_id>', methods=['GET'])

def get_course(course_id):

course = Course.query.get(course_id)

if course:

     return jsonify(course.to_dict())

return jsonify({'message': 'Course not found'}), 404

@app.route('/courses', methods=['POST'])

def create_course():

data = request.json

course = Course(**data)

db.session.add(course)

db.session.commit()

return jsonify({'message': 'Course created successfully'}), 201

@app.route('/courses/<int:course_id>', methods=['PUT'])

def update_course(course_id):

data = request.json

course = Course.query.get(course_id)

if course:

     for key, value in data.items():

         setattr(course, key, value)

     db.session.commit()

     return jsonify({'message': 'Course updated successfully'}), 200

return jsonify({'message': 'Course not found'}), 404

@app.route('/courses/<int:course_id>', methods=['DELETE'])

def delete_course(course_id):

course = Course.query.get(course_id)

if course:

     db.session.delete(course)

     db.session.commit()

     return jsonify({'message': 'Course deleted successfully'}), 200

return jsonify({'message': 'Course not found'}), 404