### User Endpoints
We will continue implementing functionality for our endpoints. Let's start with the User. Let's quickly define the GET methods and specify the schemas in the Blueprint response decorators.
``` python
# resource/user.py

@blp.route("/users/<int:user_id>")
class User(MethodView):
    @blp.response(200, UserSchema)
    def get(self, user_id):
        return UserModel.query.get_or_404(user_id)


@blp.route("/users/")
class UserList(MethodView):
    @blp.response(200, UserSchema(many=True))
    def get(self):
        return UserModel.query.all()
```


### Player Endpoints
Now let's move on to Player. We quickly define the GET methods and import models and schema in the <u>resources/player.py</u>.
``` python
blp = Blueprint("players", __name__, description="Operations on the players")

@blp.route("/players/<int:player_id>")
class Player(MethodView):
    @blp.response(200, PlayerSchema)
    def get(self, player_id):
        return PlayerModel.query.get_or_404(player_id)


@blp.route("/players/")
class PlayerList(MethodView):
    @blp.response(200, PlayerSchema(many=True))
    def get(self):
        return PlayerModel.query.all()
```

#### DELETE Method
let's handle the DELETE method. We literally repeat the functionality from the TeamView.
``` python
@blp.route("/players/<int:player_id>")
class Player(MethodView):
    ...

    def delete(self, player_id):
        player = PlayerModel.query.get_or_404(player_id)
        db.session.delete(player)
        db.session.commit()
        return {"message": "Player deleted"}
```

#### CREATE Method
``` python
@blp.route("/players/")
class PlayerList(MethodView):
    ...

    @blp.arguments(PlayerSchema)
    @blp.response(201, PlayerSchema)
    def post(self, player_data):
        player = PlayerModel(**player_data)

        try:
            db.session.add(player)
            db.session.commit()
        except IntegrityError as er:
            abort(400, message=er)
        except SQLAlchemyError as er:
            abort(500, message=er)

        return player
```

#### UPDATE Method
``` python
@blp.route("/players/<int:player_id>")
class Player(MethodView):
    ...

    @blp.arguments(PlayerUpdateSchema)
    @blp.response(200, PlayerSchema)
    def put(self, player_data, player_id):
        player = PlayerModel.query.get(player_id)

        if player:
            player.first_name = player_data["first_name"] or player.first_name
            player.last_name = player_data["last_name"] or player.last_name
            player.position = player_data["position"] or player.position
            player.number = player_data["number"] or player.number
        else:
            player = PlayerModel(**player_data)

            db.session.add(player)

        db.session.commit()

        return player
```

In the next chapter, we will get acquainted with new functionality for the quick and convenient creation of documentation for our API.

This meticulously crafted course takes you from the foundational principles of APIs and REST, through the complexities of database relationships and schema management, to the intricacies of endpoint creation, authentication, and deployment. With a hands-on approach, you'll master Flask, SQLAlchemy, Flask-Smorest, and JWT authentication, culminating in a fully functional, secure, and deployable web API. Whether you're a beginner eager to dive into the world of web development or a seasoned programmer looking to refine your skills, this course offers a comprehensive, engaging, and practical learning experience, setting you up for professional success.

Dive into the world of web APIs with Flask, starting with the basics. You'll learn what APIs and REST APIs are, how to set up your project, configure your environment, and establish a GitHub SSH connection. This foundational knowledge will set you up for success.

Explore the core of database handling with SQLAlchemy. You'll learn to create robust models and understand many-to-one, one-to-one, and many-to-many relationships. This section empowers you with the skills to structure complex databases for real-world applications.

Unveil the power of Flask-Smorest and Marshmallow for managing web APIs and data serialization. You'll delve into JSON, schema handling, and the intricacies of data representation and validation, paving the way for advanced API development.

Master the art of creating and managing endpoints with Flask's Blueprints and MethodView. From setting up your first endpoints to exploring Flask-Migration and SQLite Studio, and utilizing tools like Postman and Insomnia, you'll craft scalable and maintainable web architectures.

Secure your web APIs with JWT authentication. Learn to set up Flask-JWT-Extended, handle user registration, login, and logout processes, and implement permissions and security measures. By the end of this section, you'll be adept at protecting and testing your endpoints.

Prepare your Flask project for deployment. This final leap covers the essentials: creating a requirements.txt, code formatting with Black and Flake8, and documenting your project with a README.md. You'll also master Git for version control and branch merging, readying you for a seamless project launch.

Professional Web API with Flask

User and Player Endpoints

User Endpoints

Player Endpoints

DELETE Method

CREATE Method

UPDATE Method