Cara Membuat CRUD menggunakan Flask API dengan model MVC + PostgreSQL + Automapping Database

Jika anda baru dalam hal pemrograman, anda mungkin terbiasa menulis kode dalam satu file lalu tekan tombol run dan boom selesai! Namun tidak demikian jika anda membuat aplikasi yang terorganisir dengan banyak fitur. Umumnya secara praktek adalah selalu mengikuti pola desain perangkat lunak meskipun aplikasinya kecil, di masa depan jika anda ingin menambahkan beberapa fitur maka akan lebih mudah untuk ditambahkan jika codingan anda dalam model MVC karena kode anda akan lebih terorganisir, teratur, fleksibel dan dapat digunakan kembali.

Mengapa harus menggunakan pola model MVC dipembuatan aplikasi?

Jika anda tidak mengikuti pola ini mungkin anda akan terjebak dalam beberapa jenis masalah ketika akan mengembangkan aplikasi. Seperti saya, ketika saya mulai belajar, ketika saya harus mengembangkan aplikasi dan melihat kembali codingan saya itu sangat sulit karena semuanya terdapat pada satu file yang sama. Tidak hanya itu satu perubahan kecil bisa menyebabkan masalah pada fitur yang lain karena pada satu file yang sama. Ada banyak pola desain perangkat lunak tetapi MVC memberikan ide bahwa "separation of concerns." saya akan mengikutinya di sini. "separation of concerns" adalah prinsip desain untuk memisahkan program komputer menjadi bagian-bagian yang berbeda. Setiap bagian membahas sesuatu yang terpisah, satu set informasi yang mempengaruhi kode program komputer.

Bagaimana ini akan membantu Anda?

Saya telah membuat Flask API sederhana dengan database PostgreSQL menggunakan pola desain MVC. Untuk menggunakan database PostgreSQL saya menggunakan package flask-sqlalchemy yang merupakan ORM (object-relational mapper) yang populer, yang merupakan cara untuk memetakan tabel database ke objek python. Itu membuatnya lebih mudah untuk bekerja dengan database. Sederhananya:

Arsitektur MVC membantu kita untuk mengontrol kompleksitas aplikasi dengan membaginya menjadi tiga komponen yaitu model, view dan controller

Alat dan teknologi yang digunakan adalah:

• Python
• Flask
• PostgreSQL
• Flask-sqlalchemy

File dan Directory Structure

File tree struktur

Database File (database.py)

File ini berisi konfigurasi untuk database. Semua koneksi database di konfigurasikan disini. Anda dapat menambahkan variable baru dengan nama yang berbeda jika anda ingin menggunakan multi database.

#postgresql://username:password@host/dbname
DB_TEST = "postgresql://postgres:postgres@127.0.0.1/test"

Konfigurasi File (config.py)

File ini berisi konfigurasi aplikasi. Anda bisa meletakan variable apapun yang sifatnya global ataupun yang lainnya. Seperti variable database, ftp configurasi dan lain lain.

import os

# Each Flask web application contains a secret key which used to sign session cookies for protection against cookie data tampering.
SECRET_KEY = os.urandom(32)

# Grabs the folder where the script runs.
# In my case it is, "F:\DataScience_Ai\hobby_projects\mvc_project\src"
basedir = os.path.abspath(os.path.dirname(__file__))

# Enable debug mode, that will refresh the page when you make changes.
DEBUG = True

# FTP Synology Configuration
FTP_HOSTNAME = "127.0.01"
FTP_USERNAME = "root"
FTP_PASSWORD = "root"
FTP_PORT     = 22
FTP_LOCAL_DIR     = basedir + "\\files"
FTP_SERVER_DIR     = "/test_python"

Model File (db_test.py)

Model adalah inti dari aplikasi. Ini akan menentukan data yang ditransfer antara controller dan logika bisnis lainnya. Hanya model yang memiliki akses langsung ke database. Model mengakses database secara langsung dan data tersebut digunakan oleh controllers. Pada Kasus ini saya menggunakan fitur automapping karena saya sudah memiliki database dan didalamnya sudah terdapat table beserta datanya.

from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine
import database

Base = automap_base()

# engine, suppose it has two tables 'user' and 'address' set up
engine = create_engine(database.DB_PCMSV3)

# reflect the tables
Base.prepare(engine, reflect=True)

# mapped classes are now created with names by default
# matching that of the table name.
User = Base.classes.table_user

# attrs = vars(User)
# print(', '.join("%s: %s" % item for item in attrs.items()))

session_test = Session(engine)

Bisa dilihar bagian variable User. Pada baris tersebut saya menyimpan strukture table table_user kedalam variable User.

Service File (user_service.py)

Anda dapat menyebutnya sebagai lapisan tambahan di atas controllers. Akan sangat membantu ketika aplikasi Anda berkembang dan lebih banyak fitur ditambahkan ke dalamnya, ini adalah praktik yang lebih baik untuk memisahkan logika bisnis dari aplikasi. Services menambahkan lapisan abstraksi tambahan antara aplikasi dan logika bisnis. Ini memiliki logika bisnis inti. Services biasanya berisi query yang digunakan untuk manajemen data di database. function pada service dapatberulang kali dipanggil di controllers.

from models.db_test import session_test, User
from sqlalchemy import select, update, delete, insert, and_

def user_list_process(where = None):
  statement = select(User)
  if where != None:
    statement = statement.where(and_(*where))
  
  datadb = session_test.execute(statement).scalars().all()
  
  result = []
  for row in datadb:
    tmp = {}
    for attribute, value in row.__dict__.items():
      # print(attribute, '=', value)
      if attribute != '_sa_instance_state':
        tmp[attribute] = value
    # print(tmp)
    result.append(tmp)
  return result

def user_insert_process(value):
  statement = insert(User)
  statement = statement.values(**value)

  session_test.execute(statement)
  session_test.commit()

def user_update_process(value, where):
  statement = update(User)
  statement = statement.where(and_(*where))
  statement = statement.values(**value)

  session_test.execute(statement)
  session_test.commit()

def user_delete_process(where):
  statement = delete(User)
  statement = statement.where(and_(*where))

  session.execute(statement)
  session.commit()

Controllers File (userController.py)

Kontroler seperti perantara antara view dan model. Mereka mengambil input dan berbicara langsung dengan model yang akan berkomunikasi dengan database. Di sini Anda hanya memanggil logika bisnis dari services. Controller tidak berkomunikasi langsung dengan database ada model antara database dan controller.

from flask import request
from models.portal import User
import services.user_service as user_service
import datetime, json

def user_list():
  user_list = user_service.user_list_process()
  return {
    "user_list": user_list
  }

def user_insert_process():
  data = {
    'name': request.form['name'],
    'gender': request.form['gender'],
    'birth_date': request.form['birth_date'],
  }
  user_service.user_insert_process(data)

  return "Successful"

def user_update_process():
  data = {
    'name': request.form['name'],
    'gender': request.form['gender'],
    'birth_date': request.form['birth_date'],
  }
  user_service.user_update_process(data, [
    User.id_user == request.form['id_user']
  ])
  
  return "Successful"

def user_delete_process(id_user):
  user_service.user_delete_process([
    User.id_user == id_user
  ])
  
  return "Successful"

Routes File (user_bp.py)

Ketika pengguna mengunjungi URL, dia akan diarahkan ke halaman tertentu. Router adalah alamat di mana pengguna akan diarahkan. Misalnya, jika pengguna ingin mengunjungi halaman login maka dia akan mengetik http://localhost:5000/login dibrowsernya. Pada artikel ini kita menggunakan flask API. Anda juga dapat menggunakan FastApi ataupun yang lainnnya.Untuk penggunaan rute yang lebih efisien, kami menggunakan blueprint flask.

from flask import Blueprint
import controllers.userController as userController
user_bp = Blueprint('user_bp', __name__)

user_bp.route('/user_list', methods=['GET'])(userController.user_list) 
user_bp.route('/user_insert_process', methods=['POST'])(user_insert_process)  
user_bp.route('/user_update_process', methods = ['PATCH'])(user_update_process)
user_bp.route('/user_delete_process/<int:id_user>', methods = ['DELETE'])(user_delete_process)

App File (app.py)

Ini adalah file utama aplikasi di flask API. Ini memiliki modul/file yang telah kita buat dan kemudian memanggilnya di sini. Anda harus mendaftarkan blueprint route disini. Dan terakhir menjalankan aplikasi flask API.

from flask import Blueprint
from flask import Flask
from routes.user_bp import user_bp 

import os
 
from flask_cors import CORS 
 
app = Flask(__name__) 
CORS(app) 
app.config.from_object('config') 

app.register_blueprint(user_bp, url_prefix='/user') 
 
if __name__ == '__main__':  # Running the app 
  app.run(host='0.0.0.0', port=5000, debug=True)

Menjalankan Aplikasi Flask API

Setelah semua file dibuat, maka langkah terakhir adalah menjalankannya. Banyak cara untuk menjalankan flask api, mulai dari menggunakan docker, flask run, dan lain lain. Disini saya menggunakan cara yang paling mudah untuk dilakukan. Pertama buka command promt di komputer anda. Lalu atur direktori nya ke direktori aplikasi api yang sudah dibuat, yang berisi app.py. Lalu jalankan perintah py app.py. Maka akan muncul tampilan seperti dibawah ini.

Hasil perintah app.py

Selamat anda sudah selesai membuat CRUD menggunakan FLASK API. Anda bisa mencobanya langsung menggunakan POSTMAN ataupun aplikasi lainnya untuk mencoba API yang sudah anda buat.

Terimakasih telah membaca artikel ini sampai akhir. Sekarang Anda sudah tahu cara membuat flask API dengan struktur MVC. Silakan terapkan dan buat API menarik dengan cara ini. Tolong share ke teman teman anda jika artikel ini bermanfaat untuk anda. Silahkan memberikan komentar tentang pendapat anda ataupun ada yang ini ditanyakan.